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 "CamHwIsp20.h"
19 #include "Isp20Evts.h"
20 #include "rk_isp20_hw.h"
21 #include "Isp20_module_dbg.h"
22 #include "mediactl/mediactl-priv.h"
23 #include <linux/v4l2-subdev.h>
24 #include <sys/mman.h>
25 #ifdef ANDROID_OS
26 #include <cutils/properties.h>
27 #endif
28 #include "SPStreamProcUnit.h"
29 #include "PdafStreamProcUnit.h"
30 #include "CaptureRawData.h"
31 #include "code_to_pixel_format.h"
32 #include "RkAiqCalibDbV2.h"
33 #include "IspParamsSplitter.h"
34 #include "rkisp21-config.h"
35 #include "rkisp3-config.h"
36 #include "rkisp32-config.h"
37 #include "isp3x/Isp3xParams.h"
38
39 namespace RkCam {
40 std::unordered_map<std::string, SmartPtr<rk_aiq_static_info_t>> CamHwIsp20::mCamHwInfos;
41 std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>> CamHwIsp20::mSensorHwInfos;
42 std::unordered_map<std::string, std::string> CamHwIsp20::mFakeCameraName;
43 rk_aiq_isp_hw_info_t CamHwIsp20::mIspHwInfos;
44 rk_aiq_cif_hw_info_t CamHwIsp20::mCifHwInfos;
45 bool CamHwIsp20::mIsMultiIspMode = false;
46 uint16_t CamHwIsp20::mMultiIspExtendedPixel = 0;
47 #ifdef ISP_HW_V30
48 #define CAMHWISP_EFFECT_ISP_POOL_NUM 12
49 #else
50 #define CAMHWISP_EFFECT_ISP_POOL_NUM 6
51 #endif
52 // TODO: Sync 1608 sensor start streaming
53 XCam::Mutex CamHwIsp20::_sync_1608_mutex;
54 bool CamHwIsp20::_sync_1608_done = false;
55
56 // TODO: Init static struct.
57 sensor_info_share_t CamHwIsp20::rk1608_share_inf{};
58
CamHwIsp20()59 CamHwIsp20::CamHwIsp20()
60 : _hdr_mode(0)
61 , _state(CAM_HW_STATE_INVALID)
62 , _is_exit(false)
63 , _linked_to_isp(false)
64 , _linked_to_1608(false)
65 #if defined(ISP_HW_V20)
66 , _ispp_module_init_ens(0)
67 #endif
68 , _sharp_fbc_rotation(RK_AIQ_ROTATION_0)
69 {
70 mNoReadBack = false;
71 #ifndef ANDROID_OS
72 char* valueStr = getenv("normal_no_read_back");
73 if (valueStr) {
74 mNoReadBack = atoi(valueStr) > 0 ? true : false;
75 }
76 #else
77 char property_value[PROPERTY_VALUE_MAX] = {'\0'};
78
79 property_get("persist.vendor.rkisp_no_read_back", property_value, "-1");
80 int val = atoi(property_value);
81 if (val != -1)
82 mNoReadBack = atoi(property_value) > 0 ? true : false;
83 #endif
84 xcam_mem_clear(_fec_drv_mem_ctx);
85 xcam_mem_clear(_ldch_drv_mem_ctx);
86 xcam_mem_clear(_cac_drv_mem_ctx);
87 xcam_mem_clear(fec_mem_info_array);
88 xcam_mem_clear(ldch_mem_info_array);
89 xcam_mem_clear(cac_mem_info_array);
90 xcam_mem_clear(_dbg_drv_mem_ctx);
91 xcam_mem_clear(dbg_mem_info_array);
92 _fec_drv_mem_ctx.type = MEM_TYPE_FEC;
93 _fec_drv_mem_ctx.ops_ctx = this;
94 _fec_drv_mem_ctx.mem_info = (void*)(fec_mem_info_array);
95
96 _ldch_drv_mem_ctx.type = MEM_TYPE_LDCH;
97 _ldch_drv_mem_ctx.ops_ctx = this;
98 _ldch_drv_mem_ctx.mem_info = (void*)(ldch_mem_info_array);
99
100 _cac_drv_mem_ctx.type = MEM_TYPE_CAC;
101 _cac_drv_mem_ctx.ops_ctx = this;
102 _cac_drv_mem_ctx.mem_info = (void*)(cac_mem_info_array);
103
104 _dbg_drv_mem_ctx.type = MEM_TYPE_DBG_INFO;
105 _dbg_drv_mem_ctx.ops_ctx = this;
106 _dbg_drv_mem_ctx.mem_info = (void*)(dbg_mem_info_array);
107
108 xcam_mem_clear(_crop_rect);
109 #ifndef DISABLE_PARAMS_ASSEMBLER
110 mParamsAssembler = new IspParamsAssembler("ISP_PARAMS_ASSEMBLER");
111 #endif
112 mVicapIspPhyLinkSupported = false;
113 mIspStremEvtTh = NULL;
114 mIsGroupMode = false;
115 mIsMain = false;
116 _isp_stream_status = ISP_STREAM_STATUS_INVALID;
117 mEffectIspParamsPool = new RkAiqIspEffParamsPool("ISP_EFF", CAMHWISP_EFFECT_ISP_POOL_NUM);
118 _curIspParamsSeq = 0;
119
120 userSensorWidth = 0;
121 userSensorHeight = 0;
122 userSensorFmtCode = 0;
123 }
124
~CamHwIsp20()125 CamHwIsp20::~CamHwIsp20()
126 {}
127
get_isp_ver(rk_aiq_isp_hw_info_t * hw_info)128 static XCamReturn get_isp_ver(rk_aiq_isp_hw_info_t *hw_info) {
129 XCamReturn ret = XCAM_RETURN_NO_ERROR;
130 struct v4l2_capability cap;
131 V4l2Device vdev(hw_info->isp_info[0].stats_path);
132
133
134 ret = vdev.open();
135 if (ret != XCAM_RETURN_NO_ERROR) {
136 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to open dev (%s)", hw_info->isp_info[0].stats_path);
137 return XCAM_RETURN_ERROR_FAILED;
138 }
139
140 if (vdev.query_cap(cap) == XCAM_RETURN_NO_ERROR) {
141 char *p;
142 p = strrchr((char*)cap.driver, '_');
143 if (p == NULL) {
144 ret = XCAM_RETURN_ERROR_FAILED;
145 goto out;
146 }
147
148 if (*(p + 1) != 'v') {
149 ret = XCAM_RETURN_ERROR_FAILED;
150 goto out;
151 }
152
153 hw_info->hw_ver_info.isp_ver = atoi(p + 2);
154 //awb/aec version?
155 vdev.close();
156 return XCAM_RETURN_NO_ERROR;
157 } else {
158 ret = XCAM_RETURN_ERROR_FAILED;
159 goto out;
160 }
161
162 out:
163 vdev.close();
164 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get isp version failed !");
165 return ret;
166 }
167
get_sensor_caps(rk_sensor_full_info_t * sensor_info)168 static XCamReturn get_sensor_caps(rk_sensor_full_info_t *sensor_info) {
169 struct v4l2_subdev_frame_size_enum fsize_enum;
170 struct v4l2_subdev_mbus_code_enum code_enum;
171 std::vector<uint32_t> formats;
172 rk_frame_fmt_t frameSize;
173 XCamReturn ret = XCAM_RETURN_NO_ERROR;
174
175 V4l2SubDevice vdev(sensor_info->device_name.c_str());
176 ret = vdev.open();
177 if (ret != XCAM_RETURN_NO_ERROR) {
178 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to open dev (%s)", sensor_info->device_name.c_str());
179 return XCAM_RETURN_ERROR_FAILED;
180 }
181 //get module info
182 struct rkmodule_inf *minfo = &(sensor_info->mod_info);
183 if(vdev.io_control(RKMODULE_GET_MODULE_INFO, minfo) < 0) {
184 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "@%s %s: Get sensor module info failed", __FUNCTION__, sensor_info->device_name.c_str());
185 return XCAM_RETURN_ERROR_FAILED;
186 }
187 sensor_info->len_name = std::string(minfo->base.lens);
188
189 #if 0
190 memset(&code_enum, 0, sizeof(code_enum));
191 while (vdev.io_control(VIDIOC_SUBDEV_ENUM_MBUS_CODE, &code_enum) == 0) {
192 formats.push_back(code_enum.code);
193 code_enum.index++;
194 };
195
196 //TODO: sensor driver not supported now
197 for (auto it = formats.begin(); it != formats.end(); ++it) {
198 fsize_enum.pad = 0;
199 fsize_enum.index = 0;
200 fsize_enum.code = *it;
201 while (vdev.io_control(VIDIOC_SUBDEV_ENUM_FRAME_SIZE, &fsize_enum) == 0) {
202 frameSize.format = (rk_aiq_format_t)fsize_enum.code;
203 frameSize.width = fsize_enum.max_width;
204 frameSize.height = fsize_enum.max_height;
205 sensor_info->frame_size.push_back(frameSize);
206 fsize_enum.index++;
207 };
208 }
209 if(!formats.size() || !sensor_info->frame_size.size()) {
210 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "@%s %s: Enum sensor frame size failed", __FUNCTION__, sensor_info->device_name.c_str());
211 ret = XCAM_RETURN_ERROR_FAILED;
212 }
213 #endif
214
215 struct v4l2_subdev_frame_interval_enum fie;
216 memset(&fie, 0, sizeof(fie));
217 while(vdev.io_control(VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL, &fie) == 0) {
218 frameSize.format = (rk_aiq_format_t)fie.code;
219 frameSize.width = fie.width;
220 frameSize.height = fie.height;
221 frameSize.fps = fie.interval.denominator / fie.interval.numerator;
222 frameSize.hdr_mode = fie.reserved[0];
223 sensor_info->frame_size.push_back(frameSize);
224 fie.index++;
225 }
226 if (fie.index == 0)
227 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "@%s %s: Enum sensor frame interval failed", __FUNCTION__, sensor_info->device_name.c_str());
228 vdev.close();
229
230 return ret;
231 }
232
233 static XCamReturn
parse_module_info(rk_sensor_full_info_t * sensor_info)234 parse_module_info(rk_sensor_full_info_t *sensor_info)
235 {
236 // sensor entity name format SHOULD be like this:
237 // m00_b_ov13850 1-0010
238 std::string entity_name(sensor_info->sensor_name);
239
240 if (entity_name.empty())
241 return XCAM_RETURN_ERROR_SENSOR;
242
243 int parse_index = 0;
244
245 if (entity_name.at(parse_index) != 'm') {
246 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%d:parse sensor entity name %s error at %d, please check sensor driver !",
247 __LINE__, entity_name.c_str(), parse_index);
248 return XCAM_RETURN_ERROR_SENSOR;
249 }
250
251 std::string index_str = entity_name.substr (parse_index, 3);
252 sensor_info->module_index_str = index_str;
253
254 parse_index += 3;
255
256 if (entity_name.at(parse_index) != '_') {
257 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%d:parse sensor entity name %s error at %d, please check sensor driver !",
258 __LINE__, entity_name.c_str(), parse_index);
259 return XCAM_RETURN_ERROR_SENSOR;
260 }
261
262 parse_index++;
263
264 if (entity_name.at(parse_index) != 'b' &&
265 entity_name.at(parse_index) != 'f') {
266 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%d:parse sensor entity name %s error at %d, please check sensor driver !",
267 __LINE__, entity_name.c_str(), parse_index);
268 return XCAM_RETURN_ERROR_SENSOR;
269 }
270 sensor_info->phy_module_orient = entity_name.at(parse_index);
271
272 parse_index++;
273
274 if (entity_name.at(parse_index) != '_') {
275 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%d:parse sensor entity name %s error at %d, please check sensor driver !",
276 __LINE__, entity_name.c_str(), parse_index);
277 return XCAM_RETURN_ERROR_SENSOR;
278 }
279
280 parse_index++;
281
282 std::size_t real_name_end = std::string::npos;
283 if ((real_name_end = entity_name.find(' ')) == std::string::npos) {
284 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%d:parse sensor entity name %s error at %d, please check sensor driver !",
285 __LINE__, entity_name.c_str(), parse_index);
286 return XCAM_RETURN_ERROR_SENSOR;
287 }
288
289 std::string real_name_str = entity_name.substr(parse_index, real_name_end - parse_index);
290 sensor_info->module_real_sensor_name = real_name_str;
291
292 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s:%d, real sensor name %s, module ori %c, module id %s",
293 __FUNCTION__, __LINE__, sensor_info->module_real_sensor_name.c_str(),
294 sensor_info->phy_module_orient, sensor_info->module_index_str.c_str());
295
296 return XCAM_RETURN_NO_ERROR;
297 }
298
299 #if defined(__GNUC__) && !defined(__clang__)
300 #pragma GCC diagnostic push
301 #pragma GCC diagnostic ignored "-Wstringop-truncation"
302 #endif
303 #if defined(ISP_HW_V20)
304 static rk_aiq_ispp_t*
get_ispp_subdevs(struct media_device * device,const char * devpath,rk_aiq_ispp_t * ispp_info)305 get_ispp_subdevs(struct media_device *device, const char *devpath, rk_aiq_ispp_t* ispp_info)
306 {
307 media_entity *entity = NULL;
308 const char *entity_name = NULL;
309 int index = 0;
310
311 if(!device || !ispp_info || !devpath)
312 return NULL;
313
314 for(index = 0; index < MAX_CAM_NUM; index++) {
315 if (0 == strlen(ispp_info[index].media_dev_path))
316 break;
317 if (0 == strncmp(ispp_info[index].media_dev_path, devpath, sizeof(ispp_info[index].media_dev_path))) {
318 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp info of path %s exists!", devpath);
319 return &ispp_info[index];
320 }
321 }
322
323 if (index >= MAX_CAM_NUM)
324 return NULL;
325 #if defined(ISP_HW_V30)
326 // parse driver pattern: soc:rkisp0-vir0
327 int model_idx = -1;
328 char* rkispp = strstr(device->info.driver, "rkispp");
329 if (rkispp) {
330 int ispp_idx = atoi(rkispp + strlen("rkispp"));
331 char* vir = strstr(device->info.driver, "vir");
332 if (vir) {
333 int vir_idx = atoi(vir + strlen("vir"));
334 model_idx = ispp_idx * 4 + vir_idx;
335 }
336 }
337
338 if (model_idx == -1) {
339 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "wrong ispp media driver info: %s", device->info.driver);
340 return NULL;
341 }
342
343 ispp_info[index].model_idx = model_idx;
344 #else
345
346 if (strcmp(device->info.model, "rkispp0") == 0 ||
347 strcmp(device->info.model, "rkispp") == 0)
348 ispp_info[index].model_idx = 0;
349 else if (strcmp(device->info.model, "rkispp1") == 0)
350 ispp_info[index].model_idx = 1;
351 else if (strcmp(device->info.model, "rkispp2") == 0)
352 ispp_info[index].model_idx = 2;
353 else if (strcmp(device->info.model, "rkispp3") == 0)
354 ispp_info[index].model_idx = 3;
355 else
356 ispp_info[index].model_idx = -1;
357 #endif
358 strncpy(ispp_info[index].media_dev_path, devpath, sizeof(ispp_info[index].media_dev_path));
359
360 entity = media_get_entity_by_name(device, "rkispp_input_image", strlen("rkispp_input_image"));
361 if(entity) {
362 entity_name = media_entity_get_devname (entity);
363 if(entity_name) {
364 strncpy(ispp_info[index].pp_input_image_path, entity_name, sizeof(ispp_info[index].pp_input_image_path));
365 }
366 }
367 entity = media_get_entity_by_name(device, "rkispp_m_bypass", strlen("rkispp_m_bypass"));
368 if(entity) {
369 entity_name = media_entity_get_devname (entity);
370 if(entity_name) {
371 strncpy(ispp_info[index].pp_m_bypass_path, entity_name, sizeof(ispp_info[index].pp_m_bypass_path));
372 }
373 }
374 entity = media_get_entity_by_name(device, "rkispp_scale0", strlen("rkispp_scale0"));
375 if(entity) {
376 entity_name = media_entity_get_devname (entity);
377 if(entity_name) {
378 strncpy(ispp_info[index].pp_scale0_path, entity_name, sizeof(ispp_info[index].pp_scale0_path));
379 }
380 }
381 entity = media_get_entity_by_name(device, "rkispp_scale1", strlen("rkispp_scale1"));
382 if(entity) {
383 entity_name = media_entity_get_devname (entity);
384 if(entity_name) {
385 strncpy(ispp_info[index].pp_scale1_path, entity_name, sizeof(ispp_info[index].pp_scale1_path));
386 }
387 }
388 entity = media_get_entity_by_name(device, "rkispp_scale2", strlen("rkispp_scale2"));
389 if(entity) {
390 entity_name = media_entity_get_devname (entity);
391 if(entity_name) {
392 strncpy(ispp_info[index].pp_scale2_path, entity_name, sizeof(ispp_info[index].pp_scale2_path));
393 }
394 }
395 entity = media_get_entity_by_name(device, "rkispp_tnr_params", strlen("rkispp_tnr_params"));
396 if(entity) {
397 entity_name = media_entity_get_devname (entity);
398 if(entity_name) {
399 strncpy(ispp_info[index].pp_tnr_params_path, entity_name, sizeof(ispp_info[index].pp_tnr_params_path));
400 }
401 }
402 entity = media_get_entity_by_name(device, "rkispp_tnr_stats", strlen("rkispp_tnr_stats"));
403 if(entity) {
404 entity_name = media_entity_get_devname (entity);
405 if(entity_name) {
406 strncpy(ispp_info[index].pp_tnr_stats_path, entity_name, sizeof(ispp_info[index].pp_tnr_stats_path));
407 }
408 }
409 entity = media_get_entity_by_name(device, "rkispp_nr_params", strlen("rkispp_nr_params"));
410 if(entity) {
411 entity_name = media_entity_get_devname (entity);
412 if(entity_name) {
413 strncpy(ispp_info[index].pp_nr_params_path, entity_name, sizeof(ispp_info[index].pp_nr_params_path));
414 }
415 }
416 entity = media_get_entity_by_name(device, "rkispp_nr_stats", strlen("rkispp_nr_stats"));
417 if(entity) {
418 entity_name = media_entity_get_devname (entity);
419 if(entity_name) {
420 strncpy(ispp_info[index].pp_nr_stats_path, entity_name, sizeof(ispp_info[index].pp_nr_stats_path));
421 }
422 }
423 entity = media_get_entity_by_name(device, "rkispp_fec_params", strlen("rkispp_fec_params"));
424 if(entity) {
425 entity_name = media_entity_get_devname (entity);
426 if(entity_name) {
427 strncpy(ispp_info[index].pp_fec_params_path, entity_name, sizeof(ispp_info[index].pp_fec_params_path));
428 }
429 }
430 entity = media_get_entity_by_name(device, "rkispp-subdev", strlen("rkispp-subdev"));
431 if(entity) {
432 entity_name = media_entity_get_devname (entity);
433 if(entity_name) {
434 strncpy(ispp_info[index].pp_dev_path, entity_name, sizeof(ispp_info[index].pp_dev_path));
435 }
436 }
437
438 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "model(%s): ispp_info(%d): ispp-subdev entity name: %s\n",
439 device->info.model, index,
440 ispp_info[index].pp_dev_path);
441
442 return &ispp_info[index];
443 }
444 #endif
445
446 static rk_aiq_isp_t*
get_isp_subdevs(struct media_device * device,const char * devpath,rk_aiq_isp_t * isp_info)447 get_isp_subdevs(struct media_device *device, const char *devpath, rk_aiq_isp_t* isp_info)
448 {
449 media_entity *entity = NULL;
450 const char *entity_name = NULL;
451 int index = 0;
452 if(!device || !isp_info || !devpath)
453 return NULL;
454
455 for(index = 0; index < MAX_CAM_NUM; index++) {
456 if (0 == strlen(isp_info[index].media_dev_path)) {
457 isp_info[index].logic_id = index;
458 break;
459 }
460 if (0 == strncmp(isp_info[index].media_dev_path, devpath, sizeof(isp_info[index].media_dev_path))) {
461 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp info of path %s exists!", devpath);
462 return &isp_info[index];
463 }
464 }
465 if (index >= MAX_CAM_NUM)
466 return NULL;
467
468 #if defined(ISP_HW_V30)
469 // parse driver pattern: soc:rkisp0-vir0
470 int model_idx = -1;
471 char* rkisp = strstr(device->info.driver, "rkisp");
472 if (rkisp) {
473 char* str_unite = NULL;
474 str_unite = strstr(device->info.driver, "unite");
475 if (str_unite) {
476 model_idx = 0;
477 } else {
478 int isp_idx = atoi(rkisp + strlen("rkisp"));
479 char* vir = strstr(device->info.driver, "vir");
480 if (vir) {
481 int vir_idx = atoi(vir + strlen("vir"));
482 model_idx = isp_idx * 4 + vir_idx;
483 isp_info[index].phy_id = isp_idx;
484 }
485 }
486 }
487
488 if (model_idx == -1) {
489 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "wrong isp media driver info: %s", device->info.driver);
490 return NULL;
491 }
492
493 isp_info[index].model_idx = model_idx;
494 #else
495 if (strcmp(device->info.model, "rkisp0") == 0 ||
496 strcmp(device->info.model, "rkisp") == 0)
497 isp_info[index].model_idx = 0;
498 else if (strcmp(device->info.model, "rkisp1") == 0)
499 isp_info[index].model_idx = 1;
500 else if (strcmp(device->info.model, "rkisp2") == 0)
501 isp_info[index].model_idx = 2;
502 else if (strcmp(device->info.model, "rkisp3") == 0)
503 isp_info[index].model_idx = 3;
504 else
505 isp_info[index].model_idx = -1;
506 #endif
507
508 strncpy(isp_info[index].media_dev_path, devpath, sizeof(isp_info[index].media_dev_path));
509
510 entity = media_get_entity_by_name(device, "rkisp-isp-subdev", strlen("rkisp-isp-subdev"));
511 if(entity) {
512 entity_name = media_entity_get_devname (entity);
513 if(entity_name) {
514 strncpy(isp_info[index].isp_dev_path, entity_name, sizeof(isp_info[index].isp_dev_path));
515 }
516 }
517
518 entity = media_get_entity_by_name(device, "rkisp-csi-subdev", strlen("rkisp-csi-subdev"));
519 if(entity) {
520 entity_name = media_entity_get_devname (entity);
521 if(entity_name) {
522 strncpy(isp_info[index].csi_dev_path, entity_name, sizeof(isp_info[index].csi_dev_path));
523 }
524 }
525 entity = media_get_entity_by_name(device, "rkisp-mpfbc-subdev", strlen("rkisp-mpfbc-subdev"));
526 if(entity) {
527 entity_name = media_entity_get_devname (entity);
528 if(entity_name) {
529 strncpy(isp_info[index].mpfbc_dev_path, entity_name, sizeof(isp_info[index].mpfbc_dev_path));
530 }
531 }
532 entity = media_get_entity_by_name(device, "rkisp_mainpath", strlen("rkisp_mainpath"));
533 if(entity) {
534 entity_name = media_entity_get_devname (entity);
535 if(entity_name) {
536 strncpy(isp_info[index].main_path, entity_name, sizeof(isp_info[index].main_path));
537 }
538 }
539 entity = media_get_entity_by_name(device, "rkisp_selfpath", strlen("rkisp_selfpath"));
540 if(entity) {
541 entity_name = media_entity_get_devname (entity);
542 if(entity_name) {
543 strncpy(isp_info[index].self_path, entity_name, sizeof(isp_info[index].self_path));
544 }
545 }
546 entity = media_get_entity_by_name(device, "rkisp_rawwr0", strlen("rkisp_rawwr0"));
547 if(entity) {
548 entity_name = media_entity_get_devname (entity);
549 if(entity_name) {
550 strncpy(isp_info[index].rawwr0_path, entity_name, sizeof(isp_info[index].rawwr0_path));
551 }
552 }
553 entity = media_get_entity_by_name(device, "rkisp_rawwr1", strlen("rkisp_rawwr1"));
554 if(entity) {
555 entity_name = media_entity_get_devname (entity);
556 if(entity_name) {
557 strncpy(isp_info[index].rawwr1_path, entity_name, sizeof(isp_info[index].rawwr1_path));
558 }
559 }
560 entity = media_get_entity_by_name(device, "rkisp_rawwr2", strlen("rkisp_rawwr2"));
561 if(entity) {
562 entity_name = media_entity_get_devname (entity);
563 if(entity_name) {
564 strncpy(isp_info[index].rawwr2_path, entity_name, sizeof(isp_info[index].rawwr2_path));
565 }
566 }
567 entity = media_get_entity_by_name(device, "rkisp_rawwr3", strlen("rkisp_rawwr3"));
568 if(entity) {
569 entity_name = media_entity_get_devname (entity);
570 if(entity_name) {
571 strncpy(isp_info[index].rawwr3_path, entity_name, sizeof(isp_info[index].rawwr3_path));
572 }
573 }
574 entity = media_get_entity_by_name(device, "rkisp_dmapath", strlen("rkisp_dmapath"));
575 if(entity) {
576 entity_name = media_entity_get_devname (entity);
577 if(entity_name) {
578 strncpy(isp_info[index].dma_path, entity_name, sizeof(isp_info[index].dma_path));
579 }
580 }
581 entity = media_get_entity_by_name(device, "rkisp_rawrd0_m", strlen("rkisp_rawrd0_m"));
582 if(entity) {
583 entity_name = media_entity_get_devname (entity);
584 if(entity_name) {
585 strncpy(isp_info[index].rawrd0_m_path, entity_name, sizeof(isp_info[index].rawrd0_m_path));
586 }
587 }
588 entity = media_get_entity_by_name(device, "rkisp_rawrd1_l", strlen("rkisp_rawrd1_l"));
589 if(entity) {
590 entity_name = media_entity_get_devname (entity);
591 if(entity_name) {
592 strncpy(isp_info[index].rawrd1_l_path, entity_name, sizeof(isp_info[index].rawrd1_l_path));
593 }
594 }
595 entity = media_get_entity_by_name(device, "rkisp_rawrd2_s", strlen("rkisp_rawrd2_s"));
596 if(entity) {
597 entity_name = media_entity_get_devname (entity);
598 if(entity_name) {
599 strncpy(isp_info[index].rawrd2_s_path, entity_name, sizeof(isp_info[index].rawrd2_s_path));
600 }
601 }
602 entity = media_get_entity_by_name(device, "rkisp-statistics", strlen("rkisp-statistics"));
603 if(entity) {
604 entity_name = media_entity_get_devname (entity);
605 if(entity_name) {
606 strncpy(isp_info[index].stats_path, entity_name, sizeof(isp_info[index].stats_path));
607 }
608 }
609 entity = media_get_entity_by_name(device, "rkisp-input-params", strlen("rkisp-input-params"));
610 if(entity) {
611 entity_name = media_entity_get_devname (entity);
612 if(entity_name) {
613 strncpy(isp_info[index].input_params_path, entity_name, sizeof(isp_info[index].input_params_path));
614 }
615 }
616 entity = media_get_entity_by_name(device, "rkisp-mipi-luma", strlen("rkisp-mipi-luma"));
617 if(entity) {
618 entity_name = media_entity_get_devname (entity);
619 if(entity_name) {
620 strncpy(isp_info[index].mipi_luma_path, entity_name, sizeof(isp_info[index].mipi_luma_path));
621 }
622 }
623 entity = media_get_entity_by_name(device, "rockchip-mipi-dphy-rx", strlen("rockchip-mipi-dphy-rx"));
624 if(entity) {
625 entity_name = media_entity_get_devname (entity);
626 if(entity_name) {
627 strncpy(isp_info[index].mipi_dphy_rx_path, entity_name, sizeof(isp_info[index].mipi_dphy_rx_path));
628 }
629 } else {
630 entity = media_get_entity_by_name(device, "rockchip-csi2-dphy0", strlen("rockchip-csi2-dphy0"));
631 if(entity) {
632 entity_name = media_entity_get_devname (entity);
633 if(entity_name) {
634 strncpy(isp_info[index].mipi_dphy_rx_path, entity_name, sizeof(isp_info[index].mipi_dphy_rx_path));
635 }
636 }
637 }
638
639 entity = media_get_entity_by_name(device, "rkcif_dvp", strlen("rkcif_dvp"));
640 if(entity)
641 isp_info[index].linked_dvp = true;
642 else
643 isp_info[index].linked_dvp = false;
644
645 entity = media_get_entity_by_name(device, "rkcif-dvp", strlen("rkcif-dvp"));
646 if(entity)
647 isp_info[index].linked_dvp = true;
648 else
649 isp_info[index].linked_dvp = false;
650
651 const char* linked_entity_name_strs[] = {
652 "rkcif-dvp",
653 "rkcif_dvp",
654 "rkcif_lite_mipi_lvds",
655 "rkcif_mipi_lvds",
656 "rkcif_mipi_lvds1",
657 "rkcif_mipi_lvds2",
658 "rkcif_mipi_lvds3",
659 "rkcif_mipi_lvds4",
660 "rkcif_mipi_lvds5",
661 "rkcif-mipi-lvds",
662 "rkcif-mipi-lvds1",
663 "rkcif-mipi-lvds2",
664 "rkcif-mipi-lvds3",
665 "rkcif-mipi-lvds4",
666 "rkcif-mipi-lvds5",
667 NULL
668 };
669
670 int vicap_idx = 0;
671 for (int i = 0; linked_entity_name_strs[i] != NULL; i++) {
672 entity = media_get_entity_by_name(device, linked_entity_name_strs[i], strlen(linked_entity_name_strs[i]));
673 if (entity) {
674 strncpy(isp_info[index].linked_vicap[vicap_idx], entity->info.name, sizeof(isp_info[index].linked_vicap[vicap_idx]));
675 isp_info[index].linked_sensor = true;
676 if (vicap_idx++ >= MAX_ISP_LINKED_VICAP_CNT) {
677 break;
678 }
679 }
680 }
681
682 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "model(%s): isp_info(%d): ispp-subdev entity name: %s\n",
683 device->info.model, index,
684 isp_info[index].isp_dev_path);
685
686 return &isp_info[index];
687 }
688
689 static rk_aiq_cif_info_t*
get_cif_subdevs(struct media_device * device,const char * devpath,rk_aiq_cif_info_t * cif_info)690 get_cif_subdevs(struct media_device *device, const char *devpath, rk_aiq_cif_info_t* cif_info)
691 {
692 media_entity *entity = NULL;
693 const char *entity_name = NULL;
694 int index = 0;
695 if(!device || !devpath || !cif_info)
696 return NULL;
697
698 for(index = 0; index < MAX_CAM_NUM; index++) {
699 if (0 == strlen(cif_info[index].media_dev_path))
700 break;
701 if (0 == strncmp(cif_info[index].media_dev_path, devpath, sizeof(cif_info[index].media_dev_path))) {
702 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp info of path %s exists!", devpath);
703 return &cif_info[index];
704 }
705 }
706 if (index >= MAX_CAM_NUM)
707 return NULL;
708
709 cif_info[index].model_idx = index;
710
711 strncpy(cif_info[index].media_dev_path, devpath, sizeof(cif_info[index].media_dev_path) - 1);
712
713 entity = media_get_entity_by_name(device, "stream_cif_mipi_id0", strlen("stream_cif_mipi_id0"));
714 if(entity) {
715 entity_name = media_entity_get_devname (entity);
716 if(entity_name) {
717 strncpy(cif_info[index].mipi_id0, entity_name, sizeof(cif_info[index].mipi_id0) - 1);
718 }
719 }
720
721 entity = media_get_entity_by_name(device, "stream_cif_mipi_id1", strlen("stream_cif_mipi_id1"));
722 if(entity) {
723 entity_name = media_entity_get_devname (entity);
724 if(entity_name) {
725 strncpy(cif_info[index].mipi_id1, entity_name, sizeof(cif_info[index].mipi_id1) - 1);
726 }
727 }
728
729 entity = media_get_entity_by_name(device, "stream_cif_mipi_id2", strlen("stream_cif_mipi_id2"));
730 if(entity) {
731 entity_name = media_entity_get_devname (entity);
732 if(entity_name) {
733 strncpy(cif_info[index].mipi_id2, entity_name, sizeof(cif_info[index].mipi_id2) - 1);
734 }
735 }
736
737 entity = media_get_entity_by_name(device, "stream_cif_mipi_id3", strlen("stream_cif_mipi_id3"));
738 if(entity) {
739 entity_name = media_entity_get_devname (entity);
740 if(entity_name) {
741 strncpy(cif_info[index].mipi_id3, entity_name, sizeof(cif_info[index].mipi_id3) - 1);
742 }
743 }
744
745 entity = media_get_entity_by_name(device, "rkcif_scale_ch0", strlen("rkcif_scale_ch0"));
746 if(entity) {
747 entity_name = media_entity_get_devname (entity);
748 if(entity_name) {
749 strncpy(cif_info[index].mipi_scl0, entity_name, sizeof(cif_info[index].mipi_scl0) - 1);
750 }
751 }
752
753 entity = media_get_entity_by_name(device, "rkcif_scale_ch1", strlen("rkcif_scale_ch1"));
754 if(entity) {
755 entity_name = media_entity_get_devname (entity);
756 if(entity_name) {
757 strncpy(cif_info[index].mipi_scl1, entity_name, sizeof(cif_info[index].mipi_scl1) - 1);
758 }
759 }
760
761 entity = media_get_entity_by_name(device, "rkcif_scale_ch2", strlen("rkcif_scale_ch2"));
762 if(entity) {
763 entity_name = media_entity_get_devname (entity);
764 if(entity_name) {
765 strncpy(cif_info[index].mipi_scl2, entity_name, sizeof(cif_info[index].mipi_scl2) - 1);
766 }
767 }
768
769 entity = media_get_entity_by_name(device, "rkcif_scale_ch3", strlen("rkcif_scale_ch3"));
770 if(entity) {
771 entity_name = media_entity_get_devname (entity);
772 if(entity_name) {
773 strncpy(cif_info[index].mipi_scl3, entity_name, sizeof(cif_info[index].mipi_scl3) - 1);
774 }
775 }
776
777 entity = media_get_entity_by_name(device, "stream_cif_dvp_id0", strlen("stream_cif_dvp_id0"));
778 if(entity) {
779 entity_name = media_entity_get_devname (entity);
780 if(entity_name) {
781 strncpy(cif_info[index].dvp_id0, entity_name, sizeof(cif_info[index].dvp_id0) - 1);
782 }
783 }
784
785 entity = media_get_entity_by_name(device, "stream_cif_dvp_id1", strlen("stream_cif_dvp_id1"));
786 if(entity) {
787 entity_name = media_entity_get_devname (entity);
788 if(entity_name) {
789 strncpy(cif_info[index].dvp_id1, entity_name, sizeof(cif_info[index].dvp_id1) - 1);
790 }
791 }
792
793 entity = media_get_entity_by_name(device, "stream_cif_dvp_id2", strlen("stream_cif_dvp_id2"));
794 if(entity) {
795 entity_name = media_entity_get_devname (entity);
796 if(entity_name) {
797 strncpy(cif_info[index].dvp_id2, entity_name, sizeof(cif_info[index].dvp_id2) - 1);
798 }
799 }
800
801 entity = media_get_entity_by_name(device, "stream_cif_dvp_id3", strlen("stream_cif_dvp_id3"));
802 if(entity) {
803 entity_name = media_entity_get_devname (entity);
804 if(entity_name) {
805 strncpy(cif_info[index].dvp_id3, entity_name, sizeof(cif_info[index].dvp_id3) - 1);
806 }
807 }
808
809 entity = media_get_entity_by_name(device, "rkcif-mipi-luma", strlen("rkisp-mipi-luma"));
810 if(entity) {
811 entity_name = media_entity_get_devname (entity);
812 if(entity_name) {
813 strncpy(cif_info[index].mipi_luma_path, entity_name, sizeof(cif_info[index].mipi_luma_path) - 1);
814 }
815 }
816
817 entity = media_get_entity_by_name(device, "rockchip-mipi-csi2", strlen("rockchip-mipi-csi2"));
818 if(entity) {
819 entity_name = media_entity_get_devname (entity);
820 if(entity_name) {
821 strncpy(cif_info[index].mipi_csi2_sd_path, entity_name, sizeof(cif_info[index].mipi_csi2_sd_path) - 1);
822 }
823 }
824
825 entity = media_get_entity_by_name(device, "rkcif-lvds-subdev", strlen("rkcif-lvds-subdev"));
826 if(entity) {
827 entity_name = media_entity_get_devname (entity);
828 if(entity_name) {
829 strncpy(cif_info[index].lvds_sd_path, entity_name, sizeof(cif_info[index].lvds_sd_path) - 1);
830 }
831 }
832
833 entity = media_get_entity_by_name(device, "rkcif-lite-lvds-subdev", strlen("rkcif-lite-lvds-subdev"));
834 if(entity) {
835 entity_name = media_entity_get_devname (entity);
836 if(entity_name) {
837 strncpy(cif_info[index].lvds_sd_path, entity_name, sizeof(cif_info[index].lvds_sd_path) - 1);
838 }
839 }
840
841 entity = media_get_entity_by_name(device, "rockchip-mipi-dphy-rx", strlen("rockchip-mipi-dphy-rx"));
842 if(entity) {
843 entity_name = media_entity_get_devname (entity);
844 if(entity_name) {
845 strncpy(cif_info[index].mipi_dphy_rx_path, entity_name, sizeof(cif_info[index].mipi_dphy_rx_path) - 1);
846 }
847 } else {
848 entity = media_get_entity_by_name(device, "rockchip-csi2-dphy0", strlen("rockchip-csi2-dphy0"));
849 if(entity) {
850 entity_name = media_entity_get_devname (entity);
851 if(entity_name) {
852 strncpy(cif_info[index].mipi_dphy_rx_path, entity_name, sizeof(cif_info[index].mipi_dphy_rx_path) - 1);
853 }
854 }
855 }
856
857 entity = media_get_entity_by_name(device, "stream_cif", strlen("stream_cif"));
858 if(entity) {
859 entity_name = media_entity_get_devname (entity);
860 if(entity_name) {
861 strncpy(cif_info[index].stream_cif_path, entity_name, sizeof(cif_info[index].stream_cif_path) - 1);
862 }
863 }
864
865 entity = media_get_entity_by_name(device, "rkcif-dvp-sof", strlen("rkcif-dvp-sof"));
866 if(entity) {
867 entity_name = media_entity_get_devname (entity);
868 if(entity_name) {
869 strncpy(cif_info[index].dvp_sof_sd_path, entity_name, sizeof(cif_info[index].dvp_sof_sd_path) - 1);
870 }
871 }
872
873 return &cif_info[index];
874 }
875
876
877 static
878 XCamReturn
SensorInfoCopy(rk_sensor_full_info_t * finfo,rk_aiq_static_info_t * info)879 SensorInfoCopy(rk_sensor_full_info_t *finfo, rk_aiq_static_info_t *info) {
880 int fs_num, i = 0;
881 rk_aiq_sensor_info_t *sinfo = NULL;
882
883 //info->media_node_index = finfo->media_node_index;
884 strncpy(info->lens_info.len_name, finfo->len_name.c_str(), sizeof(info->lens_info.len_name));
885 sinfo = &info->sensor_info;
886 strncpy(sinfo->sensor_name, finfo->sensor_name.c_str(), sizeof(sinfo->sensor_name));
887 fs_num = finfo->frame_size.size();
888 if (fs_num) {
889 for (auto iter = finfo->frame_size.begin(); iter != finfo->frame_size.end() && i < 10; ++iter, i++) {
890 sinfo->support_fmt[i].width = (*iter).width;
891 sinfo->support_fmt[i].height = (*iter).height;
892 sinfo->support_fmt[i].format = (*iter).format;
893 sinfo->support_fmt[i].fps = (*iter).fps;
894 sinfo->support_fmt[i].hdr_mode = (*iter).hdr_mode;
895 }
896 sinfo->num = i;
897 }
898
899 if (finfo->module_index_str.size()) {
900 sinfo->phyId = atoi(finfo->module_index_str.c_str() + 1);
901 } else {
902 sinfo->phyId = -1;
903 }
904
905 return XCAM_RETURN_NO_ERROR;
906 }
907
908 XCamReturn
selectIqFile(const char * sns_ent_name,char * iqfile_name)909 CamHwIsp20::selectIqFile(const char* sns_ent_name, char* iqfile_name)
910 {
911 if (!sns_ent_name || !iqfile_name)
912 return XCAM_RETURN_ERROR_SENSOR;
913 const struct rkmodule_base_inf* base_inf = NULL;
914 const char *sensor_name, *module_name, *lens_name;
915 char sensor_name_full[32];
916 std::string str(sns_ent_name);
917
918 auto it = CamHwIsp20::mSensorHwInfos.find(str);
919 if (it == CamHwIsp20::mSensorHwInfos.end()) {
920 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_ent_name);
921 return XCAM_RETURN_ERROR_SENSOR;
922 }
923 base_inf = &(it->second.ptr()->mod_info.base);
924 if (!strlen(base_inf->module) || !strlen(base_inf->sensor) ||
925 !strlen(base_inf->lens)) {
926 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "no camera module info, check the drv !");
927 return XCAM_RETURN_ERROR_SENSOR;
928 }
929 sensor_name = base_inf->sensor;
930 strncpy(sensor_name_full, sensor_name, 32);
931
932 module_name = base_inf->module;
933 lens_name = base_inf->lens;
934 if (strlen(module_name) && strlen(lens_name)) {
935 sprintf(iqfile_name, "%s_%s_%s.json",
936 sensor_name_full, module_name, lens_name);
937 } else {
938 sprintf(iqfile_name, "%s.json", sensor_name_full);
939 }
940
941 return XCAM_RETURN_NO_ERROR;
942 }
943 #if defined(__GNUC__) && !defined(__clang__)
944 #pragma GCC diagnostic pop
945 #endif
946
947 rk_aiq_static_info_t*
getStaticCamHwInfoByPhyId(const char * sns_ent_name,uint16_t index)948 CamHwIsp20::getStaticCamHwInfoByPhyId(const char* sns_ent_name, uint16_t index)
949 {
950 if (sns_ent_name) {
951 std::string str(sns_ent_name);
952
953 auto it = mCamHwInfos.find(str);
954 if (it != mCamHwInfos.end()) {
955 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "find camerainfo of %s!", sns_ent_name);
956 return it->second.ptr();
957 } else {
958 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "camerainfo of %s not fount!", sns_ent_name);
959 }
960 } else {
961 std::string index_str{"m"};
962 if (index < 10) {
963 index_str.append("0");
964 }
965 index_str.append(std::to_string(index));
966 auto it = std::find_if(
967 std::begin(mCamHwInfos), std::end(mCamHwInfos),
968 [&](const std::pair<std::string, SmartPtr<rk_aiq_static_info_t>>& info) -> bool {
969 return !info.first.compare(0, 3, index_str);
970 });
971 if (it != mCamHwInfos.end()) {
972 return it->second.ptr();
973 }
974 }
975
976 return NULL;
977 }
978
979 rk_aiq_static_info_t*
getStaticCamHwInfo(const char * sns_ent_name,uint16_t index)980 CamHwIsp20::getStaticCamHwInfo(const char* sns_ent_name, uint16_t index)
981 {
982 if (sns_ent_name) {
983 std::string str(sns_ent_name);
984
985 auto it = mCamHwInfos.find(str);
986 if (it != mCamHwInfos.end()) {
987 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "find camerainfo of %s!", sns_ent_name);
988 return it->second.ptr();
989 } else {
990 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "camerainfo of %s not fount!", sns_ent_name);
991 }
992 } else {
993 if (index < mCamHwInfos.size()) {
994 int i = 0;
995 for (auto it = mCamHwInfos.begin(); it != mCamHwInfos.end(); it++, i++) {
996 if (i == index)
997 return it->second.ptr();
998 }
999 }
1000 }
1001
1002 return NULL;
1003 }
1004
1005 XCamReturn
clearStaticCamHwInfo()1006 CamHwIsp20::clearStaticCamHwInfo()
1007 {
1008 /* std::map<std::string, SmartPtr<rk_aiq_static_info_t>>::iterator it1; */
1009 /* std::map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it2; */
1010
1011 /* for (it1 = mCamHwInfos.begin(); it1 != mCamHwInfos.end(); it1++) { */
1012 /* rk_aiq_static_info_t *ptr = it1->second.ptr(); */
1013 /* delete ptr; */
1014 /* } */
1015 /* for (it2 = mSensorHwInfos.begin(); it2 != mSensorHwInfos.end(); it2++) { */
1016 /* rk_sensor_full_info_t *ptr = it2->second.ptr(); */
1017 /* delete ptr; */
1018 /* } */
1019 mCamHwInfos.clear();
1020 mSensorHwInfos.clear();
1021
1022 return XCAM_RETURN_NO_ERROR;
1023 }
1024
1025 void
findAttachedSubdevs(struct media_device * device,uint32_t count,rk_sensor_full_info_t * s_info)1026 CamHwIsp20::findAttachedSubdevs(struct media_device *device, uint32_t count, rk_sensor_full_info_t *s_info)
1027 {
1028 const struct media_entity_desc *entity_info = NULL;
1029 struct media_entity *entity = NULL;
1030 uint32_t k;
1031
1032 for (k = 0; k < count; ++k) {
1033 entity = media_get_entity (device, k);
1034 entity_info = media_entity_get_info(entity);
1035 if ((NULL != entity_info) && (entity_info->type == MEDIA_ENT_T_V4L2_SUBDEV_LENS)) {
1036 if ((entity_info->name[0] == 'm') &&
1037 (strncmp(entity_info->name, s_info->module_index_str.c_str(), 3) == 0)) {
1038 if (entity_info->flags == 1)
1039 s_info->module_ircut_dev_name = std::string(media_entity_get_devname(entity));
1040 else//vcm
1041 s_info->module_lens_dev_name = std::string(media_entity_get_devname(entity));
1042 }
1043 } else if ((NULL != entity_info) && (entity_info->type == MEDIA_ENT_T_V4L2_SUBDEV_FLASH)) {
1044 if ((entity_info->name[0] == 'm') &&
1045 (strncmp(entity_info->name, s_info->module_index_str.c_str(), 3) == 0)) {
1046
1047 /* check if entity name has the format string mxx_x_xxx-irxxx */
1048 if (strstr(entity_info->name, "-ir") != NULL) {
1049 s_info->module_flash_ir_dev_name[s_info->flash_ir_num++] =
1050 std::string(media_entity_get_devname(entity));
1051 } else
1052 s_info->module_flash_dev_name[s_info->flash_num++] =
1053 std::string(media_entity_get_devname(entity));
1054 }
1055 }
1056 }
1057 // query flash infos
1058 if (s_info->flash_num) {
1059 SmartPtr<FlashLightHw> fl = new FlashLightHw(s_info->module_flash_dev_name, s_info->flash_num);
1060 fl->init(1);
1061 s_info->fl_strth_adj_sup = fl->isStrengthAdj();
1062 fl->deinit();
1063 }
1064 if (s_info->flash_ir_num) {
1065 SmartPtr<FlashLightHw> fl_ir = new FlashLightHw(s_info->module_flash_ir_dev_name, s_info->flash_ir_num);
1066 fl_ir->init(1);
1067 s_info->fl_ir_strth_adj_sup = fl_ir->isStrengthAdj();
1068 fl_ir->deinit();
1069 }
1070 }
1071
1072 XCamReturn
initCamHwInfos()1073 CamHwIsp20::initCamHwInfos()
1074 {
1075 char sys_path[64], devpath[32];
1076 FILE *fp = NULL;
1077 struct media_device *device = NULL;
1078 int nents, j = 0, i = 0, node_index = 0;
1079 const struct media_entity_desc *entity_info = NULL;
1080 struct media_entity *entity = NULL;
1081
1082 xcam_mem_clear (CamHwIsp20::mIspHwInfos);
1083 xcam_mem_clear (CamHwIsp20::mCifHwInfos);
1084
1085 while (i < MAX_MEDIA_INDEX) {
1086 node_index = i;
1087 snprintf (sys_path, 64, "/dev/media%d", i++);
1088 fp = fopen (sys_path, "r");
1089 if (!fp)
1090 continue;
1091 fclose (fp);
1092 device = media_device_new (sys_path);
1093 if (!device) {
1094 continue;
1095 }
1096
1097 /* Enumerate entities, pads and links. */
1098 media_device_enumerate (device);
1099
1100 rk_aiq_isp_t* isp_info = NULL;
1101 rk_aiq_cif_info_t* cif_info = NULL;
1102 bool dvp_itf = false;
1103 if (strcmp(device->info.model, "rkispp0") == 0 ||
1104 strcmp(device->info.model, "rkispp1") == 0 ||
1105 strcmp(device->info.model, "rkispp2") == 0 ||
1106 strcmp(device->info.model, "rkispp3") == 0 ||
1107 strcmp(device->info.model, "rkispp") == 0) {
1108 #if defined(ISP_HW_V20)
1109 rk_aiq_ispp_t* ispp_info = get_ispp_subdevs(device, sys_path, CamHwIsp20::mIspHwInfos.ispp_info);
1110 if (ispp_info)
1111 ispp_info->valid = true;
1112 #endif
1113 goto media_unref;
1114 } else if (strcmp(device->info.model, "rkisp0") == 0 ||
1115 strcmp(device->info.model, "rkisp1") == 0 ||
1116 strcmp(device->info.model, "rkisp2") == 0 ||
1117 strcmp(device->info.model, "rkisp3") == 0 ||
1118 strcmp(device->info.model, "rkisp") == 0) {
1119 isp_info = get_isp_subdevs(device, sys_path, CamHwIsp20::mIspHwInfos.isp_info);
1120 if (strstr(device->info.driver, "rkisp-unite")) {
1121 isp_info->is_multi_isp_mode = true;
1122 mIsMultiIspMode = true;
1123 mMultiIspExtendedPixel = RKMOUDLE_UNITE_EXTEND_PIXEL;
1124 } else {
1125 isp_info->is_multi_isp_mode = false;
1126 mIsMultiIspMode = false;
1127 mMultiIspExtendedPixel = 0;
1128 }
1129 isp_info->valid = true;
1130 } else if (strcmp(device->info.model, "rkcif") == 0 ||
1131 strcmp(device->info.model, "rkcif-dvp") == 0 ||
1132 strcmp(device->info.model, "rkcif_dvp") == 0 ||
1133 strstr(device->info.model, "rkcif_mipi_lvds") ||
1134 strstr(device->info.model, "rkcif-mipi-lvds") ||
1135 strcmp(device->info.model, "rkcif_lite_mipi_lvds") == 0) {
1136 cif_info = get_cif_subdevs(device, sys_path, CamHwIsp20::mCifHwInfos.cif_info);
1137 strncpy(cif_info->model_str, device->info.model, sizeof(cif_info->model_str));
1138
1139 if (strcmp(device->info.model, "rkcif_dvp") == 0 || strcmp(device->info.model, "rkcif-dvp") == 0)
1140 dvp_itf = true;
1141 } else {
1142 goto media_unref;
1143 }
1144
1145 nents = media_get_entities_count (device);
1146 for (j = 0; j < nents; ++j) {
1147 entity = media_get_entity (device, j);
1148 entity_info = media_entity_get_info(entity);
1149 if ((NULL != entity_info) && (entity_info->type == MEDIA_ENT_T_V4L2_SUBDEV_SENSOR)) {
1150 if (strstr(entity_info->name, "1608")) {
1151 // [baron] skip psy-sensor(m_09_RK1608Dphy), save cif inf addr.
1152 if (cif_info) {
1153 CamHwIsp20::rk1608_share_inf.reference_mipi_cif = cif_info;
1154 }
1155 continue;
1156 }
1157 rk_aiq_static_info_t *info = new rk_aiq_static_info_t();
1158 rk_sensor_full_info_t *s_full_info = new rk_sensor_full_info_t();
1159 s_full_info->media_node_index = node_index;
1160 strncpy(devpath, media_entity_get_devname(entity), sizeof(devpath) - 1);
1161 devpath[sizeof(devpath) - 1] = '\0';
1162 s_full_info->device_name = std::string(devpath);
1163 s_full_info->sensor_name = std::string(entity_info->name);
1164 s_full_info->parent_media_dev = std::string(sys_path);
1165 parse_module_info(s_full_info);
1166 get_sensor_caps(s_full_info);
1167
1168 if (cif_info) {
1169 s_full_info->linked_to_isp = false;
1170 s_full_info->cif_info = cif_info;
1171 s_full_info->isp_info = NULL;
1172 s_full_info->dvp_itf = dvp_itf;
1173 // [baron] add flag for 1608 sensor
1174 s_full_info->linked_to_1608 = false;
1175 info->_is_1608_sensor = false;
1176 } else if (isp_info) {
1177 s_full_info->linked_to_isp = true;
1178 isp_info->linked_sensor = true;
1179 isp_info->isMultiplex = false;
1180 s_full_info->isp_info = isp_info;
1181 #if defined(ISP_HW_V30)
1182 // FIXME: Just support isp3x(rk3588-8/9camera).
1183 for (int vi_idx = 0; vi_idx < MAX_ISP_LINKED_VICAP_CNT; vi_idx++) {
1184 if (strlen(isp_info->linked_vicap[vi_idx]) > 0) {
1185 strcpy(CamHwIsp20::rk1608_share_inf.reference_name, isp_info->linked_vicap[vi_idx]);
1186 s_full_info->cif_info = CamHwIsp20::rk1608_share_inf.reference_mipi_cif;
1187 info->_is_1608_sensor = true;
1188 s_full_info->linked_to_1608 = true;
1189 }
1190 }
1191 #endif
1192 } else {
1193 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "sensor device mount error!\n");
1194 }
1195 #if 0
1196 printf(" >>>>>>>>> sensor(%s): cif addr(%p), link_to_1608[%d], share_vi(%s)\n",
1197 entity_info->name,
1198 s_full_info->cif_info,
1199 s_full_info->linked_to_1608,
1200 CamHwIsp20::rk1608_share_inf.reference_name
1201 );
1202 #endif
1203
1204 findAttachedSubdevs(device, nents, s_full_info);
1205 SensorInfoCopy(s_full_info, info);
1206 info->has_lens_vcm = s_full_info->module_lens_dev_name.empty() ? false : true;
1207 info->has_fl = s_full_info->flash_num > 0 ? true : false;
1208 info->has_irc = s_full_info->module_ircut_dev_name.empty() ? false : true;
1209 info->fl_strth_adj_sup = s_full_info->fl_ir_strth_adj_sup;
1210 info->fl_ir_strth_adj_sup = s_full_info->fl_ir_strth_adj_sup;
1211 if (s_full_info->isp_info)
1212 info->is_multi_isp_mode = s_full_info->isp_info->is_multi_isp_mode;
1213 info->multi_isp_extended_pixel = mMultiIspExtendedPixel;
1214 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "Init sensor %s with Multi-ISP Mode:%d Extended Pixels:%d ",
1215 s_full_info->sensor_name.c_str(), info->is_multi_isp_mode,
1216 info->multi_isp_extended_pixel);
1217 CamHwIsp20::mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
1218 CamHwIsp20::mCamHwInfos[s_full_info->sensor_name] = info;
1219 }
1220 }
1221
1222 media_unref:
1223 media_device_unref (device);
1224 }
1225
1226 #if defined(ISP_HW_V30)
1227 // judge isp if multiplex by multiple cams
1228 rk_aiq_isp_t* isp_info = NULL;
1229 for (i = 0; i < MAX_CAM_NUM; i++) {
1230 isp_info = &CamHwIsp20::mIspHwInfos.isp_info[i];
1231 if (isp_info->valid) {
1232 for (j = i - 1; j >= 0; j--) {
1233 if (isp_info->phy_id == CamHwIsp20::mIspHwInfos.isp_info[j].phy_id) {
1234 isp_info->isMultiplex = true;
1235 CamHwIsp20::mIspHwInfos.isp_info[j].isMultiplex = true;
1236 }
1237 }
1238 }
1239 }
1240 #endif
1241
1242 std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator iter;
1243 for(iter = CamHwIsp20::mSensorHwInfos.begin(); \
1244 iter != CamHwIsp20::mSensorHwInfos.end(); iter++) {
1245 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "match the sensor_name(%s) media link\n", (iter->first).c_str());
1246 SmartPtr<rk_sensor_full_info_t> s_full_info = iter->second;
1247
1248 /*
1249 * The ISP and ISPP match links through the media device model
1250 */
1251 if (s_full_info->linked_to_isp) {
1252 for (i = 0; i < MAX_CAM_NUM; i++) {
1253 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "isp model_idx: %d, ispp(%d) model_idx: %d\n",
1254 s_full_info->isp_info->model_idx,
1255 i,
1256 CamHwIsp20::mIspHwInfos.ispp_info[i].model_idx);
1257
1258 if (CamHwIsp20::mIspHwInfos.ispp_info[i].valid &&
1259 (s_full_info->isp_info->model_idx == CamHwIsp20::mIspHwInfos.ispp_info[i].model_idx)) {
1260 s_full_info->ispp_info = &CamHwIsp20::mIspHwInfos.ispp_info[i];
1261 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "isp(%d) link to ispp(%d)\n",
1262 s_full_info->isp_info->model_idx,
1263 CamHwIsp20::mIspHwInfos.ispp_info[i].model_idx);
1264 CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx =
1265 atoi(s_full_info->ispp_info->media_dev_path + strlen("/dev/media"));
1266 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "sensor %s adapted to pp media %d:%s\n",
1267 s_full_info->sensor_name.c_str(),
1268 CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx,
1269 s_full_info->ispp_info->media_dev_path);
1270 break;
1271 }
1272 }
1273 } else {
1274 /*
1275 * Determine which isp that vipCap is linked
1276 */
1277 for (i = 0; i < MAX_CAM_NUM; i++) {
1278 rk_aiq_isp_t* isp_info = &CamHwIsp20::mIspHwInfos.isp_info[i];
1279
1280 for (int vicap_idx = 0; vicap_idx < MAX_ISP_LINKED_VICAP_CNT; vicap_idx++) {
1281 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "vicap %s, linked_vicap %s",
1282 s_full_info->cif_info->model_str, isp_info->linked_vicap[vicap_idx]);
1283 if (strcmp(s_full_info->cif_info->model_str, isp_info->linked_vicap[vicap_idx]) == 0) {
1284 s_full_info->isp_info = &CamHwIsp20::mIspHwInfos.isp_info[i];
1285 CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->is_multi_isp_mode =
1286 s_full_info->isp_info->is_multi_isp_mode;
1287 CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]
1288 ->multi_isp_extended_pixel = mMultiIspExtendedPixel;
1289 if (CamHwIsp20::mIspHwInfos.ispp_info[i].valid)
1290 s_full_info->ispp_info = &CamHwIsp20::mIspHwInfos.ispp_info[i];
1291 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "vicap link to isp(%d) to ispp(%d)\n",
1292 s_full_info->isp_info->model_idx,
1293 s_full_info->ispp_info ? s_full_info->ispp_info->model_idx : -1);
1294 CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx =
1295 s_full_info->ispp_info ? atoi(s_full_info->ispp_info->media_dev_path + strlen("/dev/media")) :
1296 -1;
1297 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "sensor %s adapted to pp media %d:%s\n",
1298 s_full_info->sensor_name.c_str(),
1299 CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx,
1300 s_full_info->ispp_info ? s_full_info->ispp_info->media_dev_path : "null");
1301 CamHwIsp20::mIspHwInfos.isp_info[i].linked_sensor = true;
1302 }
1303 }
1304 }
1305 }
1306
1307 if (!s_full_info->isp_info/* || !s_full_info->ispp_info*/) {
1308 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get isp or ispp info fail, something gos wrong!");
1309 } else {
1310 //CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->linked_isp_info = *s_full_info->isp_info;
1311 //CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->linked_ispp_info = *s_full_info->ispp_info;
1312 }
1313 }
1314
1315 /* Look for free isp&ispp link to fake camera */
1316 for (i = 0; i < MAX_CAM_NUM; i++) {
1317 if (CamHwIsp20::mIspHwInfos.isp_info[i].valid &&
1318 !CamHwIsp20::mIspHwInfos.isp_info[i].linked_sensor) {
1319 rk_aiq_static_info_t *hwinfo = new rk_aiq_static_info_t();
1320 rk_sensor_full_info_t *fullinfo = new rk_sensor_full_info_t();
1321
1322 fullinfo->isp_info = &CamHwIsp20::mIspHwInfos.isp_info[i];
1323 if (CamHwIsp20::mIspHwInfos.ispp_info[i].valid) {
1324 fullinfo->ispp_info = &CamHwIsp20::mIspHwInfos.ispp_info[i];
1325 hwinfo->sensor_info.binded_strm_media_idx =
1326 atoi(fullinfo->ispp_info->media_dev_path + strlen("/dev/media"));
1327 }
1328 fullinfo->media_node_index = -1;
1329 fullinfo->device_name = std::string("/dev/null");
1330 fullinfo->sensor_name = std::string("FakeCamera");
1331 fullinfo->sensor_name += std::to_string(i);
1332 fullinfo->parent_media_dev = std::string("/dev/null");
1333 fullinfo->linked_to_isp = true;
1334
1335 hwinfo->sensor_info.support_fmt[0].hdr_mode = NO_HDR;
1336 hwinfo->sensor_info.support_fmt[1].hdr_mode = HDR_X2;
1337 hwinfo->sensor_info.support_fmt[2].hdr_mode = HDR_X3;
1338 hwinfo->sensor_info.num = 3;
1339 CamHwIsp20::mIspHwInfos.isp_info[i].linked_sensor = true;
1340
1341 SensorInfoCopy(fullinfo, hwinfo);
1342 hwinfo->has_lens_vcm = false;
1343 hwinfo->has_fl = false;
1344 hwinfo->has_irc = false;
1345 hwinfo->fl_strth_adj_sup = 0;
1346 hwinfo->fl_ir_strth_adj_sup = 0;
1347 hwinfo->is_multi_isp_mode = fullinfo->isp_info->is_multi_isp_mode;
1348 hwinfo->multi_isp_extended_pixel = mMultiIspExtendedPixel;
1349 CamHwIsp20::mSensorHwInfos[fullinfo->sensor_name] = fullinfo;
1350 CamHwIsp20::mCamHwInfos[fullinfo->sensor_name] = hwinfo;
1351 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "fake camera %d link to isp(%d) to ispp(%d)\n",
1352 i,
1353 fullinfo->isp_info->model_idx,
1354 fullinfo->ispp_info ? fullinfo->ispp_info->model_idx : -1);
1355 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "sensor %s adapted to pp media %d:%s\n",
1356 fullinfo->sensor_name.c_str(),
1357 CamHwIsp20::mCamHwInfos[fullinfo->sensor_name]->sensor_info.binded_strm_media_idx,
1358 fullinfo->ispp_info ? fullinfo->ispp_info->media_dev_path : "null");
1359 }
1360 }
1361
1362 get_isp_ver(&CamHwIsp20::mIspHwInfos);
1363 for (auto &item : mCamHwInfos)
1364 item.second->isp_hw_ver = mIspHwInfos.hw_ver_info.isp_ver;
1365 return XCAM_RETURN_NO_ERROR;
1366 }
1367
1368 const char*
getBindedSnsEntNmByVd(const char * vd)1369 CamHwIsp20::getBindedSnsEntNmByVd(const char* vd)
1370 {
1371 if (!vd)
1372 return NULL;
1373
1374 std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator iter;
1375 for(iter = CamHwIsp20::mSensorHwInfos.begin(); \
1376 iter != CamHwIsp20::mSensorHwInfos.end(); iter++) {
1377 SmartPtr<rk_sensor_full_info_t> s_full_info = iter->second;
1378
1379 // skip 1608-dphy 'sensor'
1380 if (strstr(s_full_info->sensor_name.c_str(), "1608"))
1381 continue;
1382 if (!s_full_info->isp_info)
1383 continue;
1384
1385 bool stream_vd = false;
1386 if (s_full_info->ispp_info) {
1387 if (strstr(s_full_info->ispp_info->pp_m_bypass_path, vd) ||
1388 strstr(s_full_info->ispp_info->pp_scale0_path, vd) ||
1389 strstr(s_full_info->ispp_info->pp_scale1_path, vd) ||
1390 strstr(s_full_info->ispp_info->pp_scale2_path, vd))
1391 stream_vd = true;
1392 } else {
1393 if (strstr(s_full_info->isp_info->main_path, vd) ||
1394 strstr(s_full_info->isp_info->self_path, vd))
1395 stream_vd = true;
1396 }
1397
1398 if (stream_vd) {
1399 // check linked
1400 if ((strstr(s_full_info->sensor_name.c_str(), "FakeCamera") == NULL) &&
1401 (strstr(s_full_info->sensor_name.c_str(), "_s_") == NULL)) {
1402 FILE *fp = NULL;
1403 struct media_device *device = NULL;
1404 uint32_t nents, j = 0, i = 0;
1405 const struct media_entity_desc *entity_info = NULL;
1406 struct media_entity *entity = NULL;
1407 media_pad *src_pad_s = NULL;
1408 char sys_path[64], devpath[32];
1409
1410 snprintf (sys_path, 64, "/dev/media%d", s_full_info->media_node_index);
1411 if (0 != access(sys_path, F_OK))
1412 continue;
1413
1414 device = media_device_new (sys_path);
1415 if (!device)
1416 return nullptr;
1417
1418 /* Enumerate entities, pads and links. */
1419 media_device_enumerate (device);
1420 entity = media_get_entity_by_name(device,
1421 s_full_info->sensor_name.c_str(),
1422 s_full_info->sensor_name.size());
1423 entity_info = media_entity_get_info(entity);
1424 if (entity && entity->num_links > 0) {
1425 if (entity->links[0].flags == MEDIA_LNK_FL_ENABLED) {
1426 media_device_unref (device);
1427 return s_full_info->sensor_name.c_str();
1428 }
1429 }
1430 media_device_unref (device);
1431 } else
1432 return s_full_info->sensor_name.c_str();
1433 }
1434 }
1435
1436 return NULL;
1437 }
1438
1439 #if defined(ISP_HW_V20)
1440 XCamReturn
init_pp(rk_sensor_full_info_t * s_info)1441 CamHwIsp20::init_pp(rk_sensor_full_info_t *s_info)
1442 {
1443 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1444 SmartPtr<PollThread> isp20IsppPollthread;
1445
1446 if (!s_info->ispp_info)
1447 return ret;
1448
1449 if (!strlen(s_info->ispp_info->media_dev_path))
1450 return ret;
1451 _ispp_sd = new V4l2SubDevice(s_info->ispp_info->pp_dev_path);
1452 _ispp_sd ->open();
1453 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "pp_dev_path: %s\n", s_info->ispp_info->pp_dev_path);
1454
1455 mTnrStreamProcUnit = new TnrStreamProcUnit(s_info);
1456 mTnrStreamProcUnit->set_devices(this, _ispp_sd);
1457 mNrStreamProcUnit = new NrStreamProcUnit(s_info);
1458 mNrStreamProcUnit->set_devices(this, _ispp_sd);
1459 mFecParamStream = new FecParamStream(s_info);
1460 mFecParamStream->set_devices(this, _ispp_sd);
1461
1462 return ret;
1463 }
1464 #endif
1465
1466 XCamReturn
init(const char * sns_ent_name)1467 CamHwIsp20::init(const char* sns_ent_name)
1468 {
1469 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1470 SmartPtr<BaseSensorHw> sensorHw;
1471 SmartPtr<LensHw> lensHw;
1472 SmartPtr<V4l2Device> mipi_tx_devs[3];
1473 SmartPtr<V4l2Device> mipi_rx_devs[3];
1474 std::string sensor_name(sns_ent_name);
1475
1476 ENTER_CAMHW_FUNCTION();
1477
1478
1479 std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
1480 if ((it = mSensorHwInfos.find(sensor_name)) == mSensorHwInfos.end()) {
1481 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_ent_name);
1482 return XCAM_RETURN_ERROR_SENSOR;
1483 }
1484 rk_sensor_full_info_t *s_info = it->second.ptr();
1485 sensorHw = new SensorHw(s_info->device_name.c_str());
1486 sensorHw->setCamPhyId(mCamPhyId);
1487 mSensorDev = sensorHw;
1488 mSensorDev->open();
1489 sensorHw->setTbInfo (mTbInfo.is_pre_aiq);
1490
1491 Isp20Params::setCamPhyId(mCamPhyId);
1492
1493 strncpy(sns_name, sns_ent_name, sizeof(sns_name) - 1);
1494 sns_name[sizeof(sns_name) - 1] = '\0';
1495
1496 // normal env.
1497 if (s_info->linked_to_isp) {
1498 _linked_to_isp = true;
1499 _linked_to_1608 = false;
1500 } else {
1501 _linked_to_isp = false;
1502 _linked_to_1608 = false;
1503 }
1504
1505 // 1608 sensor env.
1506 if (s_info->linked_to_1608) {
1507 _linked_to_isp = false;
1508 _linked_to_1608 = true;
1509 // [baron] Record the number of use sensors(valid 1608 sensor)
1510 CamHwIsp20::rk1608_share_inf.en_sns_num++;
1511 }
1512
1513 mIspCoreDev = new V4l2SubDevice(s_info->isp_info->isp_dev_path);
1514 mIspCoreDev->open();
1515
1516 if (strlen(s_info->isp_info->mipi_luma_path)) {
1517 if (_linked_to_isp) {
1518 mIspLumaDev = new V4l2Device(s_info->isp_info->mipi_luma_path);
1519 } else
1520 mIspLumaDev = new V4l2Device(s_info->cif_info->mipi_luma_path);
1521 mIspLumaDev->open();
1522 }
1523
1524 mIspStatsDev = new V4l2Device (s_info->isp_info->stats_path);
1525 mIspStatsDev->open();
1526 mIspParamsDev = new V4l2Device (s_info->isp_info->input_params_path);
1527 mIspParamsDev->open();
1528
1529 if(!s_info->module_lens_dev_name.empty()) {
1530 lensHw = new LensHw(s_info->module_lens_dev_name.c_str());
1531 mLensDev = lensHw;
1532 mLensDev->open();
1533 }
1534 #if defined(ISP_HW_V20) || defined(ISP_HW_V21)
1535 else {
1536 // af soft stats need this device on 356x 1126
1537 lensHw = new LensHw(NULL);
1538 mLensDev = lensHw;
1539 }
1540 #endif
1541
1542 if(!s_info->module_ircut_dev_name.empty()) {
1543 mIrcutDev = new V4l2SubDevice(s_info->module_ircut_dev_name.c_str());
1544 mIrcutDev->open();
1545 }
1546
1547 if (!_linked_to_isp) {
1548 if (strlen(s_info->cif_info->mipi_csi2_sd_path) > 0) {
1549 _cif_csi2_sd = new V4l2SubDevice (s_info->cif_info->mipi_csi2_sd_path);
1550 } else if (strlen(s_info->cif_info->lvds_sd_path) > 0) {
1551 _cif_csi2_sd = new V4l2SubDevice (s_info->cif_info->lvds_sd_path);
1552 } else if (strlen(s_info->cif_info->dvp_sof_sd_path) > 0) {
1553 _cif_csi2_sd = new V4l2SubDevice (s_info->cif_info->dvp_sof_sd_path);
1554 } else {
1555 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "_cif_csi2_sd is null! \n");
1556 }
1557 _cif_csi2_sd->open();
1558 }
1559
1560 #if defined(ISP_HW_V20)
1561 init_pp(s_info);
1562 #endif
1563 #if defined(RKAIQ_ENABLE_SPSTREAM)
1564 mIspSpDev = new V4l2Device (s_info->isp_info->self_path);//rkisp_selfpath
1565 mIspSpDev->open();
1566 mSpStreamUnit = new SPStreamProcUnit(mIspSpDev, ISP_POLL_SP, mIspHwInfos.hw_ver_info.isp_ver);
1567 mSpStreamUnit->set_devices(this, mIspCoreDev, _ispp_sd, mLensDev);
1568 #endif
1569
1570 mPdafStreamUnit = new PdafStreamProcUnit(ISP_POLL_PDAF_STATS);
1571 mPdafStreamUnit->set_devices(this);
1572
1573 #ifndef USE_RAWSTREAM_LIB
1574 auto buf_it = std::find_if(
1575 std::begin(mDevBufCntMap), std::end(mDevBufCntMap),
1576 [&](const std::pair<std::string, int>& buf_cnt_map) {
1577 return (
1578 !buf_cnt_map.first.compare("rkraw_tx") || !buf_cnt_map.first.compare("rkraw_rx") ||
1579 !buf_cnt_map.first.compare(0, sizeof("stream_cif_mipi_id"), "stream_cif_mipi_id") ||
1580 !buf_cnt_map.first.compare(0, sizeof("rkisp_rawwr"), "rkisp_rawwr"));
1581 });
1582 int buf_cnt = 0;
1583 if (buf_it != mDevBufCntMap.end()) {
1584 buf_cnt = buf_it->second;
1585 }
1586
1587 if (!_linked_to_1608) {
1588 mRawCapUnit = new RawStreamCapUnit(s_info, _linked_to_isp, buf_cnt);
1589 mRawProcUnit = new RawStreamProcUnit(s_info, _linked_to_isp, buf_cnt);
1590
1591 // set sensor stream flag.
1592 mRawCapUnit->setSensorCategory(false);
1593 mRawProcUnit->setSensorCategory(false);
1594 } else {
1595 // 1608 sensor
1596 if (NULL == CamHwIsp20::rk1608_share_inf.raw_cap_unit.ptr()) {
1597 // [baron] just new buffer in 1st.
1598 mRawCapUnit = new RawStreamCapUnit(s_info, _linked_to_isp, buf_cnt);
1599 CamHwIsp20::rk1608_share_inf.raw_cap_unit = mRawCapUnit;
1600 }
1601
1602 mRawProcUnit = new RawStreamProcUnit(s_info, _linked_to_isp, buf_cnt);
1603 if (mRawProcUnit.ptr()) {
1604 // [baron] save multi rx addr for 1 tx.
1605 CamHwIsp20::rk1608_share_inf.raw_proc_unit[mCamPhyId] = mRawProcUnit.ptr();
1606 }
1607
1608 // update tx by bakeup tx.
1609 mRawCapUnit = CamHwIsp20::rk1608_share_inf.raw_cap_unit;
1610 mRawCapUnit->setSensorCategory(true);
1611 mRawProcUnit->setSensorCategory(true);
1612 }
1613
1614 mRawCapUnit->set_devices(mIspCoreDev, this, mRawProcUnit.ptr());
1615 mRawProcUnit->set_devices(mIspCoreDev, this);
1616 mRawCapUnit->setCamPhyId(mCamPhyId);
1617 mRawProcUnit->setCamPhyId(mCamPhyId);
1618 #endif
1619
1620 //cif scale
1621 if (!_linked_to_isp && !_linked_to_1608) {
1622 if (strlen(s_info->cif_info->mipi_scl0))
1623 mCifScaleStream = new CifSclStream();
1624 }
1625
1626 //isp stats
1627 mIspStatsStream = new RKStatsStream(mIspStatsDev, ISP_POLL_3A_STATS);
1628 mIspStatsStream->setPollCallback (this);
1629 mIspStatsStream->set_event_handle_dev(sensorHw);
1630 if(lensHw.ptr()) {
1631 mIspStatsStream->set_focus_handle_dev(lensHw);
1632 }
1633 mIspStatsStream->set_rx_handle_dev(this);
1634 mIspStatsStream->setCamPhyId(mCamPhyId);
1635 //luma
1636 if (mIspLumaDev.ptr()) {
1637 mLumaStream = new RKStream(mIspLumaDev, ISP_POLL_LUMA);
1638 mLumaStream->setPollCallback (this);
1639 }
1640
1641 #ifndef DISABLE_PARAMS_POLL_THREAD
1642 //isp params
1643 mIspParamStream = new RKStream(mIspParamsDev, ISP_POLL_PARAMS);
1644 mIspParamStream->setCamPhyId(mCamPhyId);
1645 mIspParamStream->setPollCallback (this);
1646 #endif
1647
1648 if (s_info->flash_num) {
1649 mFlashLight = new FlashLightHw(s_info->module_flash_dev_name, s_info->flash_num);
1650 mFlashLight->init(s_info->flash_num);
1651 }
1652 if (s_info->flash_ir_num) {
1653 mFlashLightIr = new FlashLightHw(s_info->module_flash_ir_dev_name, s_info->flash_ir_num);
1654 mFlashLightIr->init(s_info->flash_ir_num);
1655 }
1656
1657 #if defined(ISP_HW_V20)
1658 xcam_mem_clear (_full_active_ispp_params);
1659 #endif
1660 _state = CAM_HW_STATE_INITED;
1661
1662 EXIT_CAMHW_FUNCTION();
1663
1664 return XCAM_RETURN_NO_ERROR;
1665 }
1666
1667 XCamReturn
deInit()1668 CamHwIsp20::deInit()
1669 {
1670 if (mPdafStreamUnit.ptr())
1671 mPdafStreamUnit->deinit();
1672 if (mFlashLight.ptr())
1673 mFlashLight->deinit();
1674 if (mFlashLightIr.ptr())
1675 mFlashLightIr->deinit();
1676
1677 std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
1678 if (strlen(sns_name) == 0 || (it = mSensorHwInfos.find(sns_name)) == mSensorHwInfos.end()) {
1679 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", strlen(sns_name) ? sns_name : "");
1680 return XCAM_RETURN_ERROR_SENSOR;
1681 }
1682
1683 rk_sensor_full_info_t *s_info = it->second.ptr();
1684 int isp_index = s_info->isp_info->logic_id;
1685 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "sensor_name(%s) is linked to isp_index(%d)",
1686 sns_name, isp_index);
1687 if (!mNoReadBack) {
1688 setupHdrLink(RK_AIQ_WORKING_MODE_ISP_HDR3, isp_index, false);
1689 setupHdrLink_vidcap(_hdr_mode, isp_index, false);
1690 }
1691
1692 {
1693 // TODO: These parameters only deinited when the first sensor deinit!
1694 if (CamHwIsp20::rk1608_share_inf.raw_cap_unit.ptr()) {
1695 CamHwIsp20::rk1608_share_inf.raw_cap_unit = NULL;
1696 for (int i = 0; i < CAM_INDEX_FOR_1608; i++) {
1697 CamHwIsp20::rk1608_share_inf.raw_proc_unit[i] = NULL;
1698 }
1699 // [Stage 01] {init} <-> {deinit}.
1700 CamHwIsp20::rk1608_share_inf.en_sns_num = 0; // last sensor valid!
1701 CamHwIsp20::rk1608_share_inf.us_open_cnt = 0;
1702
1703 // [Stage 02] {Prepare} <-> {deinit}
1704 CamHwIsp20::rk1608_share_inf.us_prepare_cnt = 0; // prepare stage use
1705 }
1706 CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId] = 1; // prepare stage use
1707 }
1708 _state = CAM_HW_STATE_INVALID;
1709 if (strstr(sns_name, "_s_")) {
1710 rawReproc_deInit(sns_name);
1711 }
1712 return XCAM_RETURN_NO_ERROR;
1713 }
1714
1715 XCamReturn
poll_buffer_ready(SmartPtr<VideoBuffer> & buf)1716 CamHwIsp20::poll_buffer_ready (SmartPtr<VideoBuffer> &buf)
1717 {
1718 if (buf->_buf_type == ISP_POLL_3A_STATS) {
1719 // stats is comming, means that next params should be ready
1720 #ifndef DISABLE_PARAMS_ASSEMBLER
1721 if (/*mNoReadBack*/true) {
1722 if (buf->get_sequence() > 0)
1723 mParamsAssembler->forceReady(buf->get_sequence() + 1);
1724 // set all ready params to drv
1725 while (_state == CAM_HW_STATE_STARTED &&
1726 mParamsAssembler->ready()) {
1727 if (setIspConfig() != XCAM_RETURN_NO_ERROR)
1728 break;
1729 }
1730
1731 }
1732 #endif
1733 } else if (buf->_buf_type == ISP_POLL_PARAMS) {
1734 V4l2BufferProxy* v4lbuf = buf.get_cast_ptr<V4l2BufferProxy>();
1735 struct isp2x_isp_params_cfg* data = (struct isp2x_isp_params_cfg*)(v4lbuf->get_v4l2_userptr());
1736 static int frame_id0_cnt = 0;
1737 if (mTbInfo.is_pre_aiq) {
1738 if (data->frame_id == 0) {
1739 ++frame_id0_cnt;
1740 }
1741 LOGE("<TB> poll param id %d cnt %d", data->frame_id, frame_id0_cnt);
1742 }
1743 if (!mTbInfo.is_pre_aiq && frame_id0_cnt < 1) {
1744 return XCAM_RETURN_NO_ERROR;
1745 }
1746 }
1747 return CamHwBase::poll_buffer_ready(buf);
1748 }
1749
1750 XCamReturn
setupPipelineFmtCif(struct v4l2_subdev_selection & sns_sd_sel,struct v4l2_subdev_format & sns_sd_fmt,__u32 sns_v4l_pix_fmt)1751 CamHwIsp20::setupPipelineFmtCif(struct v4l2_subdev_selection& sns_sd_sel,
1752 struct v4l2_subdev_format& sns_sd_fmt,
1753 __u32 sns_v4l_pix_fmt)
1754 {
1755 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1756
1757 int8_t bpp = 0;
1758 pixFmt2Bpp(sns_v4l_pix_fmt, bpp);
1759
1760 #ifndef USE_RAWSTREAM_LIB
1761 if (mIsMultiIspMode && !mNoReadBack) {
1762 ret = mRawCapUnit->set_csi_mem_word_big_align(sns_sd_sel.r.width, sns_sd_sel.r.height,
1763 sns_v4l_pix_fmt, bpp);
1764 if (ret < 0) {
1765 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "tx set csi_mem_word_big_align failed!\n");
1766 return ret;
1767 }
1768
1769 ret = mRawProcUnit->set_csi_mem_word_big_align(sns_sd_sel.r.width, sns_sd_sel.r.height,
1770 sns_v4l_pix_fmt, bpp);
1771 if (ret < 0) {
1772 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "rx set csi_mem_word_big_align failed!\n");
1773 return ret;
1774 }
1775 }
1776
1777 // TODO: set cif crop according to sensor crop bounds
1778 if (!_linked_to_1608) {
1779 mRawCapUnit->set_tx_format(sns_sd_sel, sns_v4l_pix_fmt);
1780 } else {
1781 // [baron] Only processed the first time
1782 if (CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId]) {
1783 // [baron] Timing issue, for 1608.
1784 mRawCapUnit->set_tx_format(sns_sd_sel, sns_v4l_pix_fmt);
1785 }
1786 }
1787
1788 mRawProcUnit->set_rx_format(sns_sd_sel, sns_v4l_pix_fmt);
1789 #endif
1790
1791 //set cif scale fmt
1792 if (mCifScaleStream.ptr()) {
1793 mCifScaleStream->set_format(sns_sd_sel, sns_v4l_pix_fmt, bpp);
1794 }
1795
1796 // set isp sink fmt, same as sensor bounds - crop
1797 struct v4l2_subdev_format isp_sink_fmt;
1798
1799 memset(&isp_sink_fmt, 0, sizeof(isp_sink_fmt));
1800 isp_sink_fmt.pad = 0;
1801 isp_sink_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1802 ret = mIspCoreDev->getFormat(isp_sink_fmt);
1803 if (ret) {
1804 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev fmt failed !\n");
1805 return ret;
1806 }
1807 isp_sink_fmt.format.width = sns_sd_sel.r.width;
1808 isp_sink_fmt.format.height = sns_sd_sel.r.height;
1809 isp_sink_fmt.format.code = sns_sd_fmt.format.code;
1810
1811 ret = mIspCoreDev->setFormat(isp_sink_fmt);
1812 if (ret) {
1813 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev fmt failed !\n");
1814 return ret;
1815 }
1816
1817 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp sink fmt info: fmt 0x%x, %dx%d !",
1818 isp_sink_fmt.format.code, isp_sink_fmt.format.width, isp_sink_fmt.format.height);
1819
1820 // set selection, isp needn't do the crop
1821 struct v4l2_subdev_selection aSelection;
1822 memset(&aSelection, 0, sizeof(aSelection));
1823
1824 aSelection.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1825 aSelection.pad = 0;
1826 aSelection.flags = 0;
1827 aSelection.target = V4L2_SEL_TGT_CROP;
1828 aSelection.r.width = sns_sd_sel.r.width;
1829 aSelection.r.height = sns_sd_sel.r.height;
1830 aSelection.r.left = 0;
1831 aSelection.r.top = 0;
1832 ret = mIspCoreDev->set_selection (aSelection);
1833 if (ret) {
1834 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev crop failed !\n");
1835 return ret;
1836 }
1837
1838 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp sink crop info: %dx%d@%d,%d !",
1839 aSelection.r.width, aSelection.r.height,
1840 aSelection.r.left, aSelection.r.top);
1841
1842 // set isp rkisp-isp-subdev src crop
1843 aSelection.pad = 2;
1844 #if 1 // isp src has no crop
1845 ret = mIspCoreDev->set_selection (aSelection);
1846 if (ret) {
1847 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev source crop failed !\n");
1848 return ret;
1849 }
1850 #endif
1851 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp src crop info: %dx%d@%d,%d !",
1852 aSelection.r.width, aSelection.r.height,
1853 aSelection.r.left, aSelection.r.top);
1854
1855 // set isp rkisp-isp-subdev src pad fmt
1856 struct v4l2_subdev_format isp_src_fmt;
1857
1858 memset(&isp_src_fmt, 0, sizeof(isp_src_fmt));
1859 isp_src_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1860 isp_src_fmt.pad = 2;
1861 ret = mIspCoreDev->getFormat(isp_src_fmt);
1862 if (ret) {
1863 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get mIspCoreDev src fmt failed !\n");
1864 return ret;
1865 }
1866
1867 isp_src_fmt.format.width = aSelection.r.width;
1868 isp_src_fmt.format.height = aSelection.r.height;
1869 ret = mIspCoreDev->setFormat(isp_src_fmt);
1870 if (ret) {
1871 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev src fmt failed !\n");
1872 return ret;
1873 }
1874
1875 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp src fmt info: fmt 0x%x, %dx%d !",
1876 isp_src_fmt.format.code, isp_src_fmt.format.width, isp_src_fmt.format.height);
1877
1878 return ret;
1879
1880 }
1881
1882 XCamReturn
setupPipelineFmtIsp(struct v4l2_subdev_selection & sns_sd_sel,struct v4l2_subdev_format & sns_sd_fmt,__u32 sns_v4l_pix_fmt)1883 CamHwIsp20::setupPipelineFmtIsp(struct v4l2_subdev_selection& sns_sd_sel,
1884 struct v4l2_subdev_format& sns_sd_fmt,
1885 __u32 sns_v4l_pix_fmt)
1886 {
1887 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1888
1889 #ifndef USE_RAWSTREAM_LIB
1890 if (!_linked_to_1608 || CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId]) {
1891 mRawCapUnit->set_tx_format(sns_sd_fmt, sns_v4l_pix_fmt);
1892 }
1893
1894 mRawProcUnit->set_rx_format(sns_sd_fmt, sns_v4l_pix_fmt);
1895 #endif
1896
1897 // set scale fmt
1898 if (mCifScaleStream.ptr()) {
1899 int8_t bpp = 0;
1900 pixFmt2Bpp(sns_v4l_pix_fmt, bpp);
1901 mCifScaleStream->set_format(sns_sd_sel, sns_v4l_pix_fmt, bpp);
1902 }
1903
1904 #ifndef ANDROID_OS // Android camera hal will set pipeline itself
1905 // set isp sink fmt, same as sensor fmt
1906 struct v4l2_subdev_format isp_sink_fmt;
1907
1908 memset(&isp_sink_fmt, 0, sizeof(isp_sink_fmt));
1909 isp_sink_fmt.pad = 0;
1910 isp_sink_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1911 ret = mIspCoreDev->getFormat(isp_sink_fmt);
1912 if (ret) {
1913 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev fmt failed !\n");
1914 return ret;
1915 }
1916
1917 isp_sink_fmt.format.width = sns_sd_fmt.format.width;
1918 isp_sink_fmt.format.height = sns_sd_fmt.format.height;
1919 isp_sink_fmt.format.code = sns_sd_fmt.format.code;
1920
1921 ret = mIspCoreDev->setFormat(isp_sink_fmt);
1922 if (ret) {
1923 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev fmt failed !\n");
1924 return ret;
1925 }
1926
1927 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp sink fmt info: fmt 0x%x, %dx%d !",
1928 isp_sink_fmt.format.code, isp_sink_fmt.format.width, isp_sink_fmt.format.height);
1929
1930 // set selection, isp do the crop
1931 struct v4l2_subdev_selection aSelection;
1932 memset(&aSelection, 0, sizeof(aSelection));
1933
1934 aSelection.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1935 aSelection.pad = 0;
1936 aSelection.flags = 0;
1937 aSelection.target = V4L2_SEL_TGT_CROP;
1938 aSelection.r.width = sns_sd_sel.r.width;
1939 aSelection.r.height = sns_sd_sel.r.height;
1940 aSelection.r.left = sns_sd_sel.r.left;
1941 aSelection.r.top = sns_sd_sel.r.top;
1942 ret = mIspCoreDev->set_selection (aSelection);
1943 if (ret) {
1944 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev crop failed !\n");
1945 return ret;
1946 }
1947
1948 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp sink crop info: %dx%d@%d,%d !",
1949 aSelection.r.width, aSelection.r.height,
1950 aSelection.r.left, aSelection.r.top);
1951
1952 // set isp rkisp-isp-subdev src crop
1953 aSelection.pad = 2;
1954 aSelection.target = V4L2_SEL_TGT_CROP;
1955 aSelection.r.left = 0;
1956 aSelection.r.top = 0;
1957 aSelection.r.width = sns_sd_sel.r.width;
1958 aSelection.r.height = sns_sd_sel.r.height;
1959 #if 1 // isp src has no crop
1960 ret = mIspCoreDev->set_selection (aSelection);
1961 if (ret) {
1962 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev source crop failed !\n");
1963 return ret;
1964 }
1965 #endif
1966 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp src crop info: %dx%d@%d,%d !",
1967 aSelection.r.width, aSelection.r.height,
1968 aSelection.r.left, aSelection.r.top);
1969
1970 // set isp rkisp-isp-subdev src pad fmt
1971 struct v4l2_subdev_format isp_src_fmt;
1972
1973 isp_src_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1974 isp_src_fmt.pad = 2;
1975 ret = mIspCoreDev->getFormat(isp_src_fmt);
1976 if (ret) {
1977 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get mIspCoreDev src fmt failed !\n");
1978 return ret;
1979 }
1980
1981 isp_src_fmt.format.width = aSelection.r.width;
1982 isp_src_fmt.format.height = aSelection.r.height;
1983 ret = mIspCoreDev->setFormat(isp_src_fmt);
1984 if (ret) {
1985 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev src fmt failed !\n");
1986 return ret;
1987 }
1988
1989 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp src fmt info: fmt 0x%x, %dx%d !",
1990 isp_src_fmt.format.code, isp_src_fmt.format.width, isp_src_fmt.format.height);
1991 #endif
1992 return ret;
1993 }
1994
1995 XCamReturn
setupPipelineFmt()1996 CamHwIsp20::setupPipelineFmt()
1997 {
1998 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1999
2000 // get sensor v4l2 pixfmt
2001 BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
2002 rk_aiq_exposure_sensor_descriptor sns_des;
2003 if (mSensorSubdev->get_sensor_desc(&sns_des)) {
2004 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "getSensorModeData failed \n");
2005 return XCAM_RETURN_ERROR_UNKNOWN;
2006 }
2007 __u32 sns_v4l_pix_fmt = sns_des.sensor_pixelformat;
2008
2009 struct v4l2_subdev_format sns_sd_fmt;
2010
2011 // get sensor real outupt size
2012 memset(&sns_sd_fmt, 0, sizeof(sns_sd_fmt));
2013 sns_sd_fmt.pad = 0;
2014 sns_sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
2015 ret = mSensorDev->getFormat(sns_sd_fmt);
2016 if (ret) {
2017 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get sensor fmt failed !\n");
2018 return ret;
2019 }
2020
2021 // get sensor crop bounds
2022 struct v4l2_subdev_selection sns_sd_sel;
2023 memset(&sns_sd_sel, 0, sizeof(sns_sd_sel));
2024
2025 ret = mSensorDev->get_selection(0, V4L2_SEL_TGT_CROP_BOUNDS, sns_sd_sel);
2026 if (ret) {
2027 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "get_selection failed !\n");
2028 // TODO, some sensor driver has not implemented this
2029 // ioctl now
2030 sns_sd_sel.r.width = sns_sd_fmt.format.width;
2031 sns_sd_sel.r.height = sns_sd_fmt.format.height;
2032 ret = XCAM_RETURN_NO_ERROR;
2033 }
2034
2035 // with librkrawstream, usr may change raw image, such as crop or rotate.
2036 // in this case, pipeline format is differ from sensor format.
2037 if(userSensorWidth && userSensorHeight){
2038 sns_sd_sel.r.width = userSensorWidth;
2039 sns_sd_sel.r.height = userSensorHeight;
2040 }
2041 if(userSensorFmtCode){
2042 sns_sd_fmt.format.code = userSensorFmtCode;
2043 }
2044
2045 if (!_linked_to_isp && _crop_rect.width && _crop_rect.height) {
2046 struct v4l2_format mipi_tx_fmt;
2047 memset(&mipi_tx_fmt, 0, sizeof(mipi_tx_fmt));
2048 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "vicap get_crop %dx%d@%d,%d\n",
2049 _crop_rect.width, _crop_rect.height, _crop_rect.left, _crop_rect.top);
2050
2051 #ifndef USE_RAWSTREAM_LIB
2052 if (!_linked_to_1608) {
2053 ret = mRawCapUnit->get_tx_device(0)->get_format(mipi_tx_fmt);
2054 } else {
2055 if (CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId]) {
2056 ret = mRawCapUnit->get_tx_device(0)->get_format(mipi_tx_fmt);
2057 }
2058 }
2059 #endif
2060 mipi_tx_fmt.fmt.pix.width = _crop_rect.width;
2061 mipi_tx_fmt.fmt.pix.height = _crop_rect.height;
2062
2063 #ifndef USE_RAWSTREAM_LIB
2064 if (!_linked_to_1608) {
2065 ret = mRawCapUnit->get_tx_device(0)->set_format(mipi_tx_fmt);
2066 } else {
2067 if (CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId]) {
2068 ret = mRawCapUnit->get_tx_device(0)->set_format(mipi_tx_fmt);
2069 }
2070 }
2071 #endif
2072 sns_sd_sel.r.width = _crop_rect.width;
2073 sns_sd_sel.r.height = _crop_rect.height;
2074 sns_sd_fmt.format.width = _crop_rect.width;
2075 sns_sd_fmt.format.height = _crop_rect.height;
2076 ret = XCAM_RETURN_NO_ERROR;
2077 }
2078
2079 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "sensor fmt info: bounds %dx%d, crop %dx%d@%d,%d !",
2080 sns_sd_sel.r.width, sns_sd_sel.r.height,
2081 sns_sd_fmt.format.width, sns_sd_fmt.format.height,
2082 sns_sd_sel.r.left, sns_sd_sel.r.top);
2083
2084 if (_linked_to_isp)
2085 ret = setupPipelineFmtIsp(sns_sd_sel, sns_sd_fmt, sns_v4l_pix_fmt);
2086 else
2087 ret = setupPipelineFmtCif(sns_sd_sel, sns_sd_fmt, sns_v4l_pix_fmt);
2088
2089 if (ret) {
2090 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set ispcore fmt failed !\n");
2091 return ret;
2092 }
2093
2094 #if defined(ISP_HW_V20)
2095 if (!_ispp_sd.ptr())
2096 return ret;
2097
2098 struct v4l2_subdev_format isp_src_fmt;
2099
2100 isp_src_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
2101 isp_src_fmt.pad = 2;
2102 ret = mIspCoreDev->getFormat(isp_src_fmt);
2103
2104 // set ispp format, same as isp_src_fmt
2105 isp_src_fmt.pad = 0;
2106 ret = _ispp_sd->setFormat(isp_src_fmt);
2107 if (ret) {
2108 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set _ispp_sd sink fmt failed !\n");
2109 return ret;
2110 }
2111 #if 0//not use
2112 struct v4l2_subdev_selection aSelection;
2113 memset(&aSelection, 0, sizeof(aSelection));
2114
2115 aSelection.which = V4L2_SUBDEV_FORMAT_ACTIVE;
2116 aSelection.pad = 0;
2117 aSelection.target = V4L2_SEL_TGT_CROP_BOUNDS;
2118 aSelection.flags = 0;
2119 aSelection.r.left = 0;
2120 aSelection.r.top = 0;
2121 aSelection.r.width = isp_src_fmt.format.width;
2122 aSelection.r.height = isp_src_fmt.format.height;
2123 #if 0
2124 ret = _ispp_sd->set_selection (aSelection);
2125 if (ret) {
2126 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set _ispp_sd crop bound failed !\n");
2127 return ret;
2128 }
2129 #endif
2130 aSelection.target = V4L2_SEL_TGT_CROP;
2131 ret = _ispp_sd->set_selection (aSelection);
2132 if (ret) {
2133 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set _ispp_sd crop failed !\n");
2134 return ret;
2135 }
2136 #endif
2137 // set sp format to NV12 as default
2138
2139 if (mIspSpDev.ptr()) {
2140 struct v4l2_selection selection;
2141 memset(&selection, 0, sizeof(selection));
2142
2143 selection.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2144 selection.target = V4L2_SEL_TGT_CROP;
2145 selection.flags = 0;
2146 selection.r.left = 0;
2147 selection.r.top = 0;
2148 selection.r.width = isp_src_fmt.format.width;
2149 selection.r.height = isp_src_fmt.format.height;
2150
2151 ret = mIspSpDev->set_selection (selection);
2152
2153 struct v4l2_format fmt;
2154 ret = mIspSpDev->get_format (fmt);
2155 if (ret) {
2156 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "get mIspSpDev fmt failed !\n");
2157 //return;
2158 }
2159 if (V4L2_PIX_FMT_FBCG == fmt.fmt.pix.pixelformat) {
2160 mIspSpDev->set_format(/*isp_src_fmt.format.width*/1920,
2161 /*isp_src_fmt.format.height*/1080,
2162 V4L2_PIX_FMT_NV12,
2163 V4L2_FIELD_NONE, 0);
2164 }
2165 }
2166 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "ispp sd fmt info: %dx%d",
2167 isp_src_fmt.format.width, isp_src_fmt.format.height);
2168 #endif
2169 return ret;
2170 }
2171
2172 XCamReturn
setupHdrLink_vidcap(int hdr_mode,int cif_index,bool enable)2173 CamHwIsp20::setupHdrLink_vidcap(int hdr_mode, int cif_index, bool enable)
2174 {
2175 media_device *device = NULL;
2176 media_entity *entity = NULL;
2177 media_pad *src_pad_s = NULL, *src_pad_m = NULL, *src_pad_l = NULL, *sink_pad = NULL;
2178
2179 // TODO: have some bugs now
2180 return XCAM_RETURN_NO_ERROR;
2181
2182 if (_linked_to_isp)
2183 return XCAM_RETURN_NO_ERROR;
2184
2185 // TODO: normal mode
2186 device = media_device_new (mCifHwInfos.cif_info[cif_index].media_dev_path);
2187
2188 /* Enumerate entities, pads and links. */
2189 media_device_enumerate (device);
2190 entity = media_get_entity_by_name(device, "rockchip-mipi-csi2", strlen("rockchip-mipi-csi2"));
2191 if(entity) {
2192 src_pad_s = (media_pad *)media_entity_get_pad(entity, 1);
2193 if (!src_pad_s) {
2194 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rockchip-mipi-csi2 source pad0 failed !\n");
2195 goto FAIL;
2196 }
2197 } else {
2198 entity = media_get_entity_by_name(device, "rkcif-lvds-subdev", strlen("rkcif-lvds-subdev"));
2199 if(entity) {
2200 src_pad_s = (media_pad *)media_entity_get_pad(entity, 1);
2201 if (!src_pad_s) {
2202 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkcif-lvds-subdev source pad0 failed !\n");
2203 goto FAIL;
2204 }
2205 } else {
2206 entity = media_get_entity_by_name(device, "rkcif-lite-lvds-subdev", strlen("rkcif-lite-lvds-subdev"));
2207 if(entity) {
2208 src_pad_s = (media_pad *)media_entity_get_pad(entity, 1);
2209 if (!src_pad_s) {
2210 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkcif-lite-lvds-subdev source pad0 failed !\n");
2211 goto FAIL;
2212 }
2213 }
2214 }
2215 }
2216
2217 entity = media_get_entity_by_name(device, "stream_cif_mipi_id0", strlen("stream_cif_mipi_id0"));
2218 if(entity) {
2219 sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
2220 if (!sink_pad) {
2221 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_mipi_id0 failed!\n");
2222 goto FAIL;
2223 }
2224 }
2225
2226 entity = media_get_entity_by_name(device, "stream_cif_dvp_id0", strlen("stream_cif_dvp_id0"));
2227 if(entity) {
2228 sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
2229 if (!sink_pad) {
2230 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_dvp_id0 failed!\n");
2231 goto FAIL;
2232 }
2233 }
2234 if (enable)
2235 media_setup_link(device, src_pad_s, sink_pad, MEDIA_LNK_FL_ENABLED);
2236 else
2237 media_setup_link(device, src_pad_s, sink_pad, 0);
2238
2239
2240 entity = media_get_entity_by_name(device, "rockchip-mipi-csi2", strlen("rockchip-mipi-csi2"));
2241 if(entity) {
2242 src_pad_m = (media_pad *)media_entity_get_pad(entity, 2);
2243 if (!src_pad_m) {
2244 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rockchip-mipi-csi2 source pad0 failed !\n");
2245 goto FAIL;
2246 }
2247 } else {
2248 entity = media_get_entity_by_name(device, "rkcif-lvds-subdev", strlen("rkcif-lvds-subdev"));
2249 if(entity) {
2250 src_pad_m = (media_pad *)media_entity_get_pad(entity, 2);
2251 if (!src_pad_m) {
2252 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkcif-lvds-subdev source pad0 failed !\n");
2253 goto FAIL;
2254 }
2255 } else {
2256 entity = media_get_entity_by_name(device, "rkcif-lite-lvds-subdev", strlen("rkcif-lite-lvds-subdev"));
2257 if(entity) {
2258 src_pad_m = (media_pad *)media_entity_get_pad(entity, 2);
2259 if (!src_pad_m) {
2260 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkcif-lite-lvds-subdev source pad0 failed !\n");
2261 goto FAIL;
2262 }
2263 }
2264 }
2265 }
2266
2267 entity = media_get_entity_by_name(device, "stream_cif_mipi_id1", strlen("stream_cif_mipi_id1"));
2268 if(entity) {
2269 sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
2270 if (!sink_pad) {
2271 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_mipi_id1 failed!\n");
2272 goto FAIL;
2273 }
2274 }
2275
2276 entity = media_get_entity_by_name(device, "stream_cif_dvp_id1", strlen("stream_cif_dvp_id1"));
2277 if(entity) {
2278 sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
2279 if (!sink_pad) {
2280 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_dvp_id1 failed!\n");
2281 goto FAIL;
2282 }
2283 }
2284
2285 if (enable)
2286 media_setup_link(device, src_pad_m, sink_pad, MEDIA_LNK_FL_ENABLED);
2287 else
2288 media_setup_link(device, src_pad_m, sink_pad, 0);
2289
2290 #if 0
2291 entity = media_get_entity_by_name(device, "rockchip-mipi-csi2", strlen("rockchip-mipi-csi2"));
2292 if(entity) {
2293 src_pad_l = (media_pad *)media_entity_get_pad(entity, 3);
2294 if (!src_pad_l) {
2295 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rockchip-mipi-csi2 source pad0 failed !\n");
2296 goto FAIL;
2297 }
2298 }
2299
2300 entity = media_get_entity_by_name(device, "stream_cif_mipi_id2", strlen("stream_cif_mipi_id2"));
2301 if(entity) {
2302 sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
2303 if (!sink_pad) {
2304 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_mipi_id2 failed!\n");
2305 goto FAIL;
2306 }
2307 }
2308
2309 entity = media_get_entity_by_name(device, "stream_cif_dvp_id2", strlen("stream_cif_dvp_id2"));
2310 if(entity) {
2311 sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
2312 if (!sink_pad) {
2313 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_dvp_id2 failed!\n");
2314 goto FAIL;
2315 }
2316 }
2317
2318 if (RK_AIQ_HDR_GET_WORKING_MODE(hdr_mode) == RK_AIQ_WORKING_MODE_ISP_HDR3) {
2319 if (enable)
2320 media_setup_link(device, src_pad_l, sink_pad, MEDIA_LNK_FL_ENABLED);
2321 else
2322 media_setup_link(device, src_pad_l, sink_pad, 0);
2323 } else
2324 media_setup_link(device, src_pad_l, sink_pad, 0);
2325 #endif
2326 media_device_unref (device);
2327 return XCAM_RETURN_NO_ERROR;
2328 FAIL:
2329 media_device_unref (device);
2330 return XCAM_RETURN_ERROR_FAILED;
2331 }
2332
2333 XCamReturn
setupHdrLink(int hdr_mode,int isp_index,bool enable)2334 CamHwIsp20::setupHdrLink(int hdr_mode, int isp_index, bool enable)
2335 {
2336 media_device *device = NULL;
2337 media_entity *entity = NULL;
2338 media_pad *src_pad_s = NULL, *src_pad_m = NULL, *src_pad_l = NULL, *sink_pad = NULL;
2339
2340 device = media_device_new (mIspHwInfos.isp_info[isp_index].media_dev_path);
2341 if (!device)
2342 return XCAM_RETURN_ERROR_FAILED;
2343
2344 /* Enumerate entities, pads and links. */
2345 media_device_enumerate (device);
2346 entity = media_get_entity_by_name(device, "rkisp-isp-subdev", strlen("rkisp-isp-subdev"));
2347 if(entity) {
2348 sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
2349 if (!sink_pad) {
2350 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get HDR sink pad failed!\n");
2351 goto FAIL;
2352 }
2353 }
2354
2355 #if 0
2356 entity = media_get_entity_by_name(device, mIspHwInfos.isp_info[isp_index].linked_vicap,
2357 strlen(mIspHwInfos.isp_info[isp_index].linked_vicap));
2358 if (entity) {
2359 media_pad* linked_vicap_pad = (media_pad *)media_entity_get_pad(entity, 0);
2360 if (linked_vicap_pad) {
2361 if (enable) {
2362 media_setup_link(device, linked_vicap_pad, sink_pad, 0);
2363 } else {
2364 media_setup_link(device, linked_vicap_pad, sink_pad, MEDIA_LNK_FL_ENABLED);
2365 }
2366 }
2367 }
2368 #endif
2369 entity = media_get_entity_by_name(device, "rkisp_rawrd2_s", strlen("rkisp_rawrd2_s"));
2370 if(entity) {
2371 src_pad_s = (media_pad *)media_entity_get_pad(entity, 0);
2372 if (!src_pad_s) {
2373 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get HDR source pad s failed!\n");
2374 goto FAIL;
2375 }
2376 }
2377 if (src_pad_s && sink_pad) {
2378 if (enable)
2379 media_setup_link(device, src_pad_s, sink_pad, MEDIA_LNK_FL_ENABLED);
2380 else
2381 media_setup_link(device, src_pad_s, sink_pad, 0);
2382 }
2383
2384 entity = media_get_entity_by_name(device, "rkisp_rawrd0_m", strlen("rkisp_rawrd0_m"));
2385 if(entity) {
2386 src_pad_m = (media_pad *)media_entity_get_pad(entity, 0);
2387 if (!src_pad_m) {
2388 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get HDR source pad m failed!\n");
2389 goto FAIL;
2390 }
2391 }
2392
2393 if (src_pad_m && sink_pad) {
2394 if (RK_AIQ_HDR_GET_WORKING_MODE(hdr_mode) >= RK_AIQ_WORKING_MODE_ISP_HDR2 && enable) {
2395 media_setup_link(device, src_pad_m, sink_pad, MEDIA_LNK_FL_ENABLED);
2396 } else
2397 media_setup_link(device, src_pad_m, sink_pad, 0);
2398 }
2399
2400 entity = media_get_entity_by_name(device, "rkisp_rawrd1_l", strlen("rkisp_rawrd1_l"));
2401 if(entity) {
2402 src_pad_l = (media_pad *)media_entity_get_pad(entity, 0);
2403 if (!src_pad_l) {
2404 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get HDR source pad l failed!\n");
2405 goto FAIL;
2406 }
2407 }
2408
2409 if (src_pad_l && sink_pad) {
2410 if (RK_AIQ_HDR_GET_WORKING_MODE(hdr_mode) == RK_AIQ_WORKING_MODE_ISP_HDR3 && enable) {
2411 media_setup_link(device, src_pad_l, sink_pad, MEDIA_LNK_FL_ENABLED);
2412 } else
2413 media_setup_link(device, src_pad_l, sink_pad, 0);
2414 }
2415 media_device_unref (device);
2416 return XCAM_RETURN_NO_ERROR;
2417 FAIL:
2418 media_device_unref (device);
2419 return XCAM_RETURN_ERROR_FAILED;
2420 }
2421
2422 XCamReturn
setExpDelayInfo(int mode)2423 CamHwIsp20::setExpDelayInfo(int mode)
2424 {
2425 ENTER_CAMHW_FUNCTION();
2426 BaseSensorHw* sensorHw;
2427 sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
2428
2429 if(mode != RK_AIQ_WORKING_MODE_NORMAL) {
2430 sensorHw->set_exp_delay_info(_cur_calib_infos.sensor.CISExpUpdate.Hdr.time_update,
2431 _cur_calib_infos.sensor.CISExpUpdate.Hdr.gain_update,
2432 _cur_calib_infos.sensor.CISDcgSet.Hdr.support_en ? \
2433 _cur_calib_infos.sensor.CISExpUpdate.Hdr.dcg_update : -1);
2434
2435 sint32_t timeDelay = _cur_calib_infos.sensor.CISExpUpdate.Hdr.time_update;
2436 sint32_t gainDelay = _cur_calib_infos.sensor.CISExpUpdate.Hdr.gain_update;
2437 _exp_delay = timeDelay > gainDelay ? timeDelay : gainDelay;
2438 } else {
2439 sensorHw->set_exp_delay_info(_cur_calib_infos.sensor.CISExpUpdate.Linear.time_update,
2440 _cur_calib_infos.sensor.CISExpUpdate.Linear.gain_update,
2441 _cur_calib_infos.sensor.CISDcgSet.Linear.support_en ? \
2442 _cur_calib_infos.sensor.CISExpUpdate.Linear.dcg_update : -1);
2443
2444 sint32_t timeDelay = _cur_calib_infos.sensor.CISExpUpdate.Linear.time_update;
2445 sint32_t gainDelay = _cur_calib_infos.sensor.CISExpUpdate.Linear.gain_update;
2446 _exp_delay = timeDelay > gainDelay ? timeDelay : gainDelay;
2447 }
2448
2449 EXIT_CAMHW_FUNCTION();
2450 return XCAM_RETURN_NO_ERROR;
2451 }
2452
2453 XCamReturn
setLensVcmCfg(struct rkmodule_inf & mod_info)2454 CamHwIsp20::setLensVcmCfg(struct rkmodule_inf& mod_info)
2455 {
2456 ENTER_CAMHW_FUNCTION();
2457 LensHw* lensHw = mLensDev.get_cast_ptr<LensHw>();
2458 rk_aiq_lens_vcmcfg old_cfg, new_cfg;
2459 int old_maxpos, new_maxpos;
2460 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2461
2462 if (lensHw) {
2463 ret = lensHw->getLensVcmCfg(old_cfg);
2464 if (ret != XCAM_RETURN_NO_ERROR)
2465 return ret;
2466 ret = lensHw->getLensVcmMaxlogpos(old_maxpos);
2467 if (ret != XCAM_RETURN_NO_ERROR)
2468 return ret;
2469
2470 CalibDbV2_Af_VcmCfg_t* vcmcfg = &_cur_calib_infos.af.vcmcfg;
2471 float posture_diff = vcmcfg->posture_diff;
2472
2473 new_cfg = old_cfg;
2474 if (vcmcfg->start_current != -1) {
2475 new_cfg.start_ma = vcmcfg->start_current;
2476 }
2477 if (vcmcfg->rated_current != -1) {
2478 new_cfg.rated_ma = vcmcfg->rated_current;
2479 }
2480 if (vcmcfg->step_mode != -1) {
2481 new_cfg.step_mode = vcmcfg->step_mode;
2482 }
2483
2484 if (vcmcfg->start_current == -1 && vcmcfg->rated_current == -1 && vcmcfg->step_mode == -1) {
2485 if (mod_info.af.flag) {
2486 new_cfg.start_ma = mod_info.af.af_otp[0].vcm_start;
2487 new_cfg.rated_ma = mod_info.af.af_otp[0].vcm_end;
2488
2489 if (posture_diff != 0) {
2490 int range = new_cfg.rated_ma - new_cfg.start_ma;
2491 int start_ma = new_cfg.start_ma;
2492 int rated_ma = new_cfg.rated_ma;
2493
2494 new_cfg.start_ma = start_ma - (int)(range * posture_diff);
2495 new_cfg.rated_ma = rated_ma + (int)(range * posture_diff);
2496
2497 LOGD_AF("posture_diff %f, start_ma %d -> %d, rated_ma %d -> %d",
2498 posture_diff, start_ma, new_cfg.start_ma, rated_ma, new_cfg.rated_ma);
2499 }
2500 }
2501 }
2502
2503 if ((new_cfg.start_ma != old_cfg.start_ma) ||
2504 (new_cfg.rated_ma != old_cfg.rated_ma) ||
2505 (new_cfg.step_mode != old_cfg.step_mode)) {
2506 ret = lensHw->setLensVcmCfg(new_cfg);
2507 }
2508
2509 new_maxpos = old_maxpos;
2510 if (vcmcfg->max_logical_pos > 0) {
2511 new_maxpos = vcmcfg->max_logical_pos;
2512 }
2513 if (old_maxpos != new_maxpos) {
2514 ret = lensHw->setLensVcmMaxlogpos(new_maxpos);
2515 }
2516 }
2517 EXIT_CAMHW_FUNCTION();
2518 return ret;
2519 }
2520
2521 XCamReturn
get_sensor_pdafinfo(rk_sensor_full_info_t * sensor_info,rk_sensor_pdaf_info_t * pdaf_info)2522 CamHwIsp20::get_sensor_pdafinfo(rk_sensor_full_info_t *sensor_info,
2523 rk_sensor_pdaf_info_t *pdaf_info) {
2524 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2525 struct rkmodule_channel_info channel;
2526 memset(&channel, 0, sizeof(struct rkmodule_channel_info));
2527
2528 V4l2SubDevice vdev(sensor_info->device_name.c_str());
2529 ret = vdev.open();
2530 if (ret != XCAM_RETURN_NO_ERROR) {
2531 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to open dev (%s)", sensor_info->device_name.c_str());
2532 return XCAM_RETURN_ERROR_FAILED;
2533 }
2534
2535 pdaf_info->pdaf_support = false;
2536 for (int i = 0; i < 4; i++) {
2537 channel.index = i;
2538 if (vdev.io_control(RKMODULE_GET_CHANNEL_INFO, &channel) == 0) {
2539 if (channel.bus_fmt == MEDIA_BUS_FMT_SPD_2X8) {
2540 pdaf_info->pdaf_support = true;
2541 pdaf_info->pdaf_vc = i;
2542 pdaf_info->pdaf_code = channel.bus_fmt;
2543 pdaf_info->pdaf_width = channel.width;
2544 pdaf_info->pdaf_height = channel.height;
2545 if (channel.data_bit == 10)
2546 pdaf_info->pdaf_pixelformat = V4L2_PIX_FMT_SRGGB10;
2547 else if (channel.data_bit == 12)
2548 pdaf_info->pdaf_pixelformat = V4L2_PIX_FMT_SRGGB12;
2549 else if (channel.data_bit == 8)
2550 pdaf_info->pdaf_pixelformat = V4L2_PIX_FMT_SRGGB8;
2551 else
2552 pdaf_info->pdaf_pixelformat = V4L2_PIX_FMT_SRGGB16;
2553 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "channel.bus_fmt 0x%x, pdaf_width %d, pdaf_height %d",
2554 channel.bus_fmt, pdaf_info->pdaf_width, pdaf_info->pdaf_height);
2555 break;
2556 }
2557 }
2558 }
2559
2560 if (pdaf_info->pdaf_support) {
2561 if (sensor_info->linked_to_isp) {
2562 switch (pdaf_info->pdaf_vc) {
2563 case 0:
2564 strcpy(pdaf_info->pdaf_vdev, sensor_info->isp_info->rawwr0_path);
2565 break;
2566 case 1:
2567 strcpy(pdaf_info->pdaf_vdev, sensor_info->isp_info->rawwr1_path);
2568 break;
2569 case 2:
2570 strcpy(pdaf_info->pdaf_vdev, sensor_info->isp_info->rawwr2_path);
2571 break;
2572 case 3:
2573 default:
2574 strcpy(pdaf_info->pdaf_vdev, sensor_info->isp_info->rawwr3_path);
2575 break;
2576 }
2577 } else {
2578 switch (pdaf_info->pdaf_vc) {
2579 case 0:
2580 strcpy(pdaf_info->pdaf_vdev, sensor_info->cif_info->mipi_id0);
2581 break;
2582 case 1:
2583 strcpy(pdaf_info->pdaf_vdev, sensor_info->cif_info->mipi_id1);
2584 break;
2585 case 2:
2586 strcpy(pdaf_info->pdaf_vdev, sensor_info->cif_info->mipi_id2);
2587 break;
2588 case 3:
2589 default:
2590 strcpy(pdaf_info->pdaf_vdev, sensor_info->cif_info->mipi_id3);
2591 break;
2592 }
2593 }
2594 }
2595 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "%s: pdaf_vdev %s", __func__, pdaf_info->pdaf_vdev);
2596
2597 vdev.close();
2598 return ret;
2599 }
2600
isOnlineByWorkingMode()2601 bool CamHwIsp20::isOnlineByWorkingMode()
2602 {
2603 return true;
2604 }
2605
2606 void
setCalib(const CamCalibDbV2Context_t * calibv2)2607 CamHwIsp20::setCalib(const CamCalibDbV2Context_t* calibv2)
2608 {
2609 mCalibDbV2 = calibv2;
2610 CalibDbV2_MFNR_t* mfnr =
2611 (CalibDbV2_MFNR_t*)CALIBDBV2_GET_MODULE_PTR((void*)(mCalibDbV2), mfnr_v1);
2612 if (mfnr) {
2613 _cur_calib_infos.mfnr.enable = mfnr->TuningPara.enable;
2614 _cur_calib_infos.mfnr.motion_detect_en = mfnr->TuningPara.motion_detect_en;
2615 } else {
2616 _cur_calib_infos.mfnr.enable = false;
2617 _cur_calib_infos.mfnr.motion_detect_en = false;
2618 }
2619
2620 CalibDb_Aec_ParaV2_t* aec =
2621 (CalibDb_Aec_ParaV2_t*)CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, ae_calib);
2622 if (aec) {
2623 _cur_calib_infos.aec.IrisType = aec->IrisCtrl.IrisType;
2624 } else {
2625 _cur_calib_infos.aec.IrisType = IRISV2_DC_TYPE;
2626 }
2627
2628 if (CHECK_ISP_HW_V32()) {
2629 CalibDbV2_AFV31_t *af_v31 =
2630 (CalibDbV2_AFV31_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, af_v31));
2631 if (af_v31) {
2632 _cur_calib_infos.af.vcmcfg = af_v31->TuningPara.vcmcfg;
2633 } else {
2634 memset(&_cur_calib_infos.af.vcmcfg, 0, sizeof(CalibDbV2_Af_VcmCfg_t));
2635 }
2636 memset(&_cur_calib_infos.af.ldg_param, 0, sizeof(CalibDbV2_Af_LdgParam_t));
2637 } else if (CHECK_ISP_HW_V30()) {
2638 CalibDbV2_AFV30_t *af_v30 =
2639 (CalibDbV2_AFV30_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, af_v30));
2640 if (af_v30) {
2641 _cur_calib_infos.af.vcmcfg = af_v30->TuningPara.vcmcfg;
2642 } else {
2643 memset(&_cur_calib_infos.af.vcmcfg, 0, sizeof(CalibDbV2_Af_VcmCfg_t));
2644 }
2645 memset(&_cur_calib_infos.af.ldg_param, 0, sizeof(CalibDbV2_Af_LdgParam_t));
2646 } else if (CHECK_ISP_HW_V32_LITE()) {
2647 CalibDbV2_AFV32_t *af_v32 =
2648 (CalibDbV2_AFV32_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, af_v32));
2649 if (af_v32) {
2650 _cur_calib_infos.af.vcmcfg = af_v32->TuningPara.vcmcfg;
2651 } else {
2652 memset(&_cur_calib_infos.af.vcmcfg, 0, sizeof(CalibDbV2_Af_VcmCfg_t));
2653 }
2654 memset(&_cur_calib_infos.af.ldg_param, 0, sizeof(CalibDbV2_Af_LdgParam_t));
2655 } else {
2656 CalibDbV2_AF_t *af =
2657 (CalibDbV2_AF_t*)CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, af);
2658 if (af) {
2659 _cur_calib_infos.af.vcmcfg = af->TuningPara.vcmcfg;
2660 _cur_calib_infos.af.ldg_param = af->TuningPara.ldg_param;
2661 _cur_calib_infos.af.highlight = af->TuningPara.highlight;
2662 } else {
2663 memset(&_cur_calib_infos.af.vcmcfg, 0, sizeof(CalibDbV2_Af_VcmCfg_t));
2664 memset(&_cur_calib_infos.af.ldg_param, 0, sizeof(CalibDbV2_Af_LdgParam_t));
2665 }
2666 }
2667
2668 CalibDb_Sensor_ParaV2_t* sensor_calib =
2669 (CalibDb_Sensor_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, sensor_calib));
2670 if (sensor_calib) {
2671 _cur_calib_infos.sensor.CISDcgSet = sensor_calib->CISDcgSet;
2672 _cur_calib_infos.sensor.CISExpUpdate = sensor_calib->CISExpUpdate;
2673 } else {
2674 memset(&_cur_calib_infos.sensor, 0,
2675 sizeof(_cur_calib_infos.sensor));
2676 }
2677
2678 // update infos to sensor hw
2679 setExpDelayInfo(_hdr_mode);
2680 }
2681
2682 XCamReturn
prepare(uint32_t width,uint32_t height,int mode,int t_delay,int g_delay)2683 CamHwIsp20::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
2684 {
2685 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2686 BaseSensorHw* sensorHw = NULL;
2687 LensHw* lensHw = mLensDev.get_cast_ptr<LensHw>();
2688
2689 ENTER_CAMHW_FUNCTION();
2690
2691 XCAM_ASSERT (mCalibDbV2);
2692
2693 _hdr_mode = mode;
2694
2695 Isp20Params::set_working_mode(_hdr_mode);
2696
2697 std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
2698 if ((it = mSensorHwInfos.find(sns_name)) == mSensorHwInfos.end()) {
2699 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_name);
2700 return XCAM_RETURN_ERROR_SENSOR;
2701 }
2702
2703 rk_sensor_full_info_t *s_info = it->second.ptr();
2704 int isp_index = s_info->isp_info->logic_id;
2705 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "sensor_name(%s) is linked to isp_index(%d)",
2706 sns_name, isp_index);
2707
2708 if ((_hdr_mode > 0 && isOnlineByWorkingMode()) ||
2709 (!_linked_to_isp && !mVicapIspPhyLinkSupported)) {
2710 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "use read back mode!");
2711 mNoReadBack = false;
2712 }
2713
2714 // multimplex mode should be using readback mode
2715 if (s_info->isp_info->isMultiplex)
2716 mNoReadBack = false;
2717
2718 if (mTbInfo.prd_type == RK_AIQ_PRD_TYPE_TB_DOORLOCK ||
2719 mTbInfo.prd_type == RK_AIQ_PRD_TYPE_TB_BATIPC) {
2720 mNoReadBack = true;
2721 }
2722
2723 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "isp hw working mode: %s !", mNoReadBack ? "online" : "readback");
2724
2725 //sof event
2726 if (!mIspSofStream.ptr()) {
2727 if (mNoReadBack) {
2728 if (mTbInfo.prd_type == RK_AIQ_PRD_TYPE_TB_DOORLOCK ||
2729 mTbInfo.prd_type == RK_AIQ_PRD_TYPE_TB_BATIPC) {
2730 mIspSofStream = new RKSofEventStream(_cif_csi2_sd, ISP_POLL_SOF);
2731 } else {
2732 mIspSofStream = new RKSofEventStream(mIspCoreDev, ISP_POLL_SOF);
2733 }
2734 } else {
2735 if (_linked_to_isp)
2736 mIspSofStream = new RKSofEventStream(mIspCoreDev, ISP_POLL_SOF);
2737 else
2738 mIspSofStream = new RKSofEventStream(_cif_csi2_sd, ISP_POLL_SOF, _linked_to_1608);
2739 }
2740 mIspSofStream->setPollCallback (this);
2741 }
2742
2743 _isp_stream_status = ISP_STREAM_STATUS_INVALID;
2744 if (/*mIsGroupMode*/true) {
2745 mIspStremEvtTh = new RkStreamEventPollThread("StreamEvt",
2746 new V4l2Device (s_info->isp_info->input_params_path),
2747 this);
2748 }
2749
2750 if (!mNoReadBack) {
2751 setupHdrLink(RK_AIQ_HDR_GET_WORKING_MODE(_hdr_mode), isp_index, true);
2752 if (!_linked_to_isp) {
2753 int cif_index = s_info->cif_info->model_idx;
2754 setupHdrLink_vidcap(_hdr_mode, cif_index, true);
2755 }
2756 } else
2757 setupHdrLink(RK_AIQ_WORKING_MODE_ISP_HDR3, isp_index, false);
2758
2759 sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
2760 ret = sensorHw->set_working_mode(mode);
2761 if (ret) {
2762 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "set sensor mode error !");
2763 return ret;
2764 }
2765
2766 if (mIsGroupMode) {
2767 ret = sensorHw->set_sync_mode(mIsMain ? INTERNAL_MASTER_MODE : EXTERNAL_MASTER_MODE);
2768 if (ret) {
2769 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "set sensor group mode error !\n");
2770 }
2771 } else {
2772 sensorHw->set_sync_mode(NO_SYNC_MODE);
2773 }
2774
2775 #ifndef USE_RAWSTREAM_LIB
2776 mRawCapUnit->set_working_mode(mode);
2777 mRawProcUnit->set_working_mode(mode);
2778 #endif
2779
2780 setExpDelayInfo(mode);
2781 setLensVcmCfg(s_info->mod_info);
2782 xcam_mem_clear(_lens_des);
2783 if (lensHw)
2784 lensHw->getLensModeData(_lens_des);
2785
2786 #if defined(ISP_HW_V20)
2787 _ispp_module_init_ens = 0;
2788 #endif
2789 ret = setupPipelineFmt();
2790 if (ret < 0) {
2791 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setupPipelineFmt err: %d\n", ret);
2792 }
2793
2794 struct v4l2_subdev_format isp_src_fmt;
2795 memset(&isp_src_fmt, 0, sizeof(isp_src_fmt));
2796 isp_src_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
2797 isp_src_fmt.pad = 2;
2798 ret = mIspCoreDev->getFormat(isp_src_fmt);
2799 #if defined(RKAIQ_HAVE_MULTIISP)
2800 if (ret == XCAM_RETURN_NO_ERROR && s_info->isp_info->is_multi_isp_mode) {
2801 uint16_t extended_pixel = mMultiIspExtendedPixel;
2802 uint32_t width = isp_src_fmt.format.width;
2803 uint32_t height = isp_src_fmt.format.height;
2804 mParamsSplitter = new IspParamsSplitter();
2805 mParamsSplitter->SetPicInfo({0, 0, width, height})
2806 .SetLeftIspRect({0, 0, width / 2 + extended_pixel, height})
2807 .SetRightIspRect({width / 2 - extended_pixel, 0, width / 2 + extended_pixel, height});
2808 IspParamsSplitter::Rectangle f = mParamsSplitter->GetPicInfo();
2809 IspParamsSplitter::Rectangle l = mParamsSplitter->GetLeftIspRect();
2810 IspParamsSplitter::Rectangle r = mParamsSplitter->GetRightIspRect();
2811 LOGD_ANALYZER(
2812 "Set Multi-ISP Mode ParamSplitter:\n"
2813 " Extended Pixel%d\n"
2814 " F : { %u, %u, %u, %u }\n"
2815 " L : { %u, %u, %u, %u }\n"
2816 " R : { %u, %u, %u, %u }\n",
2817 extended_pixel,
2818 f.x, f.y, f.w, f.h,
2819 l.x, l.y, l.w, l.h,
2820 r.x, r.y, r.w, r.h);
2821 }
2822 #endif
2823
2824 #ifndef USE_RAWSTREAM_LIB
2825 if (!_linked_to_isp && !mNoReadBack) {
2826 if (!_linked_to_1608) {
2827 mRawCapUnit->prepare_cif_mipi();
2828 } else {
2829 if (CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId]) {
2830 mRawCapUnit->prepare_cif_mipi();
2831 CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId] = 0;
2832 }
2833 }
2834 }
2835 #endif
2836
2837 #if defined(RKAIQ_ENABLE_SPSTREAM)
2838 if ((_cur_calib_infos.mfnr.enable && _cur_calib_infos.mfnr.motion_detect_en) || _cur_calib_infos.af.ldg_param.enable) {
2839 mSpStreamUnit->prepare(&_cur_calib_infos.af.ldg_param, &_cur_calib_infos.af.highlight);
2840 }
2841 #endif
2842 CalibDbV2_Af_Pdaf_t *pdaf = NULL;
2843 if (CHECK_ISP_HW_V30()) {
2844 CalibDbV2_AFV30_t *af_v30 =
2845 (CalibDbV2_AFV30_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, af_v30));
2846 pdaf = &af_v30->TuningPara.pdaf;
2847 }
2848
2849 get_sensor_pdafinfo(s_info, &mPdafInfo);
2850 if (mPdafInfo.pdaf_support && pdaf && pdaf->enable) {
2851 mPdafInfo.pdaf_lrdiffline = pdaf->pdLRInDiffLine;
2852 mPdafStreamUnit->prepare(&mPdafInfo);
2853 } else {
2854 mPdafInfo.pdaf_support = false;
2855 }
2856
2857 if (mCifScaleStream.ptr()) {
2858 mCifScaleStream->set_working_mode(mode);
2859 mCifScaleStream->prepare();
2860 }
2861
2862 _state = CAM_HW_STATE_PREPARED;
2863 EXIT_CAMHW_FUNCTION();
2864 return ret;
2865 }
2866
2867 XCamReturn
start()2868 CamHwIsp20::start()
2869 {
2870 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2871 BaseSensorHw* sensorHw = NULL;
2872 LensHw* lensHw = NULL;
2873
2874 ENTER_CAMHW_FUNCTION();
2875 sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
2876 lensHw = mLensDev.get_cast_ptr<LensHw>();
2877
2878 if (_state != CAM_HW_STATE_PREPARED &&
2879 _state != CAM_HW_STATE_STOPPED) {
2880 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "camhw state err: %d\n", ret);
2881 return XCAM_RETURN_ERROR_FAILED;
2882 }
2883
2884 #ifndef DISABLE_PARAMS_ASSEMBLER
2885 // set inital params
2886 if (mParamsAssembler.ptr()) {
2887 mParamsAssembler->setCamPhyId(mCamPhyId);
2888 ret = mParamsAssembler->start();
2889 if (ret < 0) {
2890 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "params assembler start err: %d\n", ret);
2891 }
2892
2893 if (mParamsAssembler->ready())
2894 setIspConfig();
2895 }
2896 #endif
2897 if (mLumaStream.ptr())
2898 mLumaStream->start();
2899 if (mIspSofStream.ptr()) {
2900 mIspSofStream->setCamPhyId(mCamPhyId);
2901 mIspSofStream->start();
2902 }
2903
2904 if (_linked_to_isp)
2905 mIspCoreDev->subscribe_event(V4L2_EVENT_FRAME_SYNC);
2906
2907 if (mIspStremEvtTh.ptr()) {
2908 ret = mIspStremEvtTh->start();
2909 if (ret < 0) {
2910 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "start isp stream event failed: %d\n", ret);
2911 }
2912 } else {
2913 ret = hdr_mipi_start_mode(_hdr_mode);
2914 if (ret < 0) {
2915 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
2916 }
2917 }
2918
2919 ret = mIspCoreDev->start();
2920 if (ret < 0) {
2921 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "start isp core dev err: %d\n", ret);
2922 }
2923 if (mIspStatsStream.ptr())
2924 mIspStatsStream->start();
2925
2926 if (mFlashLight.ptr()) {
2927 ret = mFlashLight->start();
2928 if (ret < 0) {
2929 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "start flashlight err: %d\n", ret);
2930 }
2931 }
2932 if (mFlashLightIr.ptr()) {
2933 ret = mFlashLightIr->start();
2934 if (ret < 0) {
2935 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "start flashlight ir err: %d\n", ret);
2936 }
2937 }
2938 #if defined(RKAIQ_ENABLE_SPSTREAM)
2939 if ((_cur_calib_infos.mfnr.enable && _cur_calib_infos.mfnr.motion_detect_en) || _cur_calib_infos.af.ldg_param.enable) {
2940 mSpStreamUnit->start();
2941 }
2942 #endif
2943 if (mPdafInfo.pdaf_support) {
2944 mPdafStreamUnit->start();
2945 }
2946
2947 #ifndef DISABLE_PARAMS_POLL_THREAD
2948 if (mIspParamStream.ptr())
2949 mIspParamStream->startThreadOnly();
2950 #endif
2951
2952 #if defined(ISP_HW_V20)
2953 if (mNrStreamProcUnit.ptr())
2954 mNrStreamProcUnit->start();
2955
2956 if (mTnrStreamProcUnit.ptr())
2957 mTnrStreamProcUnit->start();
2958
2959 if (mFecParamStream.ptr())
2960 mFecParamStream->start();
2961 #endif
2962 sensorHw->start();
2963 if (lensHw)
2964 lensHw->start();
2965 _is_exit = false;
2966 _state = CAM_HW_STATE_STARTED;
2967
2968 #ifndef DISABLE_PARAMS_ASSEMBLER
2969 // in fastboot server stage, F1 param maybe ready
2970 // before _state = CAM_HW_STATE_STARTED.
2971 if (mParamsAssembler->ready())
2972 setIspConfig();
2973 #endif
2974 EXIT_CAMHW_FUNCTION();
2975 return ret;
2976 }
2977
2978
2979 XCamReturn
hdr_mipi_prepare_mode(int mode)2980 CamHwIsp20::hdr_mipi_prepare_mode(int mode)
2981 {
2982 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2983 int new_mode = RK_AIQ_HDR_GET_WORKING_MODE(mode);
2984
2985 #ifndef USE_RAWSTREAM_LIB
2986 if (!mNoReadBack) {
2987 bool init_state = true;
2988 if (_linked_to_1608) {
2989 if (CamHwIsp20::rk1608_share_inf.us_prepare_cnt > 0) {
2990 init_state = false;
2991 }
2992 CamHwIsp20::rk1608_share_inf.us_prepare_cnt++;
2993 if (CamHwIsp20::rk1608_share_inf.us_prepare_cnt > 10)
2994 CamHwIsp20::rk1608_share_inf.us_prepare_cnt = 10;
2995 }
2996
2997 if (new_mode == RK_AIQ_WORKING_MODE_NORMAL) {
2998 if (!_linked_to_1608) {
2999 ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_0);
3000 } else {
3001 if (init_state) {
3002 ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_0);
3003 }
3004 }
3005 ret = mRawProcUnit->prepare(MIPI_STREAM_IDX_0);
3006 } else if (new_mode == RK_AIQ_WORKING_MODE_ISP_HDR2) {
3007 if (!_linked_to_1608) {
3008 ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_0 | MIPI_STREAM_IDX_1);
3009 } else {
3010 if (init_state) {
3011 ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_0 | MIPI_STREAM_IDX_1);
3012 }
3013 }
3014 ret = mRawProcUnit->prepare(MIPI_STREAM_IDX_0 | MIPI_STREAM_IDX_1);
3015 } else {
3016 if (!_linked_to_1608) {
3017 ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_ALL);
3018 } else {
3019 if (init_state) {
3020 ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_ALL);
3021 }
3022 }
3023 ret = mRawProcUnit->prepare(MIPI_STREAM_IDX_ALL);
3024 }
3025 if (ret < 0) {
3026 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
3027 }
3028 }
3029 #endif
3030 return ret;
3031 }
3032
3033 XCamReturn
hdr_mipi_start_mode(int mode)3034 CamHwIsp20::hdr_mipi_start_mode(int mode)
3035 {
3036 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3037 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s enter", __FUNCTION__);
3038
3039 #ifndef USE_RAWSTREAM_LIB
3040 if (!mNoReadBack) {
3041 if (!_linked_to_1608) {
3042 mRawCapUnit->start(mode);
3043 mRawProcUnit->start(mode);
3044 } else {
3045 SmartLock locker(_sync_1608_mutex);
3046 bool stream_on = false;
3047 CamHwIsp20::rk1608_share_inf.us_stream_cnt++;
3048 if (CamHwIsp20::rk1608_share_inf.us_stream_cnt > 10)
3049 CamHwIsp20::rk1608_share_inf.us_stream_cnt = 10;
3050 if (CamHwIsp20::rk1608_share_inf.us_stream_cnt >= CamHwIsp20::rk1608_share_inf.en_sns_num) {
3051 // only processed the last streaming
3052 stream_on = true;
3053 }
3054 if (stream_on) {
3055 mRawCapUnit->start(mode);
3056 }
3057 mRawProcUnit->start(mode);
3058 if (stream_on) {
3059 _sync_1608_done = true;
3060 _sync_done_cond.broadcast();
3061 } else {
3062 _sync_1608_done = false;
3063 }
3064 }
3065 }
3066 #endif
3067 if (mCifScaleStream.ptr())
3068 mCifScaleStream->start();
3069 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s exit", __FUNCTION__);
3070 return ret;
3071 }
3072
3073 XCamReturn
hdr_mipi_stop()3074 CamHwIsp20::hdr_mipi_stop()
3075 {
3076 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3077 #ifndef USE_RAWSTREAM_LIB
3078 mRawProcUnit->stop();
3079
3080 if (!_linked_to_1608) {
3081 mRawCapUnit->stop();
3082 } else {
3083 bool stop_en = false;
3084 CamHwIsp20::rk1608_share_inf.us_stop_cnt++;
3085 if (CamHwIsp20::rk1608_share_inf.us_stop_cnt > 10)
3086 CamHwIsp20::rk1608_share_inf.us_stop_cnt = 10;
3087 if (CamHwIsp20::rk1608_share_inf.us_stop_cnt == CamHwIsp20::rk1608_share_inf.en_sns_num) {
3088 stop_en = true;
3089 }
3090 if (stop_en) {
3091 mRawCapUnit->stop();
3092 }
3093 }
3094 #endif
3095 if (mCifScaleStream.ptr())
3096 mCifScaleStream->stop();
3097 return ret;
3098 }
3099
stop()3100 XCamReturn CamHwIsp20::stop()
3101 {
3102 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3103 BaseSensorHw* sensorHw = NULL;
3104 LensHw* lensHw = NULL;
3105
3106 ENTER_CAMHW_FUNCTION();
3107
3108 if (_state == CAM_HW_STATE_STOPPED)
3109 return ret;
3110
3111 if (mIspStatsStream.ptr())
3112 mIspStatsStream->stop();
3113 if (mLumaStream.ptr())
3114 mLumaStream->stop();
3115 if (mIspSofStream.ptr())
3116 mIspSofStream->stop();
3117
3118 #if defined(RKAIQ_ENABLE_SPSTREAM)
3119 if ((_cur_calib_infos.mfnr.enable && _cur_calib_infos.mfnr.motion_detect_en) || _cur_calib_infos.af.ldg_param.enable) {
3120 mSpStreamUnit->stop();
3121 }
3122 #endif
3123 if (mPdafInfo.pdaf_support) {
3124 mPdafStreamUnit->stop();
3125 }
3126
3127 // stop after pollthread, ensure that no new events
3128 // come into snesorHw
3129 sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
3130 sensorHw->stop();
3131
3132 lensHw = mLensDev.get_cast_ptr<LensHw>();
3133 if (lensHw)
3134 lensHw->stop();
3135
3136 if (_linked_to_isp)
3137 mIspCoreDev->unsubscribe_event(V4L2_EVENT_FRAME_SYNC);
3138 ret = mIspCoreDev->stop();
3139 if (ret < 0) {
3140 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "stop isp core dev err: %d\n", ret);
3141 }
3142
3143 #ifndef DISABLE_PARAMS_ASSEMBLER
3144 if (mParamsAssembler.ptr())
3145 mParamsAssembler->stop();
3146 #endif
3147 if (mIspStremEvtTh.ptr()) {
3148 mIspStremEvtTh->stop();
3149 if (/*_isp_stream_status == ISP_STREAM_STATUS_STREAM_ON*/true) {
3150 SmartLock locker(_stop_cond_mutex);
3151 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "stop isp stream");
3152 #ifndef DISABLE_PARAMS_POLL_THREAD
3153 if (mIspParamStream.ptr())
3154 mIspParamStream->stop();
3155 #else
3156 if (mIspParamsDev.ptr())
3157 mIspParamsDev->stop();
3158 #endif
3159 hdr_mipi_stop();
3160 _isp_stream_status = ISP_STREAM_STATUS_INVALID;
3161 }
3162 } else {
3163 #ifndef DISABLE_PARAMS_POLL_THREAD
3164 if (mIspParamStream.ptr())
3165 mIspParamStream->stop();
3166 #else
3167 if (mIspParamsDev.ptr())
3168 mIspParamsDev->stop();
3169 #endif
3170
3171 if (!mNoReadBack) {
3172 ret = hdr_mipi_stop();
3173 if (ret < 0) {
3174 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi stop err: %d\n", ret);
3175 }
3176 }
3177 }
3178
3179 #if defined(ISP_HW_V20)
3180 if (mTnrStreamProcUnit.ptr())
3181 mTnrStreamProcUnit->stop();
3182
3183 if (mNrStreamProcUnit.ptr())
3184 mNrStreamProcUnit->stop();
3185
3186 if (mFecParamStream.ptr())
3187 mFecParamStream->stop();
3188 #endif
3189
3190 if (mFlashLight.ptr()) {
3191 ret = mFlashLight->stop();
3192 if (ret < 0) {
3193 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "stop flashlight err: %d\n", ret);
3194 }
3195 }
3196 if (mFlashLightIr.ptr()) {
3197 mFlashLightIr->keep_status(mKpHwSt);
3198 ret = mFlashLightIr->stop();
3199 if (ret < 0) {
3200 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "stop flashlight ir err: %d\n", ret);
3201 }
3202 }
3203
3204 if (!mKpHwSt)
3205 setIrcutParams(false);
3206
3207 {
3208 SmartLock locker (_isp_params_cfg_mutex);
3209 _camIsp3aResult.clear();
3210 _effecting_ispparam_map.clear();
3211 }
3212
3213 {
3214 // TODO: [baron] PAL/NTSC mode convert[Start / Stop]. recovery cnt.
3215 // [Stage 02] {start} <-> {stop}
3216 CamHwIsp20::rk1608_share_inf.us_stream_cnt = 0;
3217 if (CamHwIsp20::rk1608_share_inf.us_stop_cnt >= CamHwIsp20::rk1608_share_inf.en_sns_num) {
3218 // ensure all valid 1608-sensor stoped.
3219 CamHwIsp20::rk1608_share_inf.us_stop_cnt = 0;
3220 }
3221 }
3222
3223 _state = CAM_HW_STATE_STOPPED;
3224
3225 EXIT_CAMHW_FUNCTION();
3226 return ret;
3227 }
3228
pause()3229 XCamReturn CamHwIsp20::pause()
3230 {
3231 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3232 BaseSensorHw* sensorHw = NULL;
3233
3234 if (mIspStatsStream.ptr())
3235 mIspStatsStream->stop();
3236 if (mIspSofStream.ptr())
3237 mIspSofStream->stop();
3238 if (mLumaStream.ptr())
3239 mLumaStream->stop();
3240 if (!mNoReadBack)
3241 hdr_mipi_stop();
3242
3243 sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
3244 sensorHw->stop();
3245 #ifndef DISABLE_PARAMS_POLL_THREAD
3246 if (mIspParamStream.ptr())
3247 mIspParamStream->stop();
3248 #else
3249 if (mIspParamsDev.ptr())
3250 mIspParamsDev->stop();
3251 #endif
3252 #if defined(ISP_HW_V20)
3253 if (mTnrStreamProcUnit.ptr())
3254 mTnrStreamProcUnit->start();
3255
3256 if (mNrStreamProcUnit.ptr())
3257 mNrStreamProcUnit->stop();
3258
3259 if (mFecParamStream.ptr())
3260 mFecParamStream->stop();
3261 #endif
3262 #ifndef DISABLE_PARAMS_ASSEMBLER
3263 if (mParamsAssembler.ptr())
3264 mParamsAssembler->stop();
3265 #endif
3266 if (mPdafStreamUnit.ptr())
3267 mPdafStreamUnit->stop();
3268
3269 {
3270 SmartLock locker (_isp_params_cfg_mutex);
3271 _camIsp3aResult.clear();
3272 _effecting_ispparam_map.clear();
3273 }
3274
3275 _state = CAM_HW_STATE_PAUSED;
3276 return ret;
3277 }
3278
swWorkingModeDyn(int mode)3279 XCamReturn CamHwIsp20::swWorkingModeDyn(int mode)
3280 {
3281 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3282 BaseSensorHw* sensorHw = NULL;
3283
3284 if (_linked_to_isp || mNoReadBack) {
3285 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "sensor linked to isp, not supported now!");
3286 return XCAM_RETURN_ERROR_FAILED;
3287 }
3288
3289 sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
3290
3291 ret = sensorHw->set_working_mode(mode);
3292 if (ret) {
3293 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "set sensor mode error !");
3294 return ret;
3295 }
3296
3297 setExpDelayInfo(mode);
3298
3299 Isp20Params::set_working_mode(mode);
3300
3301 #if 0 // for quick switch, not used now
3302 int old_mode = RK_AIQ_HDR_GET_WORKING_MODE(_hdr_mode);
3303 int new_mode = RK_AIQ_HDR_GET_WORKING_MODE(mode);
3304 //set hdr mode to drv
3305 if (mIspCoreDev.ptr()) {
3306 int drv_mode = ISP2X_HDR_MODE_NOMAL;
3307 if (new_mode == RK_AIQ_WORKING_MODE_ISP_HDR3)
3308 drv_mode = ISP2X_HDR_MODE_X3;
3309 else if (new_mode == RK_AIQ_WORKING_MODE_ISP_HDR2)
3310 drv_mode = ISP2X_HDR_MODE_X2;
3311
3312 if (mIspCoreDev->io_control (RKISP_CMD_SW_HDR_MODE_QUICK, &drv_mode) < 0) {
3313 ret = XCAM_RETURN_ERROR_FAILED;
3314 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set RKISP_CMD_SW_HDR_MODE_QUICK failed");
3315 return ret;
3316 }
3317 }
3318 // reconfig tx,rx stream
3319 if (!old_mode && new_mode) {
3320 // normal to hdr
3321 if (new_mode == RK_AIQ_WORKING_MODE_ISP_HDR3)
3322 hdr_mipi_start(MIPI_STREAM_IDX_1 | MIPI_STREAM_IDX_2);
3323 else
3324 hdr_mipi_start(MIPI_STREAM_IDX_1);
3325 } else if (old_mode && !new_mode) {
3326 // hdr to normal
3327 if (new_mode == RK_AIQ_WORKING_MODE_ISP_HDR3)
3328 hdr_mipi_stop(MIPI_STREAM_IDX_1 | MIPI_STREAM_IDX_2);
3329 else
3330 hdr_mipi_stop(MIPI_STREAM_IDX_1);
3331 } else if (old_mode == RK_AIQ_WORKING_MODE_ISP_HDR3 &&
3332 new_mode == RK_AIQ_WORKING_MODE_ISP_HDR2) {
3333 // hdr3 to hdr2
3334 hdr_mipi_stop(MIPI_STREAM_IDX_1);
3335 } else if (old_mode == RK_AIQ_WORKING_MODE_ISP_HDR2 &&
3336 new_mode == RK_AIQ_WORKING_MODE_ISP_HDR3) {
3337 // hdr3 to hdr2
3338 hdr_mipi_start(MIPI_STREAM_IDX_2);
3339 } else {
3340 // do nothing
3341 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "do nothing, old mode %d, new mode %d\n",
3342 _hdr_mode, mode);
3343 }
3344 #endif
3345 _hdr_mode = mode;
3346
3347 #ifndef USE_RAWSTREAM_LIB
3348 mRawCapUnit->set_working_mode(mode);
3349 mRawProcUnit->set_working_mode(mode);
3350 // remap _mipi_tx_devs for cif
3351 if (!_linked_to_isp && !mNoReadBack) {
3352 mRawCapUnit->prepare_cif_mipi();
3353 }
3354 #endif
3355
3356 return ret;
3357 }
3358
resume()3359 XCamReturn CamHwIsp20::resume()
3360 {
3361 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3362 BaseSensorHw* sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
3363
3364 #ifndef DISABLE_PARAMS_ASSEMBLER
3365 // set inital params
3366 ret = mParamsAssembler->start();
3367 if (ret < 0) {
3368 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "params assembler start err: %d\n", ret);
3369 }
3370
3371 if (mParamsAssembler->ready())
3372 setIspConfig();
3373 #endif
3374 ret = hdr_mipi_start_mode(_hdr_mode);
3375 if (ret < 0) {
3376 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
3377 }
3378 sensorHw->start();
3379 if (mIspSofStream.ptr())
3380 mIspSofStream->start();
3381 #ifndef DISABLE_PARAMS_POLL_THREAD
3382 if (mIspParamStream.ptr())
3383 mIspParamStream->startThreadOnly();
3384 #endif
3385 if (mLumaStream.ptr())
3386 mLumaStream->start();
3387 if (mIspStatsStream.ptr())
3388 mIspStatsStream->start();
3389
3390 #if defined(ISP_HW_V20)
3391 if (mTnrStreamProcUnit.ptr())
3392 mTnrStreamProcUnit->start();
3393
3394 if (mNrStreamProcUnit.ptr())
3395 mNrStreamProcUnit->start();
3396
3397 if (mFecParamStream.ptr())
3398 mFecParamStream->start();
3399 #endif
3400 if (mPdafStreamUnit.ptr())
3401 mPdafStreamUnit->start();
3402
3403 _state = CAM_HW_STATE_STARTED;
3404 return ret;
3405 }
3406
3407 #if defined(ISP_HW_V20)
3408 void
gen_full_ispp_params(const struct rkispp_params_cfg * update_params,struct rkispp_params_cfg * full_params)3409 CamHwIsp20::gen_full_ispp_params(const struct rkispp_params_cfg* update_params,
3410 struct rkispp_params_cfg* full_params)
3411 {
3412 XCAM_ASSERT (update_params);
3413 XCAM_ASSERT (full_params);
3414
3415 int end = RK_ISP2X_PP_MAX_ID - RK_ISP2X_PP_TNR_ID;
3416
3417 ENTER_CAMHW_FUNCTION();
3418 for (int i = 0; i < end; i++)
3419 if (update_params->module_en_update & (1 << i)) {
3420 full_params->module_en_update |= 1 << i;
3421 // clear old bit value
3422 full_params->module_ens &= ~(1 << i);
3423 // set new bit value
3424 full_params->module_ens |= update_params->module_ens & (1LL << i);
3425 }
3426
3427 for (int i = 0; i < end; i++)
3428 if (update_params->module_cfg_update & (1 << i)) {
3429 full_params->module_cfg_update |= 1 << i;
3430 }
3431
3432 EXIT_CAMHW_FUNCTION();
3433 }
3434 #endif
3435
3436 #if 0
3437 void CamHwIsp20::dump_isp_config(struct isp2x_isp_params_cfg* isp_params,
3438 SmartPtr<RkAiqIspParamsProxy> aiq_results,
3439 SmartPtr<RkAiqIspParamsProxy> aiq_other_results)
3440 {
3441 rk_aiq_isp_meas_params_v20_t* isp20_meas_result =
3442 static_cast<rk_aiq_isp_meas_params_v20_t*>(aiq_results->data().ptr());
3443 rk_aiq_isp_other_params_v20_t* isp20_other_result =
3444 static_cast<rk_aiq_isp_other_params_v20_t*>(aiq_other_results->data().ptr());
3445
3446 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp_params mask: 0x%llx-0x%llx-0x%llx\n",
3447 isp_params->module_en_update,
3448 isp_params->module_ens,
3449 isp_params->module_cfg_update);
3450
3451 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "aiq_results: ae-lite.winnum=%d; ae-big2.winnum=%d, sub[1].size: [%dx%d]\n",
3452 isp20_meas_result->aec_meas.rawae0.wnd_num,
3453 isp20_meas_result->aec_meas.rawae1.wnd_num,
3454 isp20_meas_result->aec_meas.rawae1.subwin[1].h_size,
3455 isp20_meas_result->aec_meas.rawae1.subwin[1].v_size);
3456
3457 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp_params: ae-lite.winnum=%d; ae-big2.winnum=%d, sub[1].size: [%dx%d]\n",
3458 isp_params->meas.rawae0.wnd_num,
3459 isp_params->meas.rawae1.wnd_num,
3460 isp_params->meas.rawae1.subwin[1].h_size,
3461 isp_params->meas.rawae1.subwin[1].v_size);
3462
3463 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp_params: win size: [%dx%d]-[%dx%d]-[%dx%d]-[%dx%d]\n",
3464 isp_params->meas.rawae0.win.h_size,
3465 isp_params->meas.rawae0.win.v_size,
3466 isp_params->meas.rawae3.win.h_size,
3467 isp_params->meas.rawae3.win.v_size,
3468 isp_params->meas.rawae1.win.h_size,
3469 isp_params->meas.rawae1.win.v_size,
3470 isp_params->meas.rawae2.win.h_size,
3471 isp_params->meas.rawae2.win.v_size);
3472
3473 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp_params: debayer:");
3474 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "clip_en:%d, dist_scale:%d, filter_c_en:%d, filter_g_en:%d",
3475 isp_params->others.debayer_cfg.clip_en,
3476 isp_params->others.debayer_cfg.dist_scale,
3477 isp_params->others.debayer_cfg.filter_c_en,
3478 isp_params->others.debayer_cfg.filter_g_en);
3479 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "gain_offset:%d,hf_offset:%d,max_ratio:%d,offset:%d,order_max:%d",
3480 isp_params->others.debayer_cfg.gain_offset,
3481 isp_params->others.debayer_cfg.hf_offset,
3482 isp_params->others.debayer_cfg.max_ratio,
3483 isp_params->others.debayer_cfg.offset,
3484 isp_params->others.debayer_cfg.order_max);
3485 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "order_min:%d, shift_num:%d, thed0:%d, thed1:%d",
3486 isp_params->others.debayer_cfg.order_min,
3487 isp_params->others.debayer_cfg.shift_num,
3488 isp_params->others.debayer_cfg.thed0,
3489 isp_params->others.debayer_cfg.thed1);
3490 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "filter1:[%d, %d, %d, %d, %d]",
3491 isp_params->others.debayer_cfg.filter1_coe1,
3492 isp_params->others.debayer_cfg.filter1_coe2,
3493 isp_params->others.debayer_cfg.filter1_coe3,
3494 isp_params->others.debayer_cfg.filter1_coe4,
3495 isp_params->others.debayer_cfg.filter1_coe5);
3496 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "filter2:[%d, %d, %d, %d, %d]",
3497 isp_params->others.debayer_cfg.filter2_coe1,
3498 isp_params->others.debayer_cfg.filter2_coe2,
3499 isp_params->others.debayer_cfg.filter2_coe3,
3500 isp_params->others.debayer_cfg.filter2_coe4,
3501 isp_params->others.debayer_cfg.filter2_coe5);
3502
3503 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp_params: gic: \n"
3504 "edge_open:%d, regmingradthrdark2:%d, regmingradthrdark1:%d, regminbusythre:%d\n"
3505 "regdarkthre:%d,regmaxcorvboth:%d,regdarktthrehi:%d,regkgrad2dark:%d,regkgrad1dark:%d\n"
3506 "regstrengthglobal_fix:%d, regdarkthrestep:%d, regkgrad2:%d, regkgrad1:%d\n"
3507 "reggbthre:%d, regmaxcorv:%d, regmingradthr2:%d, regmingradthr1:%d, gr_ratio:%d\n"
3508 "dnloscale:%d, dnhiscale:%d, reglumapointsstep:%d, gvaluelimitlo:%d, gvaluelimithi:%d\n"
3509 "fratiohilimt1:%d, strength_fix:%d, noise_cuten:%d, noise_coe_a:%d, noise_coe_b:%d, diff_clip:%d\n",
3510 isp_params->others.gic_cfg.edge_open,
3511 isp_params->others.gic_cfg.regmingradthrdark2,
3512 isp_params->others.gic_cfg.regmingradthrdark1,
3513 isp_params->others.gic_cfg.regminbusythre,
3514 isp_params->others.gic_cfg.regdarkthre,
3515 isp_params->others.gic_cfg.regmaxcorvboth,
3516 isp_params->others.gic_cfg.regdarktthrehi,
3517 isp_params->others.gic_cfg.regkgrad2dark,
3518 isp_params->others.gic_cfg.regkgrad1dark,
3519 isp_params->others.gic_cfg.regstrengthglobal_fix,
3520 isp_params->others.gic_cfg.regdarkthrestep,
3521 isp_params->others.gic_cfg.regkgrad2,
3522 isp_params->others.gic_cfg.regkgrad1,
3523 isp_params->others.gic_cfg.reggbthre,
3524 isp_params->others.gic_cfg.regmaxcorv,
3525 isp_params->others.gic_cfg.regmingradthr2,
3526 isp_params->others.gic_cfg.regmingradthr1,
3527 isp_params->others.gic_cfg.gr_ratio,
3528 isp_params->others.gic_cfg.dnloscale,
3529 isp_params->others.gic_cfg.dnhiscale,
3530 isp_params->others.gic_cfg.reglumapointsstep,
3531 isp_params->others.gic_cfg.gvaluelimitlo,
3532 isp_params->others.gic_cfg.gvaluelimithi,
3533 isp_params->others.gic_cfg.fusionratiohilimt1,
3534 isp_params->others.gic_cfg.regstrengthglobal_fix,
3535 isp_params->others.gic_cfg.noise_cut_en,
3536 isp_params->others.gic_cfg.noise_coe_a,
3537 isp_params->others.gic_cfg.noise_coe_b,
3538 isp_params->others.gic_cfg.diff_clip);
3539 for(int i = 0; i < ISP2X_GIC_SIGMA_Y_NUM; i++) {
3540 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "sigma_y[%d]=%d\n", i, isp_params->others.gic_cfg.sigma_y[i]);
3541 }
3542 #if 0 //TODO Merge
3543 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "aiq_results: gic: dnloscale=%f, dnhiscale=%f,gvaluelimitlo=%f,gvaluelimithi=%f,fusionratiohilimt1=%f"
3544 "textureStrength=%f,globalStrength=%f,noiseCurve_0=%f,noiseCurve_1=%f",
3545 isp20_other_result->gic.dnloscale, isp20_other_result->gic.dnhiscale,
3546 isp20_other_result->gic.gvaluelimitlo, isp20_other_result->gic.gvaluelimithi,
3547 isp20_other_result->gic.fusionratiohilimt1, isp20_other_result->gic.textureStrength,
3548 isp20_other_result->gic.globalStrength, isp20_other_result->gic.noiseCurve_0,
3549 isp20_other_result->gic.noiseCurve_1);
3550 for(int i = 0; i < ISP2X_GIC_SIGMA_Y_NUM; i++) {
3551 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "sigma[%d]=%f\n", i, isp20_other_result->gic.sigma_y[i]);
3552 }
3553 #endif
3554 }
3555 #endif
3556
3557 #if defined(ISP_HW_V20)
3558 XCamReturn
setIsppSharpFbcRot(struct rkispp_sharp_config * shp_cfg)3559 CamHwIsp20::setIsppSharpFbcRot(struct rkispp_sharp_config* shp_cfg)
3560 {
3561 // check if sharp enable
3562 // check if fec disable
3563 if ((_ispp_module_init_ens & ISPP_MODULE_SHP) &&
3564 !(_ispp_module_init_ens & ISPP_MODULE_FEC)) {
3565 switch (_sharp_fbc_rotation) {
3566 case RK_AIQ_ROTATION_0 :
3567 shp_cfg->rotation = 0;
3568 break;
3569 case RK_AIQ_ROTATION_90 :
3570 shp_cfg->rotation = 1;
3571 break;
3572 case RK_AIQ_ROTATION_270 :
3573 shp_cfg->rotation = 3;
3574 break;
3575 default:
3576 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "wrong rotation %d\n", _sharp_fbc_rotation);
3577 return XCAM_RETURN_ERROR_PARAM;
3578 }
3579 } else {
3580 if (_sharp_fbc_rotation != RK_AIQ_ROTATION_0) {
3581 shp_cfg->rotation = 0;
3582 _sharp_fbc_rotation = RK_AIQ_ROTATION_0;
3583 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't set sharp config, check fec & sharp config\n");
3584 return XCAM_RETURN_ERROR_PARAM;
3585 }
3586 }
3587
3588 LOGD("sharp rotation %d", _sharp_fbc_rotation);
3589
3590 return XCAM_RETURN_NO_ERROR;
3591 }
3592 #endif
3593
3594 XCamReturn
showOtpPdafData(struct rkmodule_pdaf_inf * otp_pdaf)3595 CamHwIsp20::showOtpPdafData(struct rkmodule_pdaf_inf *otp_pdaf)
3596 {
3597 unsigned int gainmap_w, gainmap_h;
3598 unsigned int dccmap_w, dccmap_h;
3599 char print_buf[256];
3600 unsigned int i, j;
3601
3602 if (otp_pdaf->flag) {
3603 gainmap_w = otp_pdaf->gainmap_width;
3604 gainmap_h = otp_pdaf->gainmap_height;
3605 dccmap_w = otp_pdaf->dccmap_width;
3606 dccmap_h = otp_pdaf->dccmap_height;
3607 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "[RKPDAFOTPParam]");
3608 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "flag=%d;", otp_pdaf->flag);
3609 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "gainmap_width=%d;", gainmap_w);
3610 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "gainmap_height=%d;", gainmap_h);
3611 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "gainmap_table=");
3612 for (i = 0; i < gainmap_h; i++) {
3613 memset(print_buf, 0, sizeof(print_buf));
3614 for (j = 0; j < gainmap_w; j++) {
3615 sprintf(print_buf + strlen(print_buf), "%d ", otp_pdaf->gainmap[i * gainmap_w + j]);
3616 }
3617 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "%s", print_buf);
3618 }
3619
3620 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dcc_mode=%d;", otp_pdaf->dcc_mode);
3621 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dcc_dir=%d;", otp_pdaf->dcc_dir);
3622 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dccmap_width=%d;", otp_pdaf->dccmap_width);
3623 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dccmap_height=%d;", otp_pdaf->dccmap_height);
3624 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dccmap_table=");
3625 for (i = 0; i < dccmap_h; i++) {
3626 memset(print_buf, 0, sizeof(print_buf));
3627 for (j = 0; j < dccmap_w; j++) {
3628 sprintf(print_buf + strlen(print_buf), "%d ", otp_pdaf->dccmap[i * dccmap_w + j]);
3629 }
3630 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "%s", print_buf);
3631 }
3632 }
3633
3634 return XCAM_RETURN_NO_ERROR;
3635 }
3636
3637 XCamReturn
showOtpAfData(struct rkmodule_af_inf * af_inf)3638 CamHwIsp20::showOtpAfData(struct rkmodule_af_inf *af_inf)
3639 {
3640 unsigned int i;
3641
3642 if (af_inf->flag) {
3643 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "[RKAFOTPParam]");
3644 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "flag=%d;", af_inf->flag);
3645 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dir_cnt=%d;", af_inf->dir_cnt);
3646
3647 for (i = 0; i < af_inf->dir_cnt; i++) {
3648 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "af_inf=%d;", af_inf->af_otp[i].vcm_dir);
3649 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "af_macro=%d;", af_inf->af_otp[i].vcm_start);
3650 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "af_macro=%d;", af_inf->af_otp[i].vcm_end);
3651 }
3652 }
3653
3654 return XCAM_RETURN_NO_ERROR;
3655 }
3656
3657 XCamReturn
getSensorModeData(const char * sns_ent_name,rk_aiq_exposure_sensor_descriptor & sns_des)3658 CamHwIsp20::getSensorModeData(const char* sns_ent_name,
3659 rk_aiq_exposure_sensor_descriptor& sns_des)
3660 {
3661 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3662 BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
3663 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
3664 struct v4l2_subdev_selection select;
3665
3666 ret = mSensorSubdev->getSensorModeData(sns_ent_name, sns_des);
3667 if (ret) {
3668 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "getSensorModeData failed \n");
3669 return ret;
3670 }
3671
3672 xcam_mem_clear (select);
3673 ret = mIspCoreDev->get_selection(0, V4L2_SEL_TGT_CROP, select);
3674 if (ret == XCAM_RETURN_NO_ERROR) {
3675 sns_des.isp_acq_width = select.r.width;
3676 sns_des.isp_acq_height = select.r.height;
3677 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "get isp acq,w: %d, h: %d\n",
3678 sns_des.isp_acq_width,
3679 sns_des.isp_acq_height);
3680 } else {
3681 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "get selecttion error \n");
3682 sns_des.isp_acq_width = sns_des.sensor_output_width;
3683 sns_des.isp_acq_height = sns_des.sensor_output_height;
3684 ret = XCAM_RETURN_NO_ERROR;
3685 }
3686
3687 if(userSensorWidth && userSensorHeight){
3688 sns_des.sensor_output_width = userSensorWidth;
3689 sns_des.sensor_output_height = userSensorHeight;
3690 sns_des.isp_acq_width = sns_des.sensor_output_width;
3691 sns_des.isp_acq_height = sns_des.sensor_output_height;
3692 }
3693
3694 xcam_mem_clear (sns_des.lens_des);
3695 if (mLensSubdev)
3696 mLensSubdev->getLensModeData(sns_des.lens_des);
3697
3698 auto iter_sns_info = mSensorHwInfos.find(sns_name);
3699 if (iter_sns_info == mSensorHwInfos.end()) {
3700 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_name);
3701 } else {
3702 struct rkmodule_inf *minfo = &(iter_sns_info->second->mod_info);
3703 if (minfo->awb.flag) {
3704 memcpy(&sns_des.otp_awb, &minfo->awb, sizeof(minfo->awb));
3705 } else {
3706 sns_des.otp_awb.flag = 0;
3707 }
3708
3709 if (minfo->lsc.flag)
3710 sns_des.otp_lsc = &minfo->lsc;
3711 else
3712 sns_des.otp_lsc = nullptr;
3713
3714 if (minfo->af.flag) {
3715 sns_des.otp_af = &minfo->af;
3716 showOtpAfData(sns_des.otp_af);
3717 } else {
3718 sns_des.otp_af = nullptr;
3719 }
3720
3721 if (minfo->pdaf.flag) {
3722 sns_des.otp_pdaf = &minfo->pdaf;
3723 showOtpPdafData(sns_des.otp_pdaf);
3724 } else {
3725 sns_des.otp_pdaf = nullptr;
3726 }
3727 }
3728
3729 return ret;
3730 }
3731
3732 XCamReturn
setExposureParams(SmartPtr<RkAiqExpParamsProxy> & expPar)3733 CamHwIsp20::setExposureParams(SmartPtr<RkAiqExpParamsProxy>& expPar)
3734 {
3735 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3736 ENTER_CAMHW_FUNCTION();
3737 BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
3738
3739 //exp
3740 ret = mSensorSubdev->setExposureParams(expPar);
3741 EXIT_CAMHW_FUNCTION();
3742 return ret;
3743 }
3744
3745 XCamReturn
setIrisParams(SmartPtr<RkAiqIrisParamsProxy> & irisPar,CalibDb_IrisTypeV2_t irisType)3746 CamHwIsp20::setIrisParams(SmartPtr<RkAiqIrisParamsProxy>& irisPar, CalibDb_IrisTypeV2_t irisType)
3747 {
3748 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3749 ENTER_CAMHW_FUNCTION();
3750 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
3751
3752 if(irisType == IRISV2_P_TYPE) {
3753 //P-iris
3754 int step = irisPar->data()->PIris.step;
3755 bool update = irisPar->data()->PIris.update;
3756
3757 if (mLensSubdev && update) {
3758 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||set P-Iris step: %d", step);
3759 if (mLensSubdev->setPIrisParams(step) < 0) {
3760 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set P-Iris step failed to device");
3761 return XCAM_RETURN_ERROR_IOCTL;
3762 }
3763 }
3764 } else if(irisType == IRISV2_DC_TYPE) {
3765 //DC-iris
3766 int PwmDuty = irisPar->data()->DCIris.pwmDuty;
3767 bool update = irisPar->data()->DCIris.update;
3768
3769 if (mLensSubdev && update) {
3770 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||set DC-Iris PwmDuty: %d", PwmDuty);
3771 if (mLensSubdev->setDCIrisParams(PwmDuty) < 0) {
3772 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set DC-Iris PwmDuty failed to device");
3773 return XCAM_RETURN_ERROR_IOCTL;
3774 }
3775 }
3776 } else if(irisType == IRISV2_HDC_TYPE) {
3777 //HDC-iris
3778 int target = irisPar->data()->HDCIris.target;
3779 bool update = irisPar->data()->HDCIris.update;
3780 if (mLensSubdev && update) {
3781 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||set HDC-Iris Target: %d", target);
3782 if (mLensSubdev->setHDCIrisParams(target) < 0) {
3783 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set HDC-Iris target failed to device");
3784 return XCAM_RETURN_ERROR_IOCTL;
3785 }
3786 }
3787 }
3788 EXIT_CAMHW_FUNCTION();
3789 return ret;
3790 }
3791
3792 XCamReturn
getIrisParams(SmartPtr<RkAiqIrisParamsProxy> & irisPar,CalibDb_IrisTypeV2_t irisType)3793 CamHwIsp20::getIrisParams(SmartPtr<RkAiqIrisParamsProxy>& irisPar, CalibDb_IrisTypeV2_t irisType)
3794 {
3795 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3796 ENTER_CAMHW_FUNCTION();
3797 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
3798
3799 if(irisType == IRISV2_HDC_TYPE) {
3800 //HDC-iris
3801 int adc = 0;
3802 int position = 0;
3803 if (mLensSubdev) {
3804 if (mLensSubdev->getHDCIrisParams(&adc) < 0) {
3805 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get HDC-Iris adc failed to device");
3806 return XCAM_RETURN_ERROR_IOCTL;
3807 }
3808 if (mLensSubdev->getZoomParams(&position) < 0) {
3809 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get zoom result failed to device");
3810 return XCAM_RETURN_ERROR_IOCTL;
3811 }
3812 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||get HDC-Iris ADC: %d get zoomPos: %d\n", adc, position);
3813 irisPar->data()->HDCIris.adc = adc;
3814 irisPar->data()->HDCIris.zoomPos = position;
3815 }
3816 }
3817 EXIT_CAMHW_FUNCTION();
3818 return ret;
3819 }
3820
3821 XCamReturn
setFocusParams(SmartPtr<RkAiqFocusParamsProxy> & focus_params)3822 CamHwIsp20::setFocusParams(SmartPtr<RkAiqFocusParamsProxy>& focus_params)
3823 {
3824 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3825 ENTER_CAMHW_FUNCTION();
3826 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
3827 rk_aiq_focus_params_t* p_focus = &focus_params->data()->result;
3828 bool focus_valid = p_focus->lens_pos_valid;
3829 bool zoom_valid = p_focus->zoom_pos_valid;
3830 bool focus_correction = p_focus->focus_correction;
3831 bool zoom_correction = p_focus->zoom_correction;
3832 bool zoomfocus_modifypos = p_focus->zoomfocus_modifypos;
3833 bool end_zoom_chg = p_focus->end_zoom_chg;
3834 bool vcm_config_valid = p_focus->vcm_config_valid;
3835
3836 if (!mLensSubdev)
3837 goto OUT;
3838
3839 if (zoomfocus_modifypos)
3840 mLensSubdev->ZoomFocusModifyPosition(focus_params);
3841 if (focus_correction)
3842 mLensSubdev->FocusCorrection();
3843 if (zoom_correction)
3844 mLensSubdev->ZoomCorrection();
3845
3846 if (focus_valid && !zoom_valid) {
3847 if (mLensSubdev->setFocusParams(focus_params) < 0) {
3848 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set focus result failed to device");
3849 return XCAM_RETURN_ERROR_IOCTL;
3850 }
3851 } else if ((focus_valid && zoom_valid) || end_zoom_chg) {
3852 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||setZoomFocusParams");
3853 if (mLensSubdev->setZoomFocusParams(focus_params) < 0) {
3854 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set setZoomFocusParams failed to device");
3855 return XCAM_RETURN_ERROR_IOCTL;
3856 }
3857 }
3858
3859 rk_aiq_lens_vcmcfg lens_cfg;
3860 if (mLensSubdev && vcm_config_valid) {
3861 mLensSubdev->getLensVcmCfg(lens_cfg);
3862 lens_cfg.start_ma = p_focus->vcm_start_ma;
3863 lens_cfg.rated_ma = p_focus->vcm_end_ma;
3864 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||set vcm config: %d, %d", lens_cfg.start_ma, lens_cfg.rated_ma);
3865 if (mLensSubdev->setLensVcmCfg(lens_cfg) < 0) {
3866 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set vcm config failed to device");
3867 return XCAM_RETURN_ERROR_IOCTL;
3868 }
3869 }
3870
3871 OUT:
3872 EXIT_CAMHW_FUNCTION();
3873 return ret;
3874 }
3875
3876 XCamReturn
getZoomPosition(int & position)3877 CamHwIsp20::getZoomPosition(int& position)
3878 {
3879 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3880 ENTER_CAMHW_FUNCTION();
3881 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
3882
3883 if (mLensSubdev) {
3884 if (mLensSubdev->getZoomParams(&position) < 0) {
3885 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get zoom result failed to device");
3886 return XCAM_RETURN_ERROR_IOCTL;
3887 }
3888 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||get zoom result: %d", position);
3889 }
3890
3891 EXIT_CAMHW_FUNCTION();
3892 return ret;
3893 }
3894
3895 XCamReturn
setLensVcmCfg(rk_aiq_lens_vcmcfg & lens_cfg)3896 CamHwIsp20::setLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg)
3897 {
3898 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3899 ENTER_CAMHW_FUNCTION();
3900 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
3901
3902 if (mLensSubdev) {
3903 if (mLensSubdev->setLensVcmCfg(lens_cfg) < 0) {
3904 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set vcm config failed");
3905 return XCAM_RETURN_ERROR_IOCTL;
3906 }
3907 }
3908
3909 EXIT_CAMHW_FUNCTION();
3910 return ret;
3911 }
3912
3913 XCamReturn
FocusCorrection()3914 CamHwIsp20::FocusCorrection()
3915 {
3916 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3917 ENTER_CAMHW_FUNCTION();
3918 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
3919
3920 if (mLensSubdev) {
3921 if (mLensSubdev->FocusCorrection() < 0) {
3922 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "focus correction failed");
3923 return XCAM_RETURN_ERROR_IOCTL;
3924 }
3925 }
3926
3927 EXIT_CAMHW_FUNCTION();
3928 return ret;
3929 }
3930
3931 XCamReturn
ZoomCorrection()3932 CamHwIsp20::ZoomCorrection()
3933 {
3934 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3935 ENTER_CAMHW_FUNCTION();
3936 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
3937
3938 if (mLensSubdev) {
3939 if (mLensSubdev->ZoomCorrection() < 0) {
3940 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "zoom correction failed");
3941 return XCAM_RETURN_ERROR_IOCTL;
3942 }
3943 }
3944
3945 EXIT_CAMHW_FUNCTION();
3946 return ret;
3947 }
3948
3949 XCamReturn
getLensVcmCfg(rk_aiq_lens_vcmcfg & lens_cfg)3950 CamHwIsp20::getLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg)
3951 {
3952 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3953 ENTER_CAMHW_FUNCTION();
3954 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
3955
3956 if (mLensSubdev) {
3957 if (mLensSubdev->getLensVcmCfg(lens_cfg) < 0) {
3958 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get vcm config failed");
3959 return XCAM_RETURN_ERROR_IOCTL;
3960 }
3961 }
3962
3963 EXIT_CAMHW_FUNCTION();
3964 return ret;
3965 }
3966
3967 XCamReturn
setAngleZ(float angleZ)3968 CamHwIsp20::setAngleZ(float angleZ)
3969 {
3970 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3971 ENTER_CAMHW_FUNCTION();
3972 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
3973
3974 if (mLensSubdev) {
3975 if (mLensSubdev->setAngleZ(angleZ) < 0) {
3976 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setAngleZ failed");
3977 return XCAM_RETURN_ERROR_IOCTL;
3978 }
3979 }
3980
3981 EXIT_CAMHW_FUNCTION();
3982 return ret;
3983 }
3984
3985 XCamReturn
setCpslParams(SmartPtr<RkAiqCpslParamsProxy> & cpsl_params)3986 CamHwIsp20::setCpslParams(SmartPtr<RkAiqCpslParamsProxy>& cpsl_params)
3987 {
3988 ENTER_CAMHW_FUNCTION();
3989
3990 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3991
3992 RKAiqCpslInfoWrapper_t* cpsl_setting = cpsl_params->data().ptr();
3993
3994 if (cpsl_setting->update_fl) {
3995 rk_aiq_flash_setting_t* fl_setting = &cpsl_setting->fl;
3996 if (mFlashLight.ptr()) {
3997 ret = mFlashLight->set_params(*fl_setting);
3998 if (ret < 0) {
3999 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set flashlight params err: %d\n", ret);
4000 }
4001 }
4002 }
4003
4004 if (cpsl_setting->update_ir) {
4005 rk_aiq_ir_setting_t* ir_setting = &cpsl_setting->ir;
4006 ret = setIrcutParams(ir_setting->irc_on);
4007 if (ret < 0) {
4008 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set ir params err: %d\n", ret);
4009 }
4010
4011 rk_aiq_flash_setting_t* fl_ir_setting = &cpsl_setting->fl_ir;
4012
4013 if (mFlashLightIr.ptr()) {
4014 ret = mFlashLightIr->set_params(*fl_ir_setting);
4015 if (ret < 0) {
4016 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set flashlight ir params err: %d\n", ret);
4017 }
4018 }
4019 }
4020
4021 EXIT_CAMHW_FUNCTION();
4022 return ret;
4023 }
4024
4025 XCamReturn
setHdrProcessCount(rk_aiq_luma_params_t luma_params)4026 CamHwIsp20::setHdrProcessCount(rk_aiq_luma_params_t luma_params)
4027 {
4028 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4029
4030 ENTER_CAMHW_FUNCTION();
4031 #ifndef USE_RAWSTREAM_LIB
4032 mRawProcUnit->set_hdr_frame_readback_infos(luma_params.frame_id, luma_params.hdrProcessCnt);
4033 #endif
4034 EXIT_CAMHW_FUNCTION();
4035 return ret;
4036 }
4037
4038 XCamReturn
getEffectiveIspParams(rkisp_effect_params_v20 & ispParams,uint32_t frame_id)4039 CamHwIsp20::getEffectiveIspParams(rkisp_effect_params_v20& ispParams, uint32_t frame_id)
4040 {
4041 ENTER_CAMHW_FUNCTION();
4042 std::map<uint32_t, SmartPtr<RkAiqIspEffParamsProxy>>::iterator it;
4043 uint32_t search_id = frame_id == uint32_t(-1) ? 0 : frame_id;
4044 SmartLock locker (_isp_params_cfg_mutex);
4045
4046 if (_effecting_ispparam_map.size() == 0) {
4047 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "camId: %d, can't search id %d, _effecting_exp_mapsize is %d\n",
4048 mCamPhyId, frame_id, _effecting_ispparam_map.size());
4049 return XCAM_RETURN_ERROR_PARAM;
4050 }
4051
4052 it = _effecting_ispparam_map.find(search_id);
4053
4054 // havn't found
4055 if (it == _effecting_ispparam_map.end()) {
4056 std::map<uint32_t, SmartPtr<RkAiqIspEffParamsProxy>>::reverse_iterator rit;
4057
4058 rit = _effecting_ispparam_map.rbegin();
4059 do {
4060 LOGV_CAMHW_SUBM(ISP20HW_SUBM, "camId: %d, traverse _effecting_ispparam_map to find id %d, current id is [%d]\n",
4061 mCamPhyId, search_id, rit->first);
4062 if (search_id >= rit->first ) {
4063 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "camId: %d, can't find id %d, get latest id %d in _effecting_ispparam_map\n",
4064 mCamPhyId, search_id, rit->first);
4065 break;
4066 }
4067 } while (++rit != _effecting_ispparam_map.rend());
4068
4069 if (rit == _effecting_ispparam_map.rend()) {
4070 if (_effecting_ispparam_map.size() > 0) {
4071 ispParams = _effecting_ispparam_map.rbegin()->second->data()->result;
4072 return XCAM_RETURN_NO_ERROR;
4073 }
4074 LOGE_CAMHW_SUBM(ISP20HW_SUBM,
4075 "camId: %d, can't find the latest effecting ispparams for id %d, impossible case !",
4076 mCamPhyId, frame_id);
4077 return XCAM_RETURN_ERROR_PARAM;
4078 }
4079 ispParams = rit->second->data()->result;
4080 } else {
4081 ispParams = it->second->data()->result;
4082 }
4083
4084 EXIT_CAMHW_FUNCTION();
4085
4086 return XCAM_RETURN_NO_ERROR;
4087 }
4088
4089 #if 0
4090 void CamHwIsp20::dumpRawnrFixValue(struct isp2x_rawnr_cfg * pRawnrCfg )
4091 {
4092 printf("%s:(%d) enter \n", __FUNCTION__, __LINE__);
4093 int i = 0;
4094
4095 //(0x0004)
4096 printf("(0x0004) gauss_en:%d log_bypass:%d \n",
4097 pRawnrCfg->gauss_en,
4098 pRawnrCfg->log_bypass);
4099
4100 //(0x0008 - 0x0010)
4101 printf("(0x0008 - 0x0010) filtpar0-2:%d %d %d \n",
4102 pRawnrCfg->filtpar0,
4103 pRawnrCfg->filtpar1,
4104 pRawnrCfg->filtpar2);
4105
4106 //(0x0014 - 0x001c)
4107 printf("(0x0014 - 0x001c) dgain0-2:%d %d %d \n",
4108 pRawnrCfg->dgain0,
4109 pRawnrCfg->dgain1,
4110 pRawnrCfg->dgain2);
4111
4112 //(0x0020 - 0x002c)
4113 for(int i = 0; i < ISP2X_RAWNR_LUMA_RATION_NUM; i++) {
4114 printf("(0x0020 - 0x002c) luration[%d]:%d \n",
4115 i, pRawnrCfg->luration[i]);
4116 }
4117
4118 //(0x0030 - 0x003c)
4119 for(int i = 0; i < ISP2X_RAWNR_LUMA_RATION_NUM; i++) {
4120 printf("(0x0030 - 0x003c) lulevel[%d]:%d \n",
4121 i, pRawnrCfg->lulevel[i]);
4122 }
4123
4124 //(0x0040)
4125 printf("(0x0040) gauss:%d \n",
4126 pRawnrCfg->gauss);
4127
4128 //(0x0044)
4129 printf("(0x0044) sigma:%d \n",
4130 pRawnrCfg->sigma);
4131
4132 //(0x0048)
4133 printf("(0x0048) pix_diff:%d \n",
4134 pRawnrCfg->pix_diff);
4135
4136 //(0x004c)
4137 printf("(0x004c) thld_diff:%d \n",
4138 pRawnrCfg->thld_diff);
4139
4140 //(0x0050)
4141 printf("(0x0050) gas_weig_scl1:%d gas_weig_scl2:%d thld_chanelw:%d \n",
4142 pRawnrCfg->gas_weig_scl1,
4143 pRawnrCfg->gas_weig_scl2,
4144 pRawnrCfg->thld_chanelw);
4145
4146 //(0x0054)
4147 printf("(0x0054) lamda:%d \n",
4148 pRawnrCfg->lamda);
4149
4150 //(0x0058 - 0x005c)
4151 printf("(0x0058 - 0x005c) fixw0-3:%d %d %d %d\n",
4152 pRawnrCfg->fixw0,
4153 pRawnrCfg->fixw1,
4154 pRawnrCfg->fixw2,
4155 pRawnrCfg->fixw3);
4156
4157 //(0x0060 - 0x0068)
4158 printf("(0x0060 - 0x0068) wlamda0-2:%d %d %d\n",
4159 pRawnrCfg->wlamda0,
4160 pRawnrCfg->wlamda1,
4161 pRawnrCfg->wlamda2);
4162
4163
4164 //(0x006c)
4165 printf("(0x006c) rgain_filp-2:%d bgain_filp:%d\n",
4166 pRawnrCfg->rgain_filp,
4167 pRawnrCfg->bgain_filp);
4168
4169
4170 printf("%s:(%d) exit \n", __FUNCTION__, __LINE__);
4171 }
4172
4173
4174
4175 void CamHwIsp20::dumpTnrFixValue(struct rkispp_tnr_config * pTnrCfg)
4176 {
4177 int i = 0;
4178 printf("%s:(%d) enter \n", __FUNCTION__, __LINE__);
4179 //0x0080
4180 printf("(0x0080) opty_en:%d optc_en:%d gain_en:%d\n",
4181 pTnrCfg->opty_en,
4182 pTnrCfg->optc_en,
4183 pTnrCfg->gain_en);
4184
4185 //0x0088
4186 printf("(0x0088) pk0_y:%d pk1_y:%d pk0_c:%d pk1_c:%d \n",
4187 pTnrCfg->pk0_y,
4188 pTnrCfg->pk1_y,
4189 pTnrCfg->pk0_c,
4190 pTnrCfg->pk1_c);
4191
4192 //0x008c
4193 printf("(0x008c) glb_gain_cur:%d glb_gain_nxt:%d \n",
4194 pTnrCfg->glb_gain_cur,
4195 pTnrCfg->glb_gain_nxt);
4196
4197 //0x0090
4198 printf("(0x0090) glb_gain_cur_div:%d gain_glb_filt_sqrt:%d \n",
4199 pTnrCfg->glb_gain_cur_div,
4200 pTnrCfg->glb_gain_cur_sqrt);
4201
4202 //0x0094 - 0x0098
4203 for(i = 0; i < TNR_SIGMA_CURVE_SIZE - 1; i++) {
4204 printf("(0x0094 - 0x0098) sigma_x[%d]:%d \n",
4205 i, pTnrCfg->sigma_x[i]);
4206 }
4207
4208 //0x009c - 0x00bc
4209 for(i = 0; i < TNR_SIGMA_CURVE_SIZE; i++) {
4210 printf("(0x009c - 0x00bc) sigma_y[%d]:%d \n",
4211 i, pTnrCfg->sigma_y[i]);
4212 }
4213
4214 //0x00c4 - 0x00cc
4215 //dir_idx = 0;
4216 for(i = 0; i < TNR_LUMA_CURVE_SIZE; i++) {
4217 printf("(0x00c4 - 0x00cc) luma_curve[%d]:%d \n",
4218 i, pTnrCfg->luma_curve[i]);
4219 }
4220
4221 //0x00d0
4222 printf("(0x00d0) txt_th0_y:%d txt_th1_y:%d \n",
4223 pTnrCfg->txt_th0_y,
4224 pTnrCfg->txt_th1_y);
4225
4226 //0x00d4
4227 printf("(0x00d0) txt_th0_c:%d txt_th1_c:%d \n",
4228 pTnrCfg->txt_th0_c,
4229 pTnrCfg->txt_th1_c);
4230
4231 //0x00d8
4232 printf("(0x00d8) txt_thy_dlt:%d txt_thc_dlt:%d \n",
4233 pTnrCfg->txt_thy_dlt,
4234 pTnrCfg->txt_thc_dlt);
4235
4236 //0x00dc - 0x00ec
4237 for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
4238 printf("(0x00dc - 0x00ec) gfcoef_y0[%d]:%d \n",
4239 i, pTnrCfg->gfcoef_y0[i]);
4240 }
4241 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4242 printf("(0x00dc - 0x00ec) gfcoef_y1[%d]:%d \n",
4243 i, pTnrCfg->gfcoef_y1[i]);
4244 }
4245 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4246 printf("(0x00dc - 0x00ec) gfcoef_y2[%d]:%d \n",
4247 i, pTnrCfg->gfcoef_y2[i]);
4248 }
4249 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4250 printf("(0x00dc - 0x00ec) gfcoef_y3[%d]:%d \n",
4251 i, pTnrCfg->gfcoef_y3[i]);
4252 }
4253
4254 //0x00f0 - 0x0100
4255 for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
4256 printf("(0x00f0 - 0x0100) gfcoef_yg0[%d]:%d \n",
4257 i, pTnrCfg->gfcoef_yg0[i]);
4258 }
4259 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4260 printf("(0x00f0 - 0x0100) gfcoef_yg1[%d]:%d \n",
4261 i, pTnrCfg->gfcoef_yg1[i]);
4262 }
4263 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4264 printf("(0x00f0 - 0x0100) gfcoef_yg2[%d]:%d \n",
4265 i, pTnrCfg->gfcoef_yg2[i]);
4266 }
4267 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4268 printf("(0x00f0 - 0x0100) gfcoef_yg3[%d]:%d \n",
4269 i, pTnrCfg->gfcoef_yg3[i]);
4270 }
4271
4272
4273 //0x0104 - 0x0110
4274 for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
4275 printf("(0x0104 - 0x0110) gfcoef_yl0[%d]:%d \n",
4276 i, pTnrCfg->gfcoef_yl0[i]);
4277 }
4278 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4279 printf("(0x0104 - 0x0110) gfcoef_yl1[%d]:%d \n",
4280 i, pTnrCfg->gfcoef_yl1[i]);
4281 }
4282 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4283 printf("(0x0104 - 0x0110) gfcoef_yl2[%d]:%d \n",
4284 i, pTnrCfg->gfcoef_yl2[i]);
4285 }
4286
4287 //0x0114 - 0x0120
4288 for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
4289 printf("(0x0114 - 0x0120) gfcoef_cg0[%d]:%d \n",
4290 i, pTnrCfg->gfcoef_cg0[i]);
4291 }
4292 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4293 printf("(0x0114 - 0x0120) gfcoef_cg1[%d]:%d \n",
4294 i, pTnrCfg->gfcoef_cg1[i]);
4295 }
4296 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4297 printf("(0x0114 - 0x0120) gfcoef_cg2[%d]:%d \n",
4298 i, pTnrCfg->gfcoef_cg2[i]);
4299 }
4300
4301
4302 //0x0124 - 0x012c
4303 for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
4304 printf("(0x0124 - 0x012c) gfcoef_cl0[%d]:%d \n",
4305 i, pTnrCfg->gfcoef_cl0[i]);
4306 }
4307 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
4308 printf("(0x0124 - 0x012c) gfcoef_cl1[%d]:%d \n",
4309 i, pTnrCfg->gfcoef_cl1[i]);
4310 }
4311
4312
4313 //0x0130 - 0x0134
4314 //dir_idx = 0; i = lvl;
4315 for(i = 0; i < TNR_SCALE_YG_SIZE; i++) {
4316 printf("(0x0130 - 0x0134) scale_yg[%d]:%d \n",
4317 i, pTnrCfg->scale_yg[i]);
4318 }
4319
4320 //0x0138 - 0x013c
4321 //dir_idx = 1; i = lvl;
4322 for(i = 0; i < TNR_SCALE_YL_SIZE; i++) {
4323 printf("(0x0138 - 0x013c) scale_yl[%d]:%d \n",
4324 i, pTnrCfg->scale_yl[i]);
4325 }
4326
4327 //0x0140 - 0x0148
4328 //dir_idx = 0; i = lvl;
4329 for(i = 0; i < TNR_SCALE_CG_SIZE; i++) {
4330 printf("(0x0140 - 0x0148) scale_cg[%d]:%d \n",
4331 i, pTnrCfg->scale_cg[i]);
4332 printf("(0x0140 - 0x0148) scale_y2cg[%d]:%d \n",
4333 i, pTnrCfg->scale_y2cg[i]);
4334 }
4335
4336 //0x014c - 0x0154
4337 //dir_idx = 1; i = lvl;
4338 for(i = 0; i < TNR_SCALE_CL_SIZE; i++) {
4339 printf("(0x014c - 0x0154) scale_cl[%d]:%d \n",
4340 i, pTnrCfg->scale_cl[i]);
4341 }
4342 for(i = 0; i < TNR_SCALE_Y2CL_SIZE; i++) {
4343 printf("(0x014c - 0x0154) scale_y2cl[%d]:%d \n",
4344 i, pTnrCfg->scale_y2cl[i]);
4345 }
4346
4347 //0x0158
4348 for(i = 0; i < TNR_WEIGHT_Y_SIZE; i++) {
4349 printf("(0x0158) weight_y[%d]:%d \n",
4350 i, pTnrCfg->weight_y[i]);
4351 }
4352
4353 printf("%s:(%d) exit \n", __FUNCTION__, __LINE__);
4354 }
4355
4356
4357 void CamHwIsp20::dumpUvnrFixValue(struct rkispp_nr_config * pNrCfg)
4358 {
4359 int i = 0;
4360 printf("%s:(%d) exit \n", __FUNCTION__, __LINE__);
4361 //0x0080
4362 printf("(0x0088) uvnr_step1_en:%d uvnr_step2_en:%d nr_gain_en:%d uvnr_nobig_en:%d uvnr_big_en:%d\n",
4363 pNrCfg->uvnr_step1_en,
4364 pNrCfg->uvnr_step2_en,
4365 pNrCfg->nr_gain_en,
4366 pNrCfg->uvnr_nobig_en,
4367 pNrCfg->uvnr_big_en);
4368
4369 //0x0084
4370 printf("(0x0084) uvnr_gain_1sigma:%d \n",
4371 pNrCfg->uvnr_gain_1sigma);
4372
4373 //0x0088
4374 printf("(0x0088) uvnr_gain_offset:%d \n",
4375 pNrCfg->uvnr_gain_offset);
4376
4377 //0x008c
4378 printf("(0x008c) uvnr_gain_uvgain:%d uvnr_step2_en:%d uvnr_gain_t2gen:%d uvnr_gain_iso:%d\n",
4379 pNrCfg->uvnr_gain_uvgain[0],
4380 pNrCfg->uvnr_gain_uvgain[1],
4381 pNrCfg->uvnr_gain_t2gen,
4382 pNrCfg->uvnr_gain_iso);
4383
4384
4385 //0x0090
4386 printf("(0x0090) uvnr_t1gen_m3alpha:%d \n",
4387 pNrCfg->uvnr_t1gen_m3alpha);
4388
4389 //0x0094
4390 printf("(0x0094) uvnr_t1flt_mode:%d \n",
4391 pNrCfg->uvnr_t1flt_mode);
4392
4393 //0x0098
4394 printf("(0x0098) uvnr_t1flt_msigma:%d \n",
4395 pNrCfg->uvnr_t1flt_msigma);
4396
4397 //0x009c
4398 printf("(0x009c) uvnr_t1flt_wtp:%d \n",
4399 pNrCfg->uvnr_t1flt_wtp);
4400
4401 //0x00a0-0x00a4
4402 for(i = 0; i < NR_UVNR_T1FLT_WTQ_SIZE; i++) {
4403 printf("(0x00a0-0x00a4) uvnr_t1flt_wtq[%d]:%d \n",
4404 i, pNrCfg->uvnr_t1flt_wtq[i]);
4405 }
4406
4407 //0x00a8
4408 printf("(0x00a8) uvnr_t2gen_m3alpha:%d \n",
4409 pNrCfg->uvnr_t2gen_m3alpha);
4410
4411 //0x00ac
4412 printf("(0x00ac) uvnr_t2gen_msigma:%d \n",
4413 pNrCfg->uvnr_t2gen_msigma);
4414
4415 //0x00b0
4416 printf("(0x00b0) uvnr_t2gen_wtp:%d \n",
4417 pNrCfg->uvnr_t2gen_wtp);
4418
4419 //0x00b4
4420 for(i = 0; i < NR_UVNR_T2GEN_WTQ_SIZE; i++) {
4421 printf("(0x00b4) uvnr_t2gen_wtq[%d]:%d \n",
4422 i, pNrCfg->uvnr_t2gen_wtq[i]);
4423 }
4424
4425 //0x00b8
4426 printf("(0x00b8) uvnr_t2flt_msigma:%d \n",
4427 pNrCfg->uvnr_t2flt_msigma);
4428
4429 //0x00bc
4430 printf("(0x00bc) uvnr_t2flt_wtp:%d \n",
4431 pNrCfg->uvnr_t2flt_wtp);
4432 for(i = 0; i < NR_UVNR_T2FLT_WT_SIZE; i++) {
4433 printf("(0x00bc) uvnr_t2flt_wt[%d]:%d \n",
4434 i, pNrCfg->uvnr_t2flt_wt[i]);
4435 }
4436
4437
4438 printf("%s:(%d) entor \n", __FUNCTION__, __LINE__);
4439 }
4440
4441
4442 void CamHwIsp20::dumpYnrFixValue(struct rkispp_nr_config * pNrCfg)
4443 {
4444 printf("%s:(%d) enter \n", __FUNCTION__, __LINE__);
4445
4446 int i = 0;
4447
4448 //0x0104 - 0x0108
4449 for(i = 0; i < NR_YNR_SGM_DX_SIZE; i++) {
4450 printf("(0x0104 - 0x0108) ynr_sgm_dx[%d]:%d \n",
4451 i, pNrCfg->ynr_sgm_dx[i]);
4452 }
4453
4454 //0x010c - 0x012c
4455 for(i = 0; i < NR_YNR_SGM_Y_SIZE; i++) {
4456 printf("(0x010c - 0x012c) ynr_lsgm_y[%d]:%d \n",
4457 i, pNrCfg->ynr_lsgm_y[i]);
4458 }
4459
4460 //0x0130
4461 for(i = 0; i < NR_YNR_CI_SIZE; i++) {
4462 printf("(0x0130) ynr_lci[%d]:%d \n",
4463 i, pNrCfg->ynr_lci[i]);
4464 }
4465
4466 //0x0134
4467 for(i = 0; i < NR_YNR_LGAIN_MIN_SIZE; i++) {
4468 printf("(0x0134) ynr_lgain_min[%d]:%d \n",
4469 i, pNrCfg->ynr_lgain_min[i]);
4470 }
4471
4472 //0x0138
4473 printf("(0x0138) ynr_lgain_max:%d \n",
4474 pNrCfg->ynr_lgain_max);
4475
4476
4477 //0x013c
4478 printf("(0x013c) ynr_lmerge_bound:%d ynr_lmerge_ratio:%d\n",
4479 pNrCfg->ynr_lmerge_bound,
4480 pNrCfg->ynr_lmerge_ratio);
4481
4482 //0x0140
4483 for(i = 0; i < NR_YNR_LWEIT_FLT_SIZE; i++) {
4484 printf("(0x0140) ynr_lweit_flt[%d]:%d \n",
4485 i, pNrCfg->ynr_lweit_flt[i]);
4486 }
4487
4488 //0x0144 - 0x0164
4489 for(i = 0; i < NR_YNR_SGM_Y_SIZE; i++) {
4490 printf("(0x0144 - 0x0164) ynr_hsgm_y[%d]:%d \n",
4491 i, pNrCfg->ynr_hsgm_y[i]);
4492 }
4493
4494 //0x0168
4495 for(i = 0; i < NR_YNR_CI_SIZE; i++) {
4496 printf("(0x0168) ynr_hlci[%d]:%d \n",
4497 i, pNrCfg->ynr_hlci[i]);
4498 }
4499
4500 //0x016c
4501 for(i = 0; i < NR_YNR_CI_SIZE; i++) {
4502 printf("(0x016c) ynr_lhci[%d]:%d \n",
4503 i, pNrCfg->ynr_lhci[i]);
4504 }
4505
4506 //0x0170
4507 for(i = 0; i < NR_YNR_CI_SIZE; i++) {
4508 printf("(0x0170) ynr_hhci[%d]:%d \n",
4509 i, pNrCfg->ynr_hhci[i]);
4510 }
4511
4512 //0x0174
4513 for(i = 0; i < NR_YNR_HGAIN_SGM_SIZE; i++) {
4514 printf("(0x0174) ynr_hgain_sgm[%d]:%d \n",
4515 i, pNrCfg->ynr_hgain_sgm[i]);
4516 }
4517
4518 //0x0178 - 0x0188
4519 for(i = 0; i < 5; i++) {
4520 printf("(0x0178 - 0x0188) ynr_hweit_d[%d - %d]:%d %d %d %d \n",
4521 i * 4 + 0, i * 4 + 3,
4522 pNrCfg->ynr_hweit_d[i * 4 + 0],
4523 pNrCfg->ynr_hweit_d[i * 4 + 1],
4524 pNrCfg->ynr_hweit_d[i * 4 + 2],
4525 pNrCfg->ynr_hweit_d[i * 4 + 3]);
4526 }
4527
4528
4529 //0x018c - 0x01a0
4530 for(i = 0; i < 6; i++) {
4531 printf("(0x018c - 0x01a0) ynr_hgrad_y[%d - %d]:%d %d %d %d \n",
4532 i * 4 + 0, i * 4 + 3,
4533 pNrCfg->ynr_hgrad_y[i * 4 + 0],
4534 pNrCfg->ynr_hgrad_y[i * 4 + 1],
4535 pNrCfg->ynr_hgrad_y[i * 4 + 2],
4536 pNrCfg->ynr_hgrad_y[i * 4 + 3]);
4537 }
4538
4539 //0x01a4 -0x01a8
4540 for(i = 0; i < NR_YNR_HWEIT_SIZE; i++) {
4541 printf("(0x01a4 -0x01a8) ynr_hweit[%d]:%d \n",
4542 i, pNrCfg->ynr_hweit[i]);
4543 }
4544
4545 //0x01b0
4546 printf("(0x01b0) ynr_hmax_adjust:%d \n",
4547 pNrCfg->ynr_hmax_adjust);
4548
4549 //0x01b4
4550 printf("(0x01b4) ynr_hstrength:%d \n",
4551 pNrCfg->ynr_hstrength);
4552
4553 //0x01b8
4554 printf("(0x01b8) ynr_lweit_cmp0-1:%d %d\n",
4555 pNrCfg->ynr_lweit_cmp[0],
4556 pNrCfg->ynr_lweit_cmp[1]);
4557
4558 //0x01bc
4559 printf("(0x01bc) ynr_lmaxgain_lv4:%d \n",
4560 pNrCfg->ynr_lmaxgain_lv4);
4561
4562 //0x01c0 - 0x01e0
4563 for(i = 0; i < NR_YNR_HSTV_Y_SIZE; i++) {
4564 printf("(0x01c0 - 0x01e0 ) ynr_hstv_y[%d]:%d \n",
4565 i, pNrCfg->ynr_hstv_y[i]);
4566 }
4567
4568 //0x01e4 - 0x01e8
4569 for(i = 0; i < NR_YNR_ST_SCALE_SIZE; i++) {
4570 printf("(0x01e4 - 0x01e8 ) ynr_st_scale[%d]:%d \n",
4571 i, pNrCfg->ynr_st_scale[i]);
4572 }
4573
4574 printf("%s:(%d) exit \n", __FUNCTION__, __LINE__);
4575
4576 }
4577
4578
4579 void CamHwIsp20::dumpSharpFixValue(struct rkispp_sharp_config * pSharpCfg)
4580 {
4581 printf("%s:(%d) enter \n", __FUNCTION__, __LINE__);
4582 int i = 0;
4583
4584 //0x0080
4585 printf("(0x0080) alpha_adp_en:%d yin_flt_en:%d edge_avg_en:%d\n",
4586 pSharpCfg->alpha_adp_en,
4587 pSharpCfg->yin_flt_en,
4588 pSharpCfg->edge_avg_en);
4589
4590
4591 //0x0084
4592 printf("(0x0084) hbf_ratio:%d ehf_th:%d pbf_ratio:%d\n",
4593 pSharpCfg->hbf_ratio,
4594 pSharpCfg->ehf_th,
4595 pSharpCfg->pbf_ratio);
4596
4597 //0x0088
4598 printf("(0x0088) edge_thed:%d dir_min:%d smoth_th4:%d\n",
4599 pSharpCfg->edge_thed,
4600 pSharpCfg->dir_min,
4601 pSharpCfg->smoth_th4);
4602
4603 //0x008c
4604 printf("(0x008c) l_alpha:%d g_alpha:%d \n",
4605 pSharpCfg->l_alpha,
4606 pSharpCfg->g_alpha);
4607
4608
4609 //0x0090
4610 for(i = 0; i < 3; i++) {
4611 printf("(0x0090) pbf_k[%d]:%d \n",
4612 i, pSharpCfg->pbf_k[i]);
4613 }
4614
4615
4616
4617 //0x0094 - 0x0098
4618 for(i = 0; i < 6; i++) {
4619 printf("(0x0094 - 0x0098) mrf_k[%d]:%d \n",
4620 i, pSharpCfg->mrf_k[i]);
4621 }
4622
4623
4624 //0x009c -0x00a4
4625 for(i = 0; i < 12; i++) {
4626 printf("(0x009c -0x00a4) mbf_k[%d]:%d \n",
4627 i, pSharpCfg->mbf_k[i]);
4628 }
4629
4630
4631 //0x00a8 -0x00ac
4632 for(i = 0; i < 6; i++) {
4633 printf("(0x00a8 -0x00ac) hrf_k[%d]:%d \n",
4634 i, pSharpCfg->hrf_k[i]);
4635 }
4636
4637
4638 //0x00b0
4639 for(i = 0; i < 3; i++) {
4640 printf("(0x00b0) hbf_k[%d]:%d \n",
4641 i, pSharpCfg->hbf_k[i]);
4642 }
4643
4644
4645 //0x00b4
4646 for(i = 0; i < 3; i++) {
4647 printf("(0x00b4) eg_coef[%d]:%d \n",
4648 i, pSharpCfg->eg_coef[i]);
4649 }
4650
4651 //0x00b8
4652 for(i = 0; i < 3; i++) {
4653 printf("(0x00b8) eg_smoth[%d]:%d \n",
4654 i, pSharpCfg->eg_smoth[i]);
4655 }
4656
4657
4658 //0x00bc - 0x00c0
4659 for(i = 0; i < 6; i++) {
4660 printf("(0x00bc - 0x00c0) eg_gaus[%d]:%d \n",
4661 i, pSharpCfg->eg_gaus[i]);
4662 }
4663
4664
4665 //0x00c4 - 0x00c8
4666 for(i = 0; i < 6; i++) {
4667 printf("(0x00c4 - 0x00c8) dog_k[%d]:%d \n",
4668 i, pSharpCfg->dog_k[i]);
4669 }
4670
4671
4672 //0x00cc - 0x00d0
4673 for(i = 0; i < SHP_LUM_POINT_SIZE; i++) {
4674 printf("(0x00cc - 0x00d0) lum_point[%d]:%d \n",
4675 i, pSharpCfg->lum_point[i]);
4676 }
4677
4678 //0x00d4
4679 printf("(0x00d4) pbf_shf_bits:%d mbf_shf_bits:%d hbf_shf_bits:%d\n",
4680 pSharpCfg->pbf_shf_bits,
4681 pSharpCfg->mbf_shf_bits,
4682 pSharpCfg->hbf_shf_bits);
4683
4684
4685 //0x00d8 - 0x00dc
4686 for(i = 0; i < SHP_SIGMA_SIZE; i++) {
4687 printf("(0x00d8 - 0x00dc) pbf_sigma[%d]:%d \n",
4688 i, pSharpCfg->pbf_sigma[i]);
4689 }
4690
4691 //0x00e0 - 0x00e4
4692 for(i = 0; i < SHP_LUM_CLP_SIZE; i++) {
4693 printf("(0x00e0 - 0x00e4) lum_clp_m[%d]:%d \n",
4694 i, pSharpCfg->lum_clp_m[i]);
4695 }
4696
4697 //0x00e8 - 0x00ec
4698 for(i = 0; i < SHP_LUM_MIN_SIZE; i++) {
4699 printf("(0x00e8 - 0x00ec) lum_min_m[%d]:%d \n",
4700 i, pSharpCfg->lum_min_m[i]);
4701 }
4702
4703 //0x00f0 - 0x00f4
4704 for(i = 0; i < SHP_SIGMA_SIZE; i++) {
4705 printf("(0x00f0 - 0x00f4) mbf_sigma[%d]:%d \n",
4706 i, pSharpCfg->mbf_sigma[i]);
4707 }
4708
4709 //0x00f8 - 0x00fc
4710 for(i = 0; i < SHP_LUM_CLP_SIZE; i++) {
4711 printf("(0x00f8 - 0x00fc) lum_clp_h[%d]:%d \n",
4712 i, pSharpCfg->lum_clp_h[i]);
4713 }
4714
4715 //0x0100 - 0x0104
4716 for(i = 0; i < SHP_SIGMA_SIZE; i++) {
4717 printf("(0x0100 - 0x0104) hbf_sigma[%d]:%d \n",
4718 i, pSharpCfg->hbf_sigma[i]);
4719 }
4720
4721 //0x0108 - 0x010c
4722 for(i = 0; i < SHP_EDGE_LUM_THED_SIZE; i++) {
4723 printf("(0x0108 - 0x010c) edge_lum_thed[%d]:%d \n",
4724 i, pSharpCfg->edge_lum_thed[i]);
4725 }
4726
4727 //0x0110 - 0x0114
4728 for(i = 0; i < SHP_CLAMP_SIZE; i++) {
4729 printf("(0x0110 - 0x0114) clamp_pos[%d]:%d \n",
4730 i, pSharpCfg->clamp_pos[i]);
4731 }
4732
4733 //0x0118 - 0x011c
4734 for(i = 0; i < SHP_CLAMP_SIZE; i++) {
4735 printf("(0x0118 - 0x011c) clamp_neg[%d]:%d \n",
4736 i, pSharpCfg->clamp_neg[i]);
4737 }
4738
4739 //0x0120 - 0x0124
4740 for(i = 0; i < SHP_DETAIL_ALPHA_SIZE; i++) {
4741 printf("(0x0120 - 0x0124) detail_alpha[%d]:%d \n",
4742 i, pSharpCfg->detail_alpha[i]);
4743 }
4744
4745 //0x0128
4746 printf("(0x0128) rfl_ratio:%d rfh_ratio:%d\n",
4747 pSharpCfg->rfl_ratio, pSharpCfg->rfh_ratio);
4748
4749 // mf/hf ratio
4750
4751 //0x012C
4752 printf("(0x012C) m_ratio:%d h_ratio:%d\n",
4753 pSharpCfg->m_ratio, pSharpCfg->h_ratio);
4754
4755 printf("%s:(%d) exit \n", __FUNCTION__, __LINE__);
4756 }
4757 #endif
4758
4759 XCamReturn
setModuleCtl(rk_aiq_module_id_t moduleId,bool en)4760 CamHwIsp20::setModuleCtl(rk_aiq_module_id_t moduleId, bool en)
4761 {
4762 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4763 if (_cur_calib_infos.mfnr.enable && _cur_calib_infos.mfnr.motion_detect_en) {
4764 if ((moduleId == RK_MODULE_TNR) && (en == false)) {
4765 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "motion detect is running, operate not permit!");
4766 return XCAM_RETURN_ERROR_FAILED;
4767 }
4768 }
4769 setModuleStatus(moduleId, en);
4770 return ret;
4771 }
4772
4773 XCamReturn
getModuleCtl(rk_aiq_module_id_t moduleId,bool & en)4774 CamHwIsp20::getModuleCtl(rk_aiq_module_id_t moduleId, bool &en)
4775 {
4776 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4777 getModuleStatus(moduleId, en);
4778 return ret;
4779 }
4780
notify_capture_raw()4781 XCamReturn CamHwIsp20::notify_capture_raw()
4782 {
4783 #ifndef USE_RAWSTREAM_LIB
4784 if (mRawProcUnit.ptr())
4785 return mRawProcUnit->notify_capture_raw();
4786 else
4787 #endif
4788 return XCAM_RETURN_ERROR_FAILED;
4789 }
4790
capture_raw_ctl(capture_raw_t type,int count,const char * capture_dir,char * output_dir)4791 XCamReturn CamHwIsp20::capture_raw_ctl(capture_raw_t type, int count, const char* capture_dir, char* output_dir)
4792 {
4793 #ifndef USE_RAWSTREAM_LIB
4794 if (!mRawProcUnit.ptr())
4795 return XCAM_RETURN_ERROR_FAILED;
4796
4797 if (type == CAPTURE_RAW_AND_YUV_SYNC)
4798 return mRawProcUnit->capture_raw_ctl(type);
4799 else if (type == CAPTURE_RAW_SYNC)
4800 return mRawProcUnit->capture_raw_ctl(type, count, capture_dir, output_dir);
4801 #endif
4802 return XCAM_RETURN_ERROR_FAILED;
4803 }
4804
4805 XCamReturn
setIrcutParams(bool on)4806 CamHwIsp20::setIrcutParams(bool on)
4807 {
4808 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4809 ENTER_CAMHW_FUNCTION();
4810
4811 struct v4l2_control control;
4812
4813 xcam_mem_clear (control);
4814 control.id = V4L2_CID_BAND_STOP_FILTER;
4815 if(on)
4816 control.value = IRCUT_STATE_CLOSED;
4817 else
4818 control.value = IRCUT_STATE_OPENED;
4819 if (mIrcutDev.ptr()) {
4820 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "set ircut value: %d", control.value);
4821 if (mIrcutDev->io_control (VIDIOC_S_CTRL, &control) < 0) {
4822 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set ircut value failed to device!");
4823 ret = XCAM_RETURN_ERROR_IOCTL;
4824 }
4825 }
4826
4827 EXIT_CAMHW_FUNCTION();
4828 return ret;
4829 }
4830
getIspModuleEnState()4831 uint64_t CamHwIsp20::getIspModuleEnState()
4832 {
4833 return _isp_module_ens;
4834 }
4835
setSensorFlip(bool mirror,bool flip,int skip_frm_cnt)4836 XCamReturn CamHwIsp20::setSensorFlip(bool mirror, bool flip, int skip_frm_cnt)
4837 {
4838 BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
4839 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4840
4841 int32_t skip_frame_sequence = 0;
4842 ret = mSensorSubdev->set_mirror_flip(mirror, flip, skip_frame_sequence);
4843
4844 /* struct timespec tp; */
4845 /* clock_gettime(CLOCK_MONOTONIC, &tp); */
4846 /* int64_t skip_ts = (int64_t)(tp.tv_sec) * 1000 * 1000 * 1000 + (int64_t)(tp.tv_nsec); */
4847 #ifndef USE_RAWSTREAM_LIB
4848 if (_state == CAM_HW_STATE_STARTED && skip_frame_sequence != -1) {
4849 mRawCapUnit->skip_frames(skip_frm_cnt, skip_frame_sequence);
4850 }
4851 #endif
4852 return ret;
4853 }
4854
getSensorFlip(bool & mirror,bool & flip)4855 XCamReturn CamHwIsp20::getSensorFlip(bool& mirror, bool& flip)
4856 {
4857 BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
4858
4859 return mSensorSubdev->get_mirror_flip(mirror, flip);
4860 }
4861
setSensorCrop(rk_aiq_rect_t & rect)4862 XCamReturn CamHwIsp20::setSensorCrop(rk_aiq_rect_t& rect)
4863 {
4864 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4865 struct v4l2_crop crop;
4866 #ifndef USE_RAWSTREAM_LIB
4867 for (int i = 0; i < 3; i++) {
4868 V4l2Device* mipi_tx = mRawCapUnit->get_tx_device(i).get_cast_ptr<V4l2Device>();
4869 memset(&crop, 0, sizeof(crop));
4870 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
4871 ret = mipi_tx->get_crop(crop);
4872 crop.c.left = rect.left;
4873 crop.c.top = rect.top;
4874 crop.c.width = rect.width;
4875 crop.c.height = rect.height;
4876 ret = mipi_tx->set_crop(crop);
4877 }
4878 _crop_rect = rect;
4879 #endif
4880 return ret;
4881 }
4882
getSensorCrop(rk_aiq_rect_t & rect)4883 XCamReturn CamHwIsp20::getSensorCrop(rk_aiq_rect_t& rect)
4884 {
4885 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4886 struct v4l2_crop crop;
4887 #ifndef USE_RAWSTREAM_LIB
4888 V4l2Device* mipi_tx = mRawCapUnit->get_tx_device(0).get_cast_ptr<V4l2Device>();
4889 memset(&crop, 0, sizeof(crop));
4890 ret = mipi_tx->get_crop(crop);
4891 rect.left = crop.c.left;
4892 rect.top = crop.c.top;
4893 rect.width = crop.c.width;
4894 rect.height = crop.c.height;
4895 #endif
4896 return ret;
4897 }
4898
setHdrGlobalTmoMode(uint32_t frame_id,bool mode)4899 void CamHwIsp20::setHdrGlobalTmoMode(uint32_t frame_id, bool mode)
4900 {
4901 if (mNoReadBack)
4902 return;
4903 #ifndef USE_RAWSTREAM_LIB
4904 mRawProcUnit->set_hdr_global_tmo_mode(frame_id, mode);
4905 #endif
4906 }
4907
setMulCamConc(bool cc)4908 void CamHwIsp20::setMulCamConc(bool cc)
4909 {
4910 #ifndef USE_RAWSTREAM_LIB
4911 mRawProcUnit->setMulCamConc(cc);
4912 if (cc)
4913 mNoReadBack = false;
4914 #endif
4915 }
4916
getShareMemOps(isp_drv_share_mem_ops_t ** mem_ops)4917 void CamHwIsp20::getShareMemOps(isp_drv_share_mem_ops_t** mem_ops)
4918 {
4919 this->alloc_mem = (alloc_mem_t)&CamHwIsp20::allocMemResource;
4920 this->release_mem = (release_mem_t)&CamHwIsp20::releaseMemResource;
4921 this->get_free_item = (get_free_item_t)&CamHwIsp20::getFreeItem;
4922 *mem_ops = this;
4923 }
4924
allocMemResource(uint8_t id,void * ops_ctx,void * config,void ** mem_ctx)4925 void CamHwIsp20::allocMemResource(uint8_t id, void *ops_ctx, void *config, void **mem_ctx)
4926 {
4927 int ret = -1;
4928 struct rkispp_fecbuf_info fecbuf_info;
4929 struct rkisp_meshbuf_info cacbuf_info;
4930 struct rkispp_fecbuf_size fecbuf_size;
4931 struct rkisp_meshbuf_size cacbuf_size;
4932 struct rkisp_info2ddr dbgbuf_info;
4933
4934 uint8_t offset = id * ISP3X_MESH_BUF_NUM;
4935
4936 CamHwIsp20 *isp20 = static_cast<CamHwIsp20*>((isp_drv_share_mem_ops_t*)ops_ctx);
4937 rk_aiq_share_mem_config_t* share_mem_cfg = (rk_aiq_share_mem_config_t *)config;
4938
4939 SmartLock locker (isp20->_mem_mutex);
4940 if (share_mem_cfg->mem_type == MEM_TYPE_LDCH) {
4941 #if defined(ISP_HW_V20) || defined(ISP_HW_V21)
4942 struct rkisp_ldchbuf_size ldchbuf_size;
4943 struct rkisp_ldchbuf_info ldchbuf_info;
4944 unsigned long cmd = RKISP_CMD_SET_LDCHBUF_SIZE;
4945
4946 ldchbuf_size.meas_width = share_mem_cfg->alloc_param.width;
4947 ldchbuf_size.meas_height = share_mem_cfg->alloc_param.height;
4948 #else
4949 struct rkisp_meshbuf_info ldchbuf_info;
4950 struct rkisp_meshbuf_size ldchbuf_size;
4951 unsigned long cmd = RKISP_CMD_SET_MESHBUF_SIZE;
4952
4953 ldchbuf_size.unite_isp_id = id;
4954 ldchbuf_size.module_id = ISP3X_MODULE_LDCH;
4955 ldchbuf_size.meas_width = share_mem_cfg->alloc_param.width;
4956 ldchbuf_size.meas_height = share_mem_cfg->alloc_param.height;
4957 ldchbuf_size.buf_cnt = ISP2X_MESH_BUF_NUM;
4958 #endif
4959 ret = isp20->mIspCoreDev->io_control(cmd, &ldchbuf_size);
4960 if (ret < 0) {
4961 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "alloc ldch buf failed!");
4962 *mem_ctx = nullptr;
4963 return;
4964 }
4965 xcam_mem_clear(ldchbuf_info);
4966 #if defined(ISP_HW_V20) || defined(ISP_HW_V21)
4967 cmd = RKISP_CMD_GET_LDCHBUF_INFO;
4968 #else
4969 ldchbuf_info.unite_isp_id = id;
4970 ldchbuf_info.module_id = ISP3X_MODULE_LDCH;
4971 cmd = RKISP_CMD_GET_MESHBUF_INFO;
4972 #endif
4973 ret = isp20->mIspCoreDev->io_control(cmd, &ldchbuf_info);
4974 if (ret < 0) {
4975 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to get ldch buf info!!");
4976 *mem_ctx = nullptr;
4977 return;
4978 }
4979
4980 rk_aiq_ldch_share_mem_info_t* mem_info_array =
4981 (rk_aiq_ldch_share_mem_info_t*)(isp20->_ldch_drv_mem_ctx.mem_info);
4982 for (int i = 0; i < ISP2X_MESH_BUF_NUM; i++) {
4983 mem_info_array[offset + i].map_addr =
4984 mmap(NULL, ldchbuf_info.buf_size[i], PROT_READ | PROT_WRITE, MAP_SHARED, ldchbuf_info.buf_fd[i], 0);
4985 if (MAP_FAILED == mem_info_array[offset + i].map_addr)
4986 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to map ldch buf!!");
4987
4988 mem_info_array[offset + i].fd = ldchbuf_info.buf_fd[i];
4989 mem_info_array[offset + i].size = ldchbuf_info.buf_size[i];
4990 struct isp2x_mesh_head *head = (struct isp2x_mesh_head*)mem_info_array[offset + i].map_addr;
4991 mem_info_array[offset + i].addr = (void*)((char*)mem_info_array[offset + i].map_addr + head->data_oft);
4992 mem_info_array[offset + i].state = (char*)&head->stat;
4993 }
4994
4995 *mem_ctx = (void*)(&isp20->_ldch_drv_mem_ctx);
4996 #if defined(ISP_HW_V20)
4997 } else if (share_mem_cfg->mem_type == MEM_TYPE_FEC) {
4998 fecbuf_size.meas_width = share_mem_cfg->alloc_param.width;
4999 fecbuf_size.meas_height = share_mem_cfg->alloc_param.height;
5000 fecbuf_size.meas_mode = share_mem_cfg->alloc_param.reserved[0];
5001 ret = isp20->_ispp_sd->io_control(RKISPP_CMD_SET_FECBUF_SIZE, &fecbuf_size);
5002 if (ret < 0) {
5003 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "alloc fec buf failed!");
5004 *mem_ctx = nullptr;
5005 return;
5006 }
5007 xcam_mem_clear(fecbuf_info);
5008 ret = isp20->_ispp_sd->io_control(RKISPP_CMD_GET_FECBUF_INFO, &fecbuf_info);
5009 if (ret < 0) {
5010 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to get fec buf info!!");
5011 *mem_ctx = nullptr;
5012 return;
5013 }
5014 rk_aiq_fec_share_mem_info_t* mem_info_array =
5015 (rk_aiq_fec_share_mem_info_t*)(isp20->_fec_drv_mem_ctx.mem_info);
5016 for (int i = 0; i < FEC_MESH_BUF_NUM; i++) {
5017 mem_info_array[i].map_addr =
5018 mmap(NULL, fecbuf_info.buf_size[i], PROT_READ | PROT_WRITE, MAP_SHARED, fecbuf_info.buf_fd[i], 0);
5019 if (MAP_FAILED == mem_info_array[i].map_addr)
5020 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to map fec buf!!");
5021
5022 mem_info_array[i].fd = fecbuf_info.buf_fd[i];
5023 mem_info_array[i].size = fecbuf_info.buf_size[i];
5024 struct rkispp_fec_head *head = (struct rkispp_fec_head*)mem_info_array[i].map_addr;
5025 mem_info_array[i].meshxf =
5026 (unsigned char*)mem_info_array[i].map_addr + head->meshxf_oft;
5027 mem_info_array[i].meshyf =
5028 (unsigned char*)mem_info_array[i].map_addr + head->meshyf_oft;
5029 mem_info_array[i].meshxi =
5030 (unsigned short*)((char*)mem_info_array[i].map_addr + head->meshxi_oft);
5031 mem_info_array[i].meshyi =
5032 (unsigned short*)((char*)mem_info_array[i].map_addr + head->meshyi_oft);
5033 mem_info_array[i].state = (char*)&head->stat;
5034 }
5035 *mem_ctx = (void*)(&isp20->_fec_drv_mem_ctx);
5036 #endif
5037 } else if (share_mem_cfg->mem_type == MEM_TYPE_CAC) {
5038 cacbuf_size.unite_isp_id = id;
5039 cacbuf_size.module_id = ISP3X_MODULE_CAC;
5040 cacbuf_size.meas_width = share_mem_cfg->alloc_param.width;
5041 cacbuf_size.meas_height = share_mem_cfg->alloc_param.height;
5042 cacbuf_size.buf_cnt = share_mem_cfg->alloc_param.reserved[0];
5043 ret = isp20->mIspCoreDev->io_control(RKISP_CMD_SET_MESHBUF_SIZE, &cacbuf_size);
5044 if (ret < 0) {
5045 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "alloc cac buf failed!");
5046 *mem_ctx = nullptr;
5047 return;
5048 }
5049 xcam_mem_clear(cacbuf_info);
5050 cacbuf_info.unite_isp_id = id;
5051 cacbuf_info.module_id = ISP3X_MODULE_CAC;
5052 ret = isp20->mIspCoreDev->io_control(RKISP_CMD_GET_MESHBUF_INFO, &cacbuf_info);
5053 if (ret < 0) {
5054 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to get cac buf info!!");
5055 *mem_ctx = nullptr;
5056 return;
5057 }
5058 rk_aiq_cac_share_mem_info_t* mem_info_array =
5059 (rk_aiq_cac_share_mem_info_t*)(isp20->_cac_drv_mem_ctx.mem_info);
5060 for (int i = 0; i < cacbuf_size.buf_cnt; i++) {
5061 mem_info_array[offset + i].map_addr =
5062 mmap(NULL, cacbuf_info.buf_size[i], PROT_READ | PROT_WRITE, MAP_SHARED, cacbuf_info.buf_fd[i], 0);
5063 if (MAP_FAILED == mem_info_array[offset + i].map_addr) {
5064 mem_info_array[offset + i].map_addr = NULL;
5065 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to map cac buf!!");
5066 *mem_ctx = nullptr;
5067 return;
5068 }
5069
5070 mem_info_array[offset + i].fd = cacbuf_info.buf_fd[i];
5071 mem_info_array[offset + i].size = cacbuf_info.buf_size[i];
5072 struct isp2x_mesh_head* head = (struct isp2x_mesh_head*)mem_info_array[offset + i].map_addr;
5073 mem_info_array[offset + i].addr = (void*)((char*)mem_info_array[offset + i].map_addr + head->data_oft);
5074 mem_info_array[offset + i].state = (char*)&head->stat;
5075 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "Got CAC LUT fd %d for ISP %d", mem_info_array[offset + i].fd, id);
5076 }
5077 *mem_ctx = (void*)(&isp20->_cac_drv_mem_ctx);
5078 } else if (share_mem_cfg->mem_type == MEM_TYPE_DBG_INFO) {
5079
5080 id = 0;
5081 offset = id * RKISP_INFO2DDR_BUF_MAX;
5082 dbgbuf_info.wsize = share_mem_cfg->alloc_param.width;
5083 dbgbuf_info.vsize = share_mem_cfg->alloc_param.height;
5084 dbgbuf_info.owner = (rkisp_info2ddr_owner)(share_mem_cfg->alloc_param.reserved[0]);
5085 if (dbgbuf_info.owner == RKISP_INFO2DRR_OWNER_AWB) {
5086 dbgbuf_info.u.awb.awb2ddr_sel = share_mem_cfg->alloc_param.reserved[1];
5087 } else if (dbgbuf_info.owner == RKISP_INFO2DRR_OWNER_GAIN) {
5088 dbgbuf_info.u.gain.gain2ddr_mode = share_mem_cfg->alloc_param.reserved[1];
5089 } else {
5090 *mem_ctx = nullptr;
5091 return;
5092 }
5093 dbgbuf_info.buf_cnt = share_mem_cfg->alloc_param.reserved[2];
5094 ret = isp20->mIspCoreDev->io_control(RKISP_CMD_INFO2DDR, &dbgbuf_info);
5095 if (ret < 0) {
5096 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "alloc dbg buf failed!");
5097 *mem_ctx = nullptr;
5098 return;
5099 }
5100 rk_aiq_dbg_share_mem_info_t* mem_info_array =
5101 (rk_aiq_dbg_share_mem_info_t*)(isp20->_dbg_drv_mem_ctx.mem_info);
5102 for (int i = 0; i < dbgbuf_info.buf_cnt; i++) {
5103 mem_info_array[offset + i].map_addr =
5104 mmap(NULL, dbgbuf_info.wsize * dbgbuf_info.vsize, PROT_READ | PROT_WRITE, MAP_SHARED, dbgbuf_info.buf_fd[i], 0);
5105 if (MAP_FAILED == mem_info_array[offset + i].map_addr) {
5106 mem_info_array[offset + i].map_addr = NULL;
5107 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to map dbg buf!!");
5108 *mem_ctx = nullptr;
5109 return;
5110 }
5111 mem_info_array[offset + i].size = dbgbuf_info.wsize * dbgbuf_info.vsize;
5112 mem_info_array[offset + i].fd = dbgbuf_info.buf_fd[i];
5113 }
5114 *mem_ctx = (void*)(&isp20->_dbg_drv_mem_ctx);
5115 }
5116 }
5117
releaseMemResource(uint8_t id,void * mem_ctx)5118 void CamHwIsp20::releaseMemResource(uint8_t id, void *mem_ctx)
5119 {
5120 int ret = -1;
5121 drv_share_mem_ctx_t* drv_mem_ctx = (drv_share_mem_ctx_t*)mem_ctx;
5122 if (mem_ctx == nullptr) return;
5123 CamHwIsp20 *isp20 = (CamHwIsp20*)(drv_mem_ctx->ops_ctx);
5124 uint8_t offset = id * ISP3X_MESH_BUF_NUM;
5125 uint64_t module_id = 0;
5126
5127 SmartLock locker (isp20->_mem_mutex);
5128 if (drv_mem_ctx->type == MEM_TYPE_LDCH) {
5129 rk_aiq_ldch_share_mem_info_t* mem_info_array =
5130 (rk_aiq_ldch_share_mem_info_t*)(drv_mem_ctx->mem_info);
5131 for (int i = 0; i < ISP2X_MESH_BUF_NUM; i++) {
5132 if (mem_info_array[offset + i].map_addr) {
5133 if (mem_info_array[offset + i].state &&
5134 (MESH_BUF_CHIPINUSE != mem_info_array[offset + i].state[0])) {
5135 mem_info_array[offset + i].state[0] = MESH_BUF_INIT;
5136 }
5137 ret = munmap(mem_info_array[offset + i].map_addr, mem_info_array[offset + i].size);
5138 if (ret < 0)
5139 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "munmap ldch buf info!!");
5140 mem_info_array[offset + i].map_addr = NULL;
5141 }
5142 if (mem_info_array[offset + i].fd > 0) {
5143 ::close(mem_info_array[offset + i].fd);
5144 mem_info_array[offset + i].fd = -1;
5145 }
5146 }
5147 module_id = ISP2X_MODULE_LDCH;
5148 } else if (drv_mem_ctx->type == MEM_TYPE_FEC) {
5149 rk_aiq_fec_share_mem_info_t* mem_info_array =
5150 (rk_aiq_fec_share_mem_info_t*)(drv_mem_ctx->mem_info);
5151 for (int i = 0; i < FEC_MESH_BUF_NUM; i++) {
5152 if (mem_info_array[i].map_addr) {
5153 if (mem_info_array[i].state &&
5154 (MESH_BUF_CHIPINUSE != mem_info_array[i].state[0])) {
5155 mem_info_array[i].state[0] = MESH_BUF_INIT;
5156 }
5157 ret = munmap(mem_info_array[i].map_addr, mem_info_array[i].size);
5158 if (ret < 0)
5159 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "munmap fec buf info!!");
5160 mem_info_array[i].map_addr = NULL;
5161 }
5162 if (mem_info_array[i].fd > 0) {
5163 ::close(mem_info_array[i].fd);
5164 mem_info_array[i].fd = -1;
5165 }
5166 }
5167 } else if (drv_mem_ctx->type == MEM_TYPE_CAC) {
5168 rk_aiq_cac_share_mem_info_t* mem_info_array =
5169 (rk_aiq_cac_share_mem_info_t*)(drv_mem_ctx->mem_info);
5170 for (int i = 0; i < ISP3X_MESH_BUF_NUM; i++) {
5171 if (mem_info_array[offset + i].map_addr) {
5172 if (mem_info_array[offset + i].state &&
5173 (MESH_BUF_CHIPINUSE != mem_info_array[offset + i].state[0])) {
5174 mem_info_array[offset + i].state[0] = MESH_BUF_INIT;
5175 }
5176 ret = munmap(mem_info_array[offset + i].map_addr, mem_info_array[offset + i].size);
5177 if (ret < 0)
5178 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "munmap cac buf info!!");
5179 mem_info_array[offset + i].map_addr = NULL;
5180 }
5181 if (mem_info_array[offset + i].fd > 0) {
5182 ::close(mem_info_array[offset + i].fd);
5183 mem_info_array[offset + i].fd = -1;
5184 }
5185 }
5186 module_id = ISP3X_MODULE_CAC;
5187 } else if (drv_mem_ctx->type == MEM_TYPE_DBG_INFO) {
5188 rk_aiq_dbg_share_mem_info_t* mem_info_array =
5189 (rk_aiq_dbg_share_mem_info_t*)(drv_mem_ctx->mem_info);
5190 if (mem_info_array == nullptr)
5191 return;
5192
5193 struct rkisp_info2ddr info;
5194 info.owner = RKISP_INFO2DRR_OWNER_NULL;
5195 ret = isp20->mIspCoreDev->io_control(RKISP_CMD_INFO2DDR, &info);
5196 if (ret < 0) {
5197 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "alloc dbg buf failed!");
5198 return;
5199 }
5200 for (int i = 0; i < RKISP_INFO2DDR_BUF_MAX; i++) {
5201 if (mem_info_array[offset + i].map_addr) {
5202 ret = munmap(mem_info_array[offset + i].map_addr, mem_info_array[offset + i].size);
5203 if (ret < 0)
5204 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%dth,munmap dbg buf info!! error:%s, map_addr:%p, size:%d",
5205 i, strerror(errno), mem_info_array[offset + i].map_addr,
5206 mem_info_array[offset + i].size);
5207 mem_info_array[offset + i].map_addr = NULL;
5208 }
5209 if (mem_info_array[offset + i].fd > 0) ::close(mem_info_array[offset + i].fd);
5210 }
5211 }
5212 if (module_id != 0) {
5213 ret = isp20->mIspCoreDev->io_control(RKISP_CMD_MESHBUF_FREE, &module_id);
5214 if (ret < 0) {
5215 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "free dbg buf failed!");
5216 }
5217 }
5218 }
5219
5220 void*
getFreeItem(uint8_t id,void * mem_ctx)5221 CamHwIsp20::getFreeItem(uint8_t id, void *mem_ctx)
5222 {
5223 unsigned int idx;
5224 int retry_cnt = 3;
5225 drv_share_mem_ctx_t* drv_mem_ctx = (drv_share_mem_ctx_t*)mem_ctx;
5226 if (!mem_ctx || !drv_mem_ctx->ops_ctx) return nullptr;
5227 CamHwIsp20 *isp20 = (CamHwIsp20*)(drv_mem_ctx->ops_ctx);
5228 uint8_t offset = id * ISP3X_MESH_BUF_NUM;
5229
5230 SmartLock locker (isp20->_mem_mutex);
5231 if (drv_mem_ctx->type == MEM_TYPE_LDCH) {
5232 rk_aiq_ldch_share_mem_info_t* mem_info_array =
5233 (rk_aiq_ldch_share_mem_info_t*)(drv_mem_ctx->mem_info);
5234 do {
5235 for (idx = 0; idx < ISP2X_MESH_BUF_NUM; idx++) {
5236 if (mem_info_array[offset + idx].map_addr) {
5237 if (mem_info_array[offset + idx].state &&
5238 (0 == mem_info_array[offset + idx].state[0])) {
5239 return (void*)&mem_info_array[offset + idx];
5240 }
5241 }
5242 }
5243 } while(retry_cnt--);
5244 } else if (drv_mem_ctx->type == MEM_TYPE_FEC) {
5245 rk_aiq_fec_share_mem_info_t* mem_info_array =
5246 (rk_aiq_fec_share_mem_info_t*)(drv_mem_ctx->mem_info);
5247 if (mem_info_array == nullptr) return nullptr;
5248 do {
5249 for (idx = 0; idx < FEC_MESH_BUF_NUM; idx++) {
5250 if (mem_info_array[idx].map_addr) {
5251 if (mem_info_array[idx].state && (0 == mem_info_array[idx].state[0])) {
5252 return (void*)&mem_info_array[idx];
5253 }
5254 }
5255 }
5256 } while(retry_cnt--);
5257 } else if (drv_mem_ctx->type == MEM_TYPE_CAC) {
5258 rk_aiq_cac_share_mem_info_t* mem_info_array =
5259 (rk_aiq_cac_share_mem_info_t*)(drv_mem_ctx->mem_info);
5260 if (mem_info_array == nullptr) return nullptr;
5261 do {
5262 for (idx = 0; idx < ISP3X_MESH_BUF_NUM; idx++) {
5263 if (mem_info_array[offset + idx].map_addr != nullptr) {
5264 if (-1 != mem_info_array[offset + idx].fd) {
5265 return (void*)&mem_info_array[offset + idx];
5266 }
5267 }
5268 }
5269 } while(retry_cnt--);
5270 } else if (drv_mem_ctx->type == MEM_TYPE_DBG_INFO) {
5271 rk_aiq_dbg_share_mem_info_t* mem_info_array =
5272 (rk_aiq_dbg_share_mem_info_t*)(drv_mem_ctx->mem_info);
5273 if (mem_info_array == nullptr) return nullptr;
5274 do {
5275 for (idx = 0; idx < RKISP_INFO2DDR_BUF_MAX; idx++) {
5276 if (mem_info_array[offset + idx].map_addr) {
5277 uint32_t state = *(uint32_t*)(mem_info_array[offset + idx].map_addr);
5278 if (state == RKISP_INFO2DDR_BUF_INIT)
5279 return (void*)&mem_info_array[offset + idx];
5280 }
5281 }
5282 } while(retry_cnt--);
5283 }
5284 return NULL;
5285 }
5286
5287 XCamReturn
poll_event_ready(uint32_t sequence,int type)5288 CamHwIsp20::poll_event_ready (uint32_t sequence, int type)
5289 {
5290 // if (type == V4L2_EVENT_FRAME_SYNC && mIspEvtsListener) {
5291 // SmartPtr<SensorHw> mSensor = mSensorDev.dynamic_cast_ptr<SensorHw>();
5292 // SmartPtr<Isp20Evt> evtInfo = new Isp20Evt(this, mSensor);
5293 // evtInfo->evt_code = type;
5294 // evtInfo->sequence = sequence;
5295 // evtInfo->expDelay = _exp_delay;
5296
5297 // return mIspEvtsListener->ispEvtsCb(evtInfo);
5298 // }
5299
5300 return XCAM_RETURN_NO_ERROR;
5301 }
5302
5303 SmartPtr<ispHwEvt_t>
make_ispHwEvt(uint32_t sequence,int type,int64_t timestamp)5304 CamHwIsp20::make_ispHwEvt (uint32_t sequence, int type, int64_t timestamp)
5305 {
5306 if (type == V4L2_EVENT_FRAME_SYNC) {
5307 SmartPtr<SensorHw> mSensor = mSensorDev.dynamic_cast_ptr<SensorHw>();
5308 SmartPtr<Isp20Evt> evtInfo = new Isp20Evt(this, mSensor);
5309 evtInfo->evt_code = type;
5310 evtInfo->sequence = sequence;
5311 evtInfo->expDelay = _exp_delay;
5312 evtInfo->setSofTimeStamp(timestamp);
5313
5314 return evtInfo;
5315 }
5316
5317 return nullptr;
5318 }
5319
5320 XCamReturn
poll_event_failed(int64_t timestamp,const char * msg)5321 CamHwIsp20::poll_event_failed (int64_t timestamp, const char *msg)
5322 {
5323 return XCAM_RETURN_ERROR_FAILED;
5324 }
5325 XCamReturn
applyAnalyzerResult(SmartPtr<SharedItemBase> base,bool sync)5326 CamHwIsp20::applyAnalyzerResult(SmartPtr<SharedItemBase> base, bool sync)
5327 {
5328 return dispatchResult(base);
5329 }
5330
5331 XCamReturn
applyAnalyzerResult(cam3aResultList & list)5332 CamHwIsp20::applyAnalyzerResult(cam3aResultList& list)
5333 {
5334 return dispatchResult(list);
5335 }
5336
5337 XCamReturn
dispatchResult(cam3aResultList & list)5338 CamHwIsp20::dispatchResult(cam3aResultList& list)
5339 {
5340 cam3aResultList isp_result_list;
5341 for (auto& result : list) {
5342 switch (result->getType()) {
5343 case RESULT_TYPE_AEC_PARAM:
5344 case RESULT_TYPE_HIST_PARAM:
5345 case RESULT_TYPE_AWB_PARAM:
5346 case RESULT_TYPE_AWBGAIN_PARAM:
5347 case RESULT_TYPE_AF_PARAM:
5348 case RESULT_TYPE_DPCC_PARAM:
5349 case RESULT_TYPE_MERGE_PARAM:
5350 case RESULT_TYPE_TMO_PARAM:
5351 case RESULT_TYPE_CCM_PARAM:
5352 case RESULT_TYPE_LSC_PARAM:
5353 case RESULT_TYPE_BLC_PARAM:
5354 case RESULT_TYPE_RAWNR_PARAM:
5355 case RESULT_TYPE_GIC_PARAM:
5356 case RESULT_TYPE_DEBAYER_PARAM:
5357 case RESULT_TYPE_LDCH_PARAM:
5358 case RESULT_TYPE_LUT3D_PARAM:
5359 case RESULT_TYPE_DEHAZE_PARAM:
5360 case RESULT_TYPE_AGAMMA_PARAM:
5361 case RESULT_TYPE_ADEGAMMA_PARAM:
5362 case RESULT_TYPE_WDR_PARAM:
5363 case RESULT_TYPE_CSM_PARAM:
5364 case RESULT_TYPE_CGC_PARAM:
5365 case RESULT_TYPE_CONV422_PARAM:
5366 case RESULT_TYPE_YUVCONV_PARAM:
5367 case RESULT_TYPE_GAIN_PARAM:
5368 case RESULT_TYPE_CP_PARAM:
5369 case RESULT_TYPE_IE_PARAM:
5370 case RESULT_TYPE_MOTION_PARAM:
5371 isp_result_list.push_back(result);
5372 break;
5373 default:
5374 dispatchResult(result);
5375 break;
5376 }
5377 }
5378
5379 if (isp_result_list.size() > 0) {
5380 handleIsp3aReslut(isp_result_list);
5381 }
5382
5383 return XCAM_RETURN_NO_ERROR;
5384 }
5385
5386 XCamReturn
handleIsp3aReslut(cam3aResultList & list)5387 CamHwIsp20::handleIsp3aReslut(cam3aResultList& list)
5388 {
5389 ENTER_CAMHW_FUNCTION();
5390 XCamReturn ret = XCAM_RETURN_NO_ERROR;
5391 if (_is_exit) {
5392 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "set 3a config bypass since ia engine has stop");
5393 return XCAM_RETURN_BYPASS;
5394 }
5395
5396 bool restart = false;
5397 if (_state == CAM_HW_STATE_PREPARED || _state == CAM_HW_STATE_STOPPED ||
5398 _state == CAM_HW_STATE_PAUSED) {
5399 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "hdr-debug: %s: first set ispparams\n",
5400 __func__);
5401 if (!mIspParamsDev->is_activated()) {
5402 ret = mIspParamsDev->start();
5403 if (ret < 0) {
5404 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "prepare isp params dev err: %d\n", ret);
5405 }
5406
5407 ret = hdr_mipi_prepare_mode(_hdr_mode);
5408 if (ret < 0) {
5409 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
5410 }
5411 }
5412
5413 for (auto& result : list) {
5414 result->setId(0);
5415 #ifndef DISABLE_PARAMS_ASSEMBLER
5416 mParamsAssembler->addReadyCondition(result->getType());
5417 #endif
5418 }
5419 restart = true;
5420 }
5421
5422 #ifndef DISABLE_PARAMS_ASSEMBLER
5423 mParamsAssembler->queue(list);
5424
5425 // set all ready params to drv
5426 while (_state == CAM_HW_STATE_STARTED &&
5427 mParamsAssembler->ready()) {
5428 SmartLock locker(_stop_cond_mutex);
5429 if (_isp_stream_status != ISP_STREAM_STATUS_STREAM_OFF) {
5430 ret = setIspConfig();
5431 if (ret != XCAM_RETURN_NO_ERROR)
5432 break;
5433 } else {
5434 break;
5435 }
5436 }
5437 #else
5438 SmartLock locker(_stop_cond_mutex);
5439 if (_isp_stream_status != ISP_STREAM_STATUS_STREAM_OFF || restart) {
5440 ret = setIspConfig(&list);
5441 }
5442 #endif
5443 EXIT_CAMHW_FUNCTION();
5444 return ret;
5445 }
5446
5447 XCamReturn
dispatchResult(SmartPtr<cam3aResult> result)5448 CamHwIsp20::dispatchResult(SmartPtr<cam3aResult> result)
5449 {
5450 XCamReturn ret = XCAM_RETURN_NO_ERROR;
5451 if (!result.ptr())
5452 return XCAM_RETURN_ERROR_PARAM;
5453
5454 LOG1("%s enter, msg type(0x%x)", __FUNCTION__, result->getType());
5455 switch (result->getType())
5456 {
5457 case RESULT_TYPE_EXPOSURE_PARAM:
5458 {
5459 SmartPtr<RkAiqExpParamsProxy> exp = result.dynamic_cast_ptr<RkAiqExpParamsProxy>();
5460 ret = setExposureParams(exp);
5461 if (ret)
5462 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setExposureParams error %d id %d", ret, result->getId());
5463 break;
5464 }
5465 case RESULT_TYPE_AEC_PARAM:
5466 case RESULT_TYPE_HIST_PARAM:
5467 case RESULT_TYPE_AWB_PARAM:
5468 case RESULT_TYPE_AWBGAIN_PARAM:
5469 case RESULT_TYPE_AF_PARAM:
5470 case RESULT_TYPE_DPCC_PARAM:
5471 case RESULT_TYPE_MERGE_PARAM:
5472 case RESULT_TYPE_TMO_PARAM:
5473 case RESULT_TYPE_CCM_PARAM:
5474 case RESULT_TYPE_LSC_PARAM:
5475 case RESULT_TYPE_BLC_PARAM:
5476 case RESULT_TYPE_RAWNR_PARAM:
5477 case RESULT_TYPE_GIC_PARAM:
5478 case RESULT_TYPE_DEBAYER_PARAM:
5479 case RESULT_TYPE_LDCH_PARAM:
5480 case RESULT_TYPE_LUT3D_PARAM:
5481 case RESULT_TYPE_DEHAZE_PARAM:
5482 case RESULT_TYPE_AGAMMA_PARAM:
5483 case RESULT_TYPE_ADEGAMMA_PARAM:
5484 case RESULT_TYPE_WDR_PARAM:
5485 case RESULT_TYPE_CSM_PARAM:
5486 case RESULT_TYPE_CGC_PARAM:
5487 case RESULT_TYPE_CONV422_PARAM:
5488 case RESULT_TYPE_YUVCONV_PARAM:
5489 case RESULT_TYPE_GAIN_PARAM:
5490 case RESULT_TYPE_CP_PARAM:
5491 case RESULT_TYPE_IE_PARAM:
5492 case RESULT_TYPE_MOTION_PARAM:
5493 case RESULT_TYPE_CAC_PARAM:
5494 handleIsp3aReslut(result);
5495 break;
5496 case RESULT_TYPE_TNR_PARAM:
5497 case RESULT_TYPE_YNR_PARAM:
5498 case RESULT_TYPE_UVNR_PARAM:
5499 case RESULT_TYPE_SHARPEN_PARAM:
5500 case RESULT_TYPE_EDGEFLT_PARAM:
5501 case RESULT_TYPE_FEC_PARAM:
5502 case RESULT_TYPE_ORB_PARAM:
5503 #if defined(ISP_HW_V20)
5504 handlePpReslut(result);
5505 #endif
5506 break;
5507 case RESULT_TYPE_FOCUS_PARAM:
5508 {
5509 SmartPtr<RkAiqFocusParamsProxy> focus = result.dynamic_cast_ptr<RkAiqFocusParamsProxy>();
5510 ret = setFocusParams(focus);
5511 if (ret)
5512 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setFocusParams error %d", ret);
5513 break;
5514 }
5515 case RESULT_TYPE_IRIS_PARAM:
5516 {
5517 SmartPtr<RkAiqIrisParamsProxy> iris = result.dynamic_cast_ptr<RkAiqIrisParamsProxy>();
5518 ret = setIrisParams(iris, _cur_calib_infos.aec.IrisType);
5519 if (ret)
5520 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setIrisParams error %d", ret);
5521 ret = getIrisParams(iris, _cur_calib_infos.aec.IrisType);
5522 if (ret)
5523 LOGE_ANALYZER("getIrisParams error %d", ret);
5524 break;
5525 }
5526 case RESULT_TYPE_CPSL_PARAM:
5527 {
5528 SmartPtr<RkAiqCpslParamsProxy> cpsl = result.dynamic_cast_ptr<RkAiqCpslParamsProxy>();
5529 ret = setCpslParams(cpsl);
5530 if (ret)
5531 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setCpslParams error %d", ret);
5532 break;
5533 }
5534 case RESULT_TYPE_FLASH_PARAM:
5535 {
5536 #ifdef FLASH_CTL_DEBUG
5537 SmartPtr<rk_aiq_flash_setting_t> flash = result.dynamic_cast_ptr<rk_aiq_flash_setting_t>();
5538 ret = setFlParams(flash);
5539 if (ret)
5540 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setFlParams error %d", ret);
5541 #endif
5542 break;
5543 }
5544 case RESULT_TYPE_AFD_PARAM:
5545 {
5546 SmartPtr<RkAiqIspAfdParamsProxy> afd = result.dynamic_cast_ptr<RkAiqIspAfdParamsProxy>();
5547 if (mCifScaleStream.ptr()) {
5548 bool enable = afd->data()->result.enable;
5549 int ratio = afd->data()->result.ratio;
5550 setCifSclStartFlag(ratio, enable);
5551 }
5552 break;
5553 }
5554 default:
5555 LOGE("unknown param type(0x%x)!", result->getType());
5556 break;
5557 }
5558 return ret;
5559 LOGD("%s exit", __FUNCTION__);
5560 }
5561
notify_sof(SmartPtr<VideoBuffer> & buf)5562 XCamReturn CamHwIsp20::notify_sof(SmartPtr<VideoBuffer>& buf)
5563 {
5564 SmartPtr<SofEventBuffer> evtbuf = buf.dynamic_cast_ptr<SofEventBuffer>();
5565 SmartPtr<SofEventData> evtdata = evtbuf->get_data();
5566 BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
5567 LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
5568 mSensorSubdev->handle_sof(evtdata->_timestamp, evtdata->_frameid);
5569 #ifndef USE_RAWSTREAM_LIB
5570 if (!mNoReadBack)
5571 mRawProcUnit->notify_sof(evtdata->_timestamp, evtdata->_frameid);
5572 #endif
5573 if (mLensSubdev)
5574 mLensSubdev->handle_sof(evtdata->_timestamp, evtdata->_frameid);
5575 return XCAM_RETURN_NO_ERROR;
5576 }
5577
5578 XCamReturn
handleIsp3aReslut(SmartPtr<cam3aResult> & result)5579 CamHwIsp20::handleIsp3aReslut(SmartPtr<cam3aResult> &result)
5580 {
5581 ENTER_CAMHW_FUNCTION();
5582 XCamReturn ret = XCAM_RETURN_NO_ERROR;
5583 if (_is_exit) {
5584 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "set 3a config bypass since ia engine has stop");
5585 return XCAM_RETURN_BYPASS;
5586 }
5587
5588 if (_state == CAM_HW_STATE_PREPARED || _state == CAM_HW_STATE_STOPPED ||
5589 _state == CAM_HW_STATE_PAUSED) {
5590 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "hdr-debug: %s: first set ispparams id[%d]\n",
5591 __func__, result->getId());
5592 if (!mIspParamsDev->is_activated()) {
5593 ret = mIspParamsDev->start();
5594 if (ret < 0) {
5595 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "prepare isp params dev err: %d\n", ret);
5596 }
5597
5598 ret = hdr_mipi_prepare_mode(_hdr_mode);
5599 if (ret < 0) {
5600 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
5601 }
5602 }
5603
5604 #ifndef DISABLE_PARAMS_ASSEMBLER
5605 mParamsAssembler->addReadyCondition(result->getType());
5606 #endif
5607 }
5608
5609 #ifndef DISABLE_PARAMS_ASSEMBLER
5610 mParamsAssembler->queue(result);
5611
5612 // set all ready params to drv
5613 while (_state == CAM_HW_STATE_STARTED &&
5614 mParamsAssembler->ready()) {
5615 SmartLock locker(_stop_cond_mutex);
5616 if (_isp_stream_status != ISP_STREAM_STATUS_STREAM_OFF) {
5617 ret = setIspConfig();
5618 if (ret != XCAM_RETURN_NO_ERROR)
5619 break;
5620 } else {
5621 break;
5622 }
5623 }
5624 #else
5625 SmartLock locker(_stop_cond_mutex);
5626 if (_isp_stream_status != ISP_STREAM_STATUS_STREAM_OFF) {
5627 ret = setIspConfig();
5628 if (ret != XCAM_RETURN_NO_ERROR) {
5629 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setIspConfig failed !");
5630 }
5631 }
5632 #endif
5633 EXIT_CAMHW_FUNCTION();
5634 return ret;
5635 }
5636
5637 void
analyzePpInitEns(SmartPtr<cam3aResult> & result)5638 CamHwIsp20::analyzePpInitEns(SmartPtr<cam3aResult> &result)
5639 {
5640 if (result->getType() == RESULT_TYPE_TNR_PARAM) {
5641 // TODO: tnr init_ens should be always on ?
5642 RkAiqIspTnrParamsProxy* tnr = nullptr;
5643 tnr = result.get_cast_ptr<RkAiqIspTnrParamsProxy>();
5644 if (tnr) {
5645 rk_aiq_isp_tnr_t& tnr_param = tnr->data()->result;
5646 if(tnr_param.tnr_en) {
5647 if (tnr_param.mode > 0)
5648 mPpModuleInitEns |= ISPP_MODULE_TNR_3TO1;
5649 else
5650 mPpModuleInitEns |= ISPP_MODULE_TNR;
5651
5652 } else {
5653 mPpModuleInitEns &= ~ISPP_MODULE_TNR_3TO1;
5654 }
5655 }
5656 } else if (result->getType() == RESULT_TYPE_FEC_PARAM) {
5657 RkAiqIspFecParamsProxy* fec = nullptr;
5658 fec = result.get_cast_ptr<RkAiqIspFecParamsProxy>();
5659 if (fec) {
5660 rk_aiq_isp_fec_t& fec_param = fec->data()->result;
5661 if(fec_param.sw_fec_en) {
5662 if (fec_param.usage == ISPP_MODULE_FEC_ST) {
5663 mPpModuleInitEns |= ISPP_MODULE_FEC_ST;
5664 } else if (fec_param.usage == ISPP_MODULE_FEC) {
5665 mPpModuleInitEns |= ISPP_MODULE_FEC;
5666 }
5667 } else {
5668 mPpModuleInitEns &= ~ISPP_MODULE_FEC_ST;
5669 }
5670 }
5671 } else if (result->getType() == RESULT_TYPE_EDGEFLT_PARAM ||
5672 result->getType() == RESULT_TYPE_YNR_PARAM ||
5673 result->getType() == RESULT_TYPE_UVNR_PARAM ||
5674 result->getType() == RESULT_TYPE_SHARPEN_PARAM) {
5675 // TODO: nr,sharp init_ens always on ?
5676 mPpModuleInitEns |= ISPP_MODULE_SHP | ISPP_MODULE_NR;
5677 } else if (result->getType() == RESULT_TYPE_ORB_PARAM) {
5678 RkAiqIspOrbParamsProxy* orb = nullptr;
5679 orb = result.get_cast_ptr<RkAiqIspOrbParamsProxy>();
5680 if (orb) {
5681 rk_aiq_isp_orb_t& orb_param = orb->data()->result;
5682 if(orb_param.orb_en)
5683 mPpModuleInitEns |= ISPP_MODULE_ORB;
5684 else
5685 mPpModuleInitEns &= ~ISPP_MODULE_ORB;
5686 }
5687 }
5688 }
5689
5690 #if defined(ISP_HW_V20)
5691 XCamReturn
handlePpReslut(SmartPtr<cam3aResult> & result)5692 CamHwIsp20::handlePpReslut(SmartPtr<cam3aResult> &result)
5693 {
5694 ENTER_CAMHW_FUNCTION();
5695 XCamReturn ret = XCAM_RETURN_NO_ERROR;
5696 if (_is_exit) {
5697 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "set pp config bypass since ia engine has stop");
5698 return XCAM_RETURN_BYPASS;
5699 }
5700
5701 if (_state == CAM_HW_STATE_PREPARED || _state == CAM_HW_STATE_STOPPED ||
5702 _state == CAM_HW_STATE_PAUSED) {
5703 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKISPP_CMD_SET_INIT_MODULE");
5704 analyzePpInitEns(result);
5705 if (_ispp_sd->io_control(RKISPP_CMD_SET_INIT_MODULE, &mPpModuleInitEns))
5706 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "RKISPP_CMD_SET_INIT_MODULE ioctl failed");
5707 }
5708 setPpConfig(result);
5709 EXIT_CAMHW_FUNCTION();
5710 return ret;
5711 }
5712 #endif
5713
getParamsForEffMap(uint32_t frameId)5714 bool CamHwIsp20::getParamsForEffMap(uint32_t frameId)
5715 {
5716 if (_effecting_ispparam_map.count(frameId) <= 0) {
5717 if (mEffectIspParamsPool->has_free_items()) {
5718 _effecting_ispparam_map[frameId] = mEffectIspParamsPool->get_item();
5719 return true;
5720 } else {
5721 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "no free eff ispparam");
5722 return false;
5723 }
5724 }
5725 return true;
5726 }
5727
5728 XCamReturn
setIspConfig(cam3aResultList * result_list)5729 CamHwIsp20::setIspConfig(cam3aResultList* result_list)
5730 {
5731 XCamReturn ret = XCAM_RETURN_NO_ERROR;
5732
5733 ENTER_CAMHW_FUNCTION();
5734
5735 SmartPtr<V4l2Buffer> v4l2buf;
5736 uint32_t frameId = -1;
5737
5738 {
5739 SmartLock locker(_isp_params_cfg_mutex);
5740 while (_effecting_ispparam_map.size() > 4)
5741 _effecting_ispparam_map.erase(_effecting_ispparam_map.begin());
5742 }
5743
5744 if (mIspParamsDev.ptr()) {
5745 ret = mIspParamsDev->get_buffer(v4l2buf);
5746 if (ret) {
5747 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "Can not get isp params buffer, queued cnts:%d \n",
5748 mIspParamsDev->get_queued_bufcnt());
5749 return XCAM_RETURN_ERROR_PARAM;
5750 }
5751 } else
5752 return XCAM_RETURN_BYPASS;
5753
5754 #ifndef DISABLE_PARAMS_ASSEMBLER
5755 cam3aResultList ready_results;
5756 ret = mParamsAssembler->deQueOne(ready_results, frameId);
5757 if (ret != XCAM_RETURN_NO_ERROR) {
5758 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "deque isp ready parameter failed\n");
5759 mIspParamsDev->return_buffer_to_pool(v4l2buf);
5760 return XCAM_RETURN_ERROR_PARAM;
5761 }
5762 #else
5763 cam3aResultList& ready_results = *result_list;
5764 frameId = (*ready_results.begin())->getId();
5765 #endif
5766 LOGD_CAMHW("----------%s, cam%d start config id(%d)'s isp params", __FUNCTION__, mCamPhyId, frameId);
5767
5768 // add isp dgain results to ready results
5769 SensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<SensorHw>();
5770 if (mSensorSubdev) {
5771 SmartPtr<RkAiqSensorExpParamsProxy> expParam;
5772
5773 if (mSensorSubdev->getEffectiveExpParams(expParam, frameId) < 0) {
5774 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "frame_id(%d), get exposure failed!!!\n", frameId);
5775 } else {
5776 expParam->setType(RESULT_TYPE_EXPOSURE_PARAM);
5777 ready_results.push_back(expParam);
5778 }
5779 }
5780
5781 if (v4l2buf.ptr()) {
5782 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
5783 struct isp32_isp_params_cfg* isp_params =
5784 (struct isp32_isp_params_cfg*)v4l2buf->get_buf().m.userptr;
5785 #elif defined(ISP_HW_V30)
5786 struct isp3x_isp_params_cfg* isp_params =
5787 (struct isp3x_isp_params_cfg*)v4l2buf->get_buf().m.userptr;
5788 #elif defined(ISP_HW_V21)
5789 struct isp21_isp_params_cfg* isp_params =
5790 (struct isp21_isp_params_cfg*)v4l2buf->get_buf().m.userptr;
5791 #else
5792 struct isp20_isp_params_cfg* isp_params =
5793 (struct isp20_isp_params_cfg*)v4l2buf->get_buf().m.userptr;
5794 #endif
5795 int buf_index = v4l2buf->get_buf().index;
5796 bool isMultiIsp = mIsMultiIspMode;
5797 bool extened_pixel = mMultiIspExtendedPixel;
5798
5799 isp_params->module_en_update = 0;
5800 isp_params->module_cfg_update = 0;
5801 isp_params->module_ens = 0;
5802 if (merge_isp_results(ready_results, isp_params) != XCAM_RETURN_NO_ERROR)
5803 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "ISP parameter translation error\n");
5804
5805 if (isp_params->module_cfg_update == 0 &&
5806 isp_params->module_en_update) {
5807 mIspParamsDev->return_buffer_to_pool(v4l2buf);
5808 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "no new ISP parameters to drv");
5809 return ret;
5810 }
5811
5812 isp_params->module_cfg_update |= ISP32_MODULE_FORCE;
5813
5814 // TODO: isp driver has bug now, lsc cfg_up should be set along with
5815 // en_up
5816 if (isp_params->module_cfg_update & ISP2X_MODULE_LSC)
5817 isp_params->module_en_update |= ISP2X_MODULE_LSC;
5818
5819 isp_params->frame_id = frameId;
5820
5821 #if defined(ISP_HW_V30)
5822 if(mIsMultiIspMode == false) {
5823 dynamic_cast<Isp3xParams*>(this)->fixedAwbOveflowToIsp3xParams(isp_params, mIsMultiIspMode);
5824 }
5825 #endif
5826
5827 #if defined(RKAIQ_HAVE_MULTIISP) && defined(ISP_HW_V30)
5828 struct isp3x_isp_params_cfg ori_params;
5829 if (mIsMultiIspMode) {
5830 ori_params = *isp_params;
5831 mParamsSplitter->SplitIspParams(&ori_params, isp_params);
5832 dynamic_cast<Isp3xParams*>(this)->fixedAwbOveflowToIsp3xParams((void*)isp_params, mIsMultiIspMode);
5833 }
5834 #endif
5835
5836 #if defined(RKAIQ_ENABLE_SPSTREAM)
5837 if (mAfParams) {
5838 RkAiqIspAfParamsProxy* afParams =
5839 mAfParams.get_cast_ptr<RkAiqIspAfParamsProxy>();
5840 if (mSpStreamUnit.ptr()) {
5841 mSpStreamUnit->update_af_meas_params(&afParams->data()->result);
5842 }
5843 }
5844 #endif
5845
5846 #if defined(RKAIQ_HAVE_MULTIISP) && defined(ISP_HW_V30)
5847 if (mIsMultiIspMode)
5848 updateEffParams(isp_params, &ori_params);
5849 else
5850 updateEffParams(isp_params, NULL);
5851 #else
5852 updateEffParams(isp_params, NULL);
5853 #endif
5854 bool is_wait_params_done = false;
5855 if (mTbInfo.prd_type != RK_AIQ_PRD_TYPE_NORMAL) {
5856 // skip the params
5857 if (processTb(isp_params)) {
5858 mIspParamsDev->return_buffer_to_pool(v4l2buf);
5859 return XCAM_RETURN_NO_ERROR;
5860 }
5861 if (mTbInfo.is_pre_aiq && frameId == 0)
5862 is_wait_params_done = true;
5863 }
5864
5865 if (mIspParamsDev->queue_buffer(v4l2buf) != 0) {
5866 LOGE_CAMHW_SUBM(ISP20HW_SUBM,
5867 "RKISP1: failed to ioctl VIDIOC_QBUF for index %d, %d %s.\n", buf_index,
5868 errno, strerror(errno));
5869 mIspParamsDev->return_buffer_to_pool(v4l2buf);
5870 return XCAM_RETURN_ERROR_IOCTL;
5871 }
5872
5873 #ifdef DISABLE_PARAMS_POLL_THREAD
5874 int timeout = is_wait_params_done ? 100 : 1;
5875 int buf_counts = mIspParamsDev->get_buffer_count ();
5876 while (mIspParamsDev->get_queued_bufcnt() > 2 || is_wait_params_done) {
5877 if (mIspParamsDev->poll_event (timeout, -1) <= 0) {
5878 LOGW_CAMHW_SUBM(ISP20HW_SUBM, "poll params error, queue cnts: %d !",
5879 mIspParamsDev->get_queued_bufcnt());
5880 if (mIspParamsDev->get_queued_bufcnt() == buf_counts)
5881 timeout = 100 ;
5882 else
5883 break;
5884 }
5885 SmartPtr<V4l2Buffer> buf;
5886 ret = mIspParamsDev->dequeue_buffer (buf);
5887 if (ret != XCAM_RETURN_NO_ERROR) {
5888 XCAM_LOG_WARNING ("dequeue buffer failed");
5889 //return ret;
5890 } else {
5891 if (is_wait_params_done) {
5892 is_wait_params_done = false;
5893 SmartPtr<VideoBuffer> video_buf = new V4l2BufferProxy (buf, mIspParamsDev);
5894 video_buf->_buf_type = ISP_POLL_PARAMS;
5895
5896 LOGE("<TB> poll param id:%d, call err_cb", frameId);
5897 CamHwBase::poll_buffer_ready(video_buf);
5898 }
5899 mIspParamsDev->return_buffer_to_pool(buf);
5900 }
5901 }
5902 #endif
5903 _isp_module_ens |= isp_params->module_ens & isp_params->module_en_update;
5904 LOGD_CAMHW_SUBM(
5905 ISP20HW_SUBM,
5906 "Config id(%u)'s isp params, full_en 0x%llx ens 0x%llx ens_up 0x%llx, cfg_up 0x%llx", isp_params->frame_id,
5907 _isp_module_ens,
5908 isp_params->module_ens,
5909 isp_params->module_en_update,
5910 isp_params->module_cfg_update);
5911 LOGD_CAMHW_SUBM(
5912 ISP20HW_SUBM,
5913 "device(%s) queue buffer index %d, queue cnt %d, check exit status again[exit: %d]",
5914 XCAM_STR(mIspParamsDev->get_device_name()), buf_index,
5915 mIspParamsDev->get_queued_bufcnt(), _is_exit);
5916 if (_is_exit) return XCAM_RETURN_BYPASS;
5917 } else
5918 return XCAM_RETURN_BYPASS;
5919
5920 EXIT_CAMHW_FUNCTION();
5921 return ret;
5922 }
5923
5924 #if defined(ISP_HW_V20)
5925 XCamReturn
setPpConfig(SmartPtr<cam3aResult> & result)5926 CamHwIsp20::setPpConfig(SmartPtr<cam3aResult> &result)
5927 {
5928 XCamReturn ret = XCAM_RETURN_NO_ERROR;
5929 ENTER_CAMHW_FUNCTION();
5930 if (result->getType() == RESULT_TYPE_TNR_PARAM) {
5931 ret = mTnrStreamProcUnit->config_params(result->getId(), result);
5932 } else if (result->getType() == RESULT_TYPE_FEC_PARAM)
5933 ret = mFecParamStream->config_params(result->getId(), result);
5934 else if (result->getType() == RESULT_TYPE_EDGEFLT_PARAM ||
5935 result->getType() == RESULT_TYPE_YNR_PARAM ||
5936 result->getType() == RESULT_TYPE_UVNR_PARAM ||
5937 result->getType() == RESULT_TYPE_SHARPEN_PARAM ||
5938 result->getType() == RESULT_TYPE_ORB_PARAM) {
5939 ret = mNrStreamProcUnit->config_params(result->getId(), result);
5940 }
5941 EXIT_CAMHW_FUNCTION();
5942 return ret;
5943 }
5944 #endif
5945
5946 SmartPtr<cam3aResult>
get_3a_module_result(cam3aResultList & results,int32_t type)5947 CamHwIsp20::get_3a_module_result (cam3aResultList &results, int32_t type)
5948 {
5949 cam3aResultList::iterator i_res = results.begin();
5950 SmartPtr<cam3aResult> res;
5951
5952 auto it = std::find_if(
5953 results.begin(), results.end(),
5954 [&](const SmartPtr<cam3aResult> &r) {
5955 return type == r->getType();
5956 });
5957 if (it != results.end()) {
5958 res = *it;
5959 }
5960
5961 return res;
5962 }
5963
get_stream_format(rkaiq_stream_type_t type,struct v4l2_format & format)5964 XCamReturn CamHwIsp20::get_stream_format(rkaiq_stream_type_t type, struct v4l2_format &format)
5965 {
5966 XCamReturn ret = XCAM_RETURN_NO_ERROR;
5967
5968 switch (type)
5969 {
5970 case RKISP20_STREAM_MIPITX_S:
5971 case RKISP20_STREAM_MIPITX_M:
5972 case RKISP20_STREAM_MIPITX_L:
5973 {
5974 memset(&format, 0, sizeof(format));
5975 #ifndef USE_RAWSTREAM_LIB
5976 ret = mRawCapUnit->get_tx_device(0)->get_format(format);
5977 #endif
5978 break;
5979 }
5980 case RKISP20_STREAM_SP:
5981 case RKISP20_STREAM_NR:
5982 {
5983 struct v4l2_subdev_format isp_fmt;
5984 isp_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
5985 isp_fmt.pad = 2;
5986 ret = mIspCoreDev->getFormat(isp_fmt);
5987 if (ret == XCAM_RETURN_NO_ERROR) {
5988 BaseSensorHw* sensorHw;
5989 sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
5990 format.fmt.pix.width = isp_fmt.format.width;
5991 format.fmt.pix.height = isp_fmt.format.height;
5992 format.fmt.pix.pixelformat = get_v4l2_pixelformat(isp_fmt.format.code);
5993 }
5994 break;
5995 }
5996 default:
5997 ret = XCAM_RETURN_ERROR_PARAM;
5998 break;
5999 }
6000 return ret;
6001 }
6002
get_sp_resolution(int & width,int & height,int & aligned_w,int & aligned_h)6003 XCamReturn CamHwIsp20::get_sp_resolution(int &width, int &height, int &aligned_w, int &aligned_h)
6004 {
6005 #if defined(RKAIQ_ENABLE_SPSTREAM)
6006 return mSpStreamUnit->get_sp_resolution(width, height, aligned_w, aligned_h);
6007 #else
6008 return XCAM_RETURN_NO_ERROR;
6009 #endif
6010 }
6011
6012 #if RKAIQ_HAVE_PDAF
get_pdaf_support()6013 bool CamHwIsp20::get_pdaf_support()
6014 {
6015 bool pdaf_support = false;
6016
6017 if (mPdafStreamUnit.ptr())
6018 pdaf_support = mPdafInfo.pdaf_support;
6019
6020 return pdaf_support;
6021 }
6022 #endif
6023
notify_isp_stream_status(bool on)6024 void CamHwIsp20::notify_isp_stream_status(bool on)
6025 {
6026 if (on) {
6027 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "camId:%d, %s on", mCamPhyId, __func__);
6028 XCamReturn ret = hdr_mipi_start_mode(_hdr_mode);
6029 if (ret < 0) {
6030 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
6031 }
6032 _isp_stream_status = ISP_STREAM_STATUS_STREAM_ON;
6033
6034 if (mHwResLintener) {
6035 SmartPtr<Isp20Evt> ispEvt =
6036 new Isp20Evt(this, mSensorDev.dynamic_cast_ptr<SensorHw>());
6037
6038 SmartPtr<V4l2Device> dev(NULL);
6039 SmartPtr<Isp20EvtBuffer> ispEvtbuf =
6040 new Isp20EvtBuffer(ispEvt, dev);
6041
6042 ispEvtbuf->_buf_type = VICAP_STREAM_ON_EVT;
6043 SmartPtr<VideoBuffer> vbuf = ispEvtbuf.dynamic_cast_ptr<VideoBuffer>();
6044
6045 // FIXME: [Baron] 2022-06-29, all rx started, tx start
6046 if (!_linked_to_1608) {
6047 mHwResLintener->hwResCb(vbuf);
6048 } else {
6049 waitLastSensorDone();
6050 mHwResLintener->hwResCb(vbuf);
6051 }
6052 }
6053 } else {
6054 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "camId:%d, %s off", mCamPhyId, __func__);
6055 _isp_stream_status = ISP_STREAM_STATUS_STREAM_OFF;
6056 // if CIFISP_V4L2_EVENT_STREAM_STOP event is listened, isp driver
6057 // will wait isp params streaming off
6058 {
6059 SmartLock locker(_stop_cond_mutex);
6060 #ifndef DISABLE_PARAMS_POLL_THREAD
6061 if (mIspParamStream.ptr())
6062 mIspParamStream->stop();
6063 #else
6064 if (mIspParamsDev.ptr())
6065 mIspParamsDev->stop();
6066 #endif
6067 }
6068 hdr_mipi_stop();
6069 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "camId:%d, %s off done", mCamPhyId, __func__);
6070 }
6071 }
6072
reset_hardware()6073 XCamReturn CamHwIsp20::reset_hardware()
6074 {
6075 XCamReturn ret = XCAM_RETURN_NO_ERROR;
6076 #ifndef USE_RAWSTREAM_LIB
6077 if (mRawCapUnit.ptr()) {
6078 ret = mRawCapUnit->reset_hardware();
6079 }
6080 #endif
6081 return ret;
6082 }
6083
6084 XCamReturn
waitLastSensorDone()6085 CamHwIsp20::waitLastSensorDone()
6086 {
6087 SmartLock lock (_sync_1608_mutex);
6088
6089 while (!_sync_1608_done) {
6090 _sync_done_cond.timedwait(_sync_1608_mutex, 100000ULL);
6091 }
6092
6093 return XCamReturn();
6094 }
6095
6096 XCamReturn
pixFmt2Bpp(uint32_t pixFmt,int8_t & bpp)6097 CamHwIsp20::pixFmt2Bpp(uint32_t pixFmt, int8_t& bpp)
6098 {
6099 switch (pixFmt) {
6100 case V4L2_PIX_FMT_SBGGR8:
6101 case V4L2_PIX_FMT_SGBRG8:
6102 case V4L2_PIX_FMT_SGRBG8:
6103 case V4L2_PIX_FMT_SRGGB8:
6104 bpp = 8;
6105 break;
6106 case V4L2_PIX_FMT_SBGGR10:
6107 case V4L2_PIX_FMT_SGBRG10:
6108 case V4L2_PIX_FMT_SGRBG10:
6109 case V4L2_PIX_FMT_SRGGB10:
6110 bpp = 10;
6111 break;
6112 case V4L2_PIX_FMT_SBGGR12:
6113 case V4L2_PIX_FMT_SGBRG12:
6114 case V4L2_PIX_FMT_SGRBG12:
6115 case V4L2_PIX_FMT_SRGGB12:
6116 bpp = 12;
6117 break;
6118 case V4L2_PIX_FMT_SBGGR14:
6119 case V4L2_PIX_FMT_SGBRG14:
6120 case V4L2_PIX_FMT_SGRBG14:
6121 case V4L2_PIX_FMT_SRGGB14:
6122 bpp = 14;
6123 break;
6124 case V4L2_PIX_FMT_SBGGR16:
6125 case V4L2_PIX_FMT_SGBRG16:
6126 case V4L2_PIX_FMT_SGRBG16:
6127 case V4L2_PIX_FMT_SRGGB16:
6128 bpp = 16;
6129 break;
6130 default:
6131 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "unknown format");
6132 return XCAM_RETURN_ERROR_PARAM;
6133 }
6134
6135 return XCAM_RETURN_NO_ERROR;
6136 }
6137
6138 XCamReturn
rawReproc_genIspParams(uint32_t sequence,rk_aiq_frame_info_t * offline_finfo,int mode)6139 CamHwIsp20::rawReproc_genIspParams (uint32_t sequence, rk_aiq_frame_info_t *offline_finfo, int mode)
6140 {
6141 XCamReturn ret;
6142 if (mode) {
6143 if (offline_finfo) {
6144 SensorHw* mSensor = mSensorDev.get_cast_ptr<SensorHw>();
6145 ret = mSensor->set_offline_effecting_exp_map(sequence + 1, offline_finfo);
6146 }
6147 struct v4l2_event event;
6148 event.u.frame_sync.frame_sequence = sequence;
6149
6150 mIspSofStream->stop();
6151 SmartPtr<VideoBuffer> buf =
6152 mIspSofStream->new_video_buffer(event, NULL);
6153
6154 CamHwBase::poll_buffer_ready(buf);
6155 } else {
6156 // wait until params of frame index 'sequence' have been done
6157 int8_t wait_times = 100;
6158 while ((sequence > _curIspParamsSeq) && (wait_times-- > 0)) {
6159 usleep(10 * 1000);
6160 }
6161 if (wait_times == 0) {
6162 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "wait params %d(cur:%d) done over 1 seconds !", sequence, _curIspParamsSeq);
6163 } else {
6164 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "wait params %d(cur:%d) success !", sequence, _curIspParamsSeq);
6165 }
6166 }
6167
6168 return XCAM_RETURN_NO_ERROR;
6169 }
6170
6171 const char*
rawReproc_preInit(const char * isp_driver,const char * offline_sns_ent_name)6172 CamHwIsp20::rawReproc_preInit(const char* isp_driver, const char* offline_sns_ent_name)
6173 {
6174 XCamReturn ret = XCAM_RETURN_NO_ERROR;
6175 ENTER_XCORE_FUNCTION();
6176 int isp_driver_index = -1;
6177 if (!isp_driver) {
6178 return NULL;
6179 } else {
6180 #ifdef ISP_HW_V30
6181 char* isp_driver_name = const_cast<char*>(isp_driver);
6182 char *rkisp = strstr(isp_driver_name, "rkisp");
6183 if (rkisp) {
6184 int isp_mode = atoi(rkisp + strlen("rkisp"));
6185 char* vir = strstr(isp_driver_name, "vir");
6186 if (vir) {
6187 int vir_idx = atoi(vir + strlen("vir"));
6188 isp_driver_index = isp_mode * 4 + vir_idx;
6189 }
6190 }
6191 #else
6192
6193 if (strcmp(isp_driver, "rkisp0") == 0 ||
6194 strcmp(isp_driver, "rkisp") == 0)
6195 isp_driver_index = 0;
6196 else if (strcmp(isp_driver, "rkisp1") == 0)
6197 isp_driver_index = 1;
6198 else if (strcmp(isp_driver, "rkisp2") == 0)
6199 isp_driver_index = 2;
6200 else if (strcmp(isp_driver, "rkisp3") == 0)
6201 isp_driver_index = 3;
6202 else
6203 isp_driver_index = -1;
6204 #endif
6205 }
6206 std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t> >::iterator iter;
6207 std::unordered_map<std::string, SmartPtr<rk_aiq_static_info_t> >::iterator iter_info;
6208 for (iter = CamHwIsp20::mSensorHwInfos.begin(); \
6209 iter != CamHwIsp20::mSensorHwInfos.end(); iter++) {
6210 rk_sensor_full_info_t *s_full_info_f = iter->second.ptr();
6211 if (s_full_info_f->isp_info) {
6212 if (s_full_info_f->isp_info->model_idx != isp_driver_index) {
6213 continue;
6214 }
6215 rk_sensor_full_info_t *s_full_info = new rk_sensor_full_info_t;
6216 *s_full_info = *s_full_info_f;
6217 iter_info = CamHwIsp20::mCamHwInfos.find(iter->first);
6218 if (iter_info == CamHwIsp20::mCamHwInfos.end()) {
6219 continue;
6220 }
6221 rk_aiq_static_info_t *cam_hw_info_f = iter_info->second.ptr();
6222 rk_aiq_static_info_t *cam_hw_info = new rk_aiq_static_info_t;
6223 *cam_hw_info = *cam_hw_info_f;
6224 char sensor_name_real[64];
6225 if (!strstr(s_full_info->sensor_name.c_str(), offline_sns_ent_name)) {
6226 int module_index = 0;
6227 std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t> >::iterator sns_it;
6228 for (sns_it = CamHwIsp20::mSensorHwInfos.begin(); \
6229 sns_it != CamHwIsp20::mSensorHwInfos.end(); sns_it++) {
6230 rk_sensor_full_info_t *sns_full = sns_it->second.ptr();
6231 if (strstr(sns_full->sensor_name.c_str(), "_s_")) {
6232 int sns_index = atoi(sns_full->sensor_name.c_str() + 2);
6233 if (module_index <= sns_index) {
6234 module_index = sns_index + 1;
6235 }
6236 }
6237 }
6238 std::string tmp_sensor_name = s_full_info_f->sensor_name;
6239 s_full_info->phy_module_orient = 's';
6240 memset(sensor_name_real, 0, sizeof(sensor_name_real));
6241 sprintf(sensor_name_real, "%s%d%s%s%s", "m0", module_index, "_s_",
6242 offline_sns_ent_name,
6243 " 1-111a");
6244 std::string sns_fake_name = sensor_name_real;
6245 s_full_info->sensor_name = sns_fake_name;
6246 CamHwIsp20::mFakeCameraName[s_full_info->sensor_name] = tmp_sensor_name;
6247 CamHwIsp20::mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
6248 CamHwIsp20::mCamHwInfos[s_full_info->sensor_name] = cam_hw_info;
6249 CamHwIsp20::mSensorHwInfos.erase(tmp_sensor_name);
6250 CamHwIsp20::mCamHwInfos.erase(tmp_sensor_name);
6251 iter_info++;
6252 return s_full_info->sensor_name.c_str();
6253 } else {
6254 std::string tmp_sensor_name = s_full_info_f->sensor_name;
6255 s_full_info->phy_module_orient = 's';
6256 memset(sensor_name_real, 0, sizeof(sensor_name_real));
6257 sprintf(sensor_name_real, "%s%s%s%s", s_full_info->module_index_str.c_str(), "_s_",
6258 s_full_info->module_real_sensor_name.c_str(),
6259 " 1-111a");
6260 std::string sns_fake_name = sensor_name_real;
6261 s_full_info->sensor_name = sns_fake_name;
6262 CamHwIsp20::mFakeCameraName[s_full_info->sensor_name] = tmp_sensor_name;
6263 CamHwIsp20::mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
6264 CamHwIsp20::mCamHwInfos[s_full_info->sensor_name] = cam_hw_info;
6265 CamHwIsp20::mSensorHwInfos.erase(tmp_sensor_name);
6266 CamHwIsp20::mCamHwInfos.erase(tmp_sensor_name);
6267 iter_info++;
6268 return s_full_info->sensor_name.c_str();
6269 }
6270 }
6271 }
6272 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "offline preInit faile\n");
6273 return NULL;
6274 EXIT_XCORE_FUNCTION();
6275 }
6276
6277 XCamReturn
rawReproc_deInit(const char * fakeSensor)6278 CamHwIsp20::rawReproc_deInit(const char* fakeSensor)
6279 {
6280 XCamReturn ret = XCAM_RETURN_NO_ERROR;
6281 std::string fake_sns_name = std::string(fakeSensor);
6282 std::string real_sns_name = "";
6283 std::unordered_map<std::string, std::string>::iterator it_sns_name;
6284 it_sns_name = CamHwIsp20::mFakeCameraName.find(fake_sns_name);
6285 if (it_sns_name == CamHwIsp20::mFakeCameraName.end()) {
6286 return XCAM_RETURN_BYPASS;
6287 }
6288 real_sns_name = it_sns_name->second;
6289 std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t> >::iterator it;
6290 std::unordered_map<std::string, SmartPtr<rk_aiq_static_info_t> >::iterator it_info;
6291 it = CamHwIsp20::mSensorHwInfos.find(fake_sns_name);
6292 it_info = CamHwIsp20::mCamHwInfos.find(fake_sns_name);
6293 if (it != CamHwIsp20::mSensorHwInfos.end()) {
6294 rk_sensor_full_info_t *s_full_info_f = it->second.ptr();
6295 rk_sensor_full_info_t *s_full_info = new rk_sensor_full_info_t;
6296 *s_full_info = *s_full_info_f;
6297 s_full_info->sensor_name = real_sns_name;
6298 CamHwIsp20::mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
6299 CamHwIsp20::mSensorHwInfos.erase(it);
6300 }
6301 if (it_info != CamHwIsp20::mCamHwInfos.end()) {
6302 rk_aiq_static_info_t *cam_hw_info_f = it_info->second.ptr();
6303 rk_aiq_static_info_t *cam_hw_info = new rk_aiq_static_info_t;
6304 *cam_hw_info = *cam_hw_info_f;
6305 CamHwIsp20::mCamHwInfos[real_sns_name] = cam_hw_info;
6306 CamHwIsp20::mCamHwInfos.erase(it_info);
6307 }
6308 CamHwIsp20::mFakeCameraName.erase(it_sns_name);
6309 return ret;
6310 }
6311
6312 XCamReturn
rawReProc_prepare(uint32_t sequence,rk_aiq_frame_info_t * offline_finfo)6313 CamHwIsp20::rawReProc_prepare (uint32_t sequence, rk_aiq_frame_info_t *offline_finfo)
6314 {
6315 XCamReturn ret = XCAM_RETURN_NO_ERROR;
6316 SensorHw* mSensor = mSensorDev.get_cast_ptr<SensorHw>();
6317 ret = mSensor->set_offline_effecting_exp_map(sequence, &offline_finfo[0]);
6318 ret = mSensor->set_offline_effecting_exp_map(sequence + 1, &offline_finfo[1]);
6319 return ret;
6320 }
6321
6322 XCamReturn
setCifSclStartFlag(int ratio,bool mode)6323 CamHwIsp20::setCifSclStartFlag(int ratio, bool mode)
6324 {
6325 XCamReturn ret = XCAM_RETURN_NO_ERROR;
6326
6327 if (mode == mCifScaleStream->getIsActive())
6328 return ret;
6329
6330 auto it = mSensorHwInfos.find(sns_name);
6331 if ( it == mSensorHwInfos.end()) {
6332 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_name);
6333 return XCAM_RETURN_ERROR_SENSOR;
6334 }
6335 rk_sensor_full_info_t *s_info = it->second.ptr();
6336 ret = mCifScaleStream->restart(s_info, ratio, this, mode);
6337 return ret;
6338 }
6339
6340 } //namspace RkCam
6341