rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/external/camera_engine_rkaiq/hwi/isp20/CamHwIsp20.cpp

6378 lines
224 KiB
C++
Raw Blame History

/*
* Copyright (c) 2019 Rockchip Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include "CamHwIsp20.h"
#include "Isp20Evts.h"
#include "rk_isp20_hw.h"
#include "Isp20_module_dbg.h"
#include "mediactl/mediactl-priv.h"
#include <linux/v4l2-subdev.h>
#include <sys/mman.h>
#ifdef ANDROID_OS
#include <cutils/properties.h>
#endif
#include "SPStreamProcUnit.h"
#include "PdafStreamProcUnit.h"
#include "CaptureRawData.h"
#include "code_to_pixel_format.h"
#include "RkAiqCalibDbV2.h"
#include "IspParamsSplitter.h"
#include "rkisp21-config.h"
#include "rkisp3-config.h"
#include "rkisp32-config.h"
#include "isp3x/Isp3xParams.h"
namespace RkCam {
std::unordered_map<std::string, SmartPtr<rk_aiq_static_info_t>> CamHwIsp20::mCamHwInfos;
std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>> CamHwIsp20::mSensorHwInfos;
std::unordered_map<std::string, std::string> CamHwIsp20::mFakeCameraName;
rk_aiq_isp_hw_info_t CamHwIsp20::mIspHwInfos;
rk_aiq_cif_hw_info_t CamHwIsp20::mCifHwInfos;
bool CamHwIsp20::mIsMultiIspMode = false;
uint16_t CamHwIsp20::mMultiIspExtendedPixel = 0;
#ifdef ISP_HW_V30
#define CAMHWISP_EFFECT_ISP_POOL_NUM 12
#else
#define CAMHWISP_EFFECT_ISP_POOL_NUM 6
#endif
// TODO: Sync 1608 sensor start streaming
XCam::Mutex CamHwIsp20::_sync_1608_mutex;
bool CamHwIsp20::_sync_1608_done = false;
// TODO: Init static struct.
sensor_info_share_t CamHwIsp20::rk1608_share_inf{};
CamHwIsp20::CamHwIsp20()
: _hdr_mode(0)
, _state(CAM_HW_STATE_INVALID)
, _is_exit(false)
, _linked_to_isp(false)
, _linked_to_1608(false)
#if defined(ISP_HW_V20)
, _ispp_module_init_ens(0)
#endif
, _sharp_fbc_rotation(RK_AIQ_ROTATION_0)
{
mNoReadBack = false;
#ifndef ANDROID_OS
char* valueStr = getenv("normal_no_read_back");
if (valueStr) {
mNoReadBack = atoi(valueStr) > 0 ? true : false;
}
#else
char property_value[PROPERTY_VALUE_MAX] = {'\0'};
property_get("persist.vendor.rkisp_no_read_back", property_value, "-1");
int val = atoi(property_value);
if (val != -1)
mNoReadBack = atoi(property_value) > 0 ? true : false;
#endif
xcam_mem_clear(_fec_drv_mem_ctx);
xcam_mem_clear(_ldch_drv_mem_ctx);
xcam_mem_clear(_cac_drv_mem_ctx);
xcam_mem_clear(fec_mem_info_array);
xcam_mem_clear(ldch_mem_info_array);
xcam_mem_clear(cac_mem_info_array);
xcam_mem_clear(_dbg_drv_mem_ctx);
xcam_mem_clear(dbg_mem_info_array);
_fec_drv_mem_ctx.type = MEM_TYPE_FEC;
_fec_drv_mem_ctx.ops_ctx = this;
_fec_drv_mem_ctx.mem_info = (void*)(fec_mem_info_array);
_ldch_drv_mem_ctx.type = MEM_TYPE_LDCH;
_ldch_drv_mem_ctx.ops_ctx = this;
_ldch_drv_mem_ctx.mem_info = (void*)(ldch_mem_info_array);
_cac_drv_mem_ctx.type = MEM_TYPE_CAC;
_cac_drv_mem_ctx.ops_ctx = this;
_cac_drv_mem_ctx.mem_info = (void*)(cac_mem_info_array);
_dbg_drv_mem_ctx.type = MEM_TYPE_DBG_INFO;
_dbg_drv_mem_ctx.ops_ctx = this;
_dbg_drv_mem_ctx.mem_info = (void*)(dbg_mem_info_array);
xcam_mem_clear(_crop_rect);
#ifndef DISABLE_PARAMS_ASSEMBLER
mParamsAssembler = new IspParamsAssembler("ISP_PARAMS_ASSEMBLER");
#endif
mVicapIspPhyLinkSupported = false;
mIspStremEvtTh = NULL;
mIsGroupMode = false;
mIsMain = false;
_isp_stream_status = ISP_STREAM_STATUS_INVALID;
mEffectIspParamsPool = new RkAiqIspEffParamsPool("ISP_EFF", CAMHWISP_EFFECT_ISP_POOL_NUM);
_curIspParamsSeq = 0;
userSensorWidth = 0;
userSensorHeight = 0;
userSensorFmtCode = 0;
}
CamHwIsp20::~CamHwIsp20()
{}
static XCamReturn get_isp_ver(rk_aiq_isp_hw_info_t *hw_info) {
XCamReturn ret = XCAM_RETURN_NO_ERROR;
struct v4l2_capability cap;
V4l2Device vdev(hw_info->isp_info[0].stats_path);
ret = vdev.open();
if (ret != XCAM_RETURN_NO_ERROR) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to open dev (%s)", hw_info->isp_info[0].stats_path);
return XCAM_RETURN_ERROR_FAILED;
}
if (vdev.query_cap(cap) == XCAM_RETURN_NO_ERROR) {
char *p;
p = strrchr((char*)cap.driver, '_');
if (p == NULL) {
ret = XCAM_RETURN_ERROR_FAILED;
goto out;
}
if (*(p + 1) != 'v') {
ret = XCAM_RETURN_ERROR_FAILED;
goto out;
}
hw_info->hw_ver_info.isp_ver = atoi(p + 2);
//awb/aec version?
vdev.close();
return XCAM_RETURN_NO_ERROR;
} else {
ret = XCAM_RETURN_ERROR_FAILED;
goto out;
}
out:
vdev.close();
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get isp version failed !");
return ret;
}
static XCamReturn get_sensor_caps(rk_sensor_full_info_t *sensor_info) {
struct v4l2_subdev_frame_size_enum fsize_enum;
struct v4l2_subdev_mbus_code_enum code_enum;
rk_frame_fmt_t frameSize;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
V4l2SubDevice vdev(sensor_info->device_name.c_str());
ret = vdev.open();
if (ret != XCAM_RETURN_NO_ERROR) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to open dev (%s)", sensor_info->device_name.c_str());
return XCAM_RETURN_ERROR_FAILED;
}
//get module info
struct rkmodule_inf *minfo = &(sensor_info->mod_info);
if(vdev.io_control(RKMODULE_GET_MODULE_INFO, minfo) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "@%s %s: Get sensor module info failed", __FUNCTION__, sensor_info->device_name.c_str());
return XCAM_RETURN_ERROR_FAILED;
}
sensor_info->len_name = std::string(minfo->base.lens);
#if 0
std::vector<uint32_t> formats;
memset(&code_enum, 0, sizeof(code_enum));
while (vdev.io_control(VIDIOC_SUBDEV_ENUM_MBUS_CODE, &code_enum) == 0) {
formats.push_back(code_enum.code);
code_enum.index++;
};
//TODO: sensor driver not supported now
for (auto it = formats.begin(); it != formats.end(); ++it) {
fsize_enum.pad = 0;
fsize_enum.index = 0;
fsize_enum.code = *it;
while (vdev.io_control(VIDIOC_SUBDEV_ENUM_FRAME_SIZE, &fsize_enum) == 0) {
frameSize.format = (rk_aiq_format_t)fsize_enum.code;
frameSize.width = fsize_enum.max_width;
frameSize.height = fsize_enum.max_height;
sensor_info->frame_size.push_back(frameSize);
fsize_enum.index++;
};
}
if(!formats.size() || !sensor_info->frame_size.size()) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "@%s %s: Enum sensor frame size failed", __FUNCTION__, sensor_info->device_name.c_str());
ret = XCAM_RETURN_ERROR_FAILED;
}
#endif
struct v4l2_subdev_frame_interval_enum fie;
memset(&fie, 0, sizeof(fie));
while(vdev.io_control(VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL, &fie) == 0) {
frameSize.format = (rk_aiq_format_t)fie.code;
frameSize.width = fie.width;
frameSize.height = fie.height;
frameSize.fps = fie.interval.denominator / fie.interval.numerator;
frameSize.hdr_mode = fie.reserved[0];
sensor_info->frame_size.push_back(frameSize);
fie.index++;
}
if (fie.index == 0) {
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "@%s %s: Enum sensor frame interval failed", __FUNCTION__, sensor_info->device_name.c_str());
}
vdev.close();
return ret;
}
static XCamReturn
parse_module_info(rk_sensor_full_info_t *sensor_info)
{
// sensor entity name format SHOULD be like this:
// m00_b_ov13850 1-0010
std::string entity_name(sensor_info->sensor_name);
if (entity_name.empty())
return XCAM_RETURN_ERROR_SENSOR;
int parse_index = 0;
if (entity_name.at(parse_index) != 'm') {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%d:parse sensor entity name %s error at %d, please check sensor driver !",
__LINE__, entity_name.c_str(), parse_index);
return XCAM_RETURN_ERROR_SENSOR;
}
std::string index_str = entity_name.substr (parse_index, 3);
sensor_info->module_index_str = index_str;
parse_index += 3;
if (entity_name.at(parse_index) != '_') {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%d:parse sensor entity name %s error at %d, please check sensor driver !",
__LINE__, entity_name.c_str(), parse_index);
return XCAM_RETURN_ERROR_SENSOR;
}
parse_index++;
if (entity_name.at(parse_index) != 'b' &&
entity_name.at(parse_index) != 'f') {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%d:parse sensor entity name %s error at %d, please check sensor driver !",
__LINE__, entity_name.c_str(), parse_index);
return XCAM_RETURN_ERROR_SENSOR;
}
sensor_info->phy_module_orient = entity_name.at(parse_index);
parse_index++;
if (entity_name.at(parse_index) != '_') {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%d:parse sensor entity name %s error at %d, please check sensor driver !",
__LINE__, entity_name.c_str(), parse_index);
return XCAM_RETURN_ERROR_SENSOR;
}
parse_index++;
std::size_t real_name_end = std::string::npos;
if ((real_name_end = entity_name.find(' ')) == std::string::npos) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%d:parse sensor entity name %s error at %d, please check sensor driver !",
__LINE__, entity_name.c_str(), parse_index);
return XCAM_RETURN_ERROR_SENSOR;
}
std::string real_name_str = entity_name.substr(parse_index, real_name_end - parse_index);
sensor_info->module_real_sensor_name = real_name_str;
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s:%d, real sensor name %s, module ori %c, module id %s",
__FUNCTION__, __LINE__, sensor_info->module_real_sensor_name.c_str(),
sensor_info->phy_module_orient, sensor_info->module_index_str.c_str());
return XCAM_RETURN_NO_ERROR;
}
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-truncation"
#endif
#if defined(ISP_HW_V20)
static rk_aiq_ispp_t*
get_ispp_subdevs(struct media_device *device, const char *devpath, rk_aiq_ispp_t* ispp_info)
{
media_entity *entity = NULL;
const char *entity_name = NULL;
int index = 0;
if(!device || !ispp_info || !devpath)
return NULL;
for(index = 0; index < MAX_CAM_NUM; index++) {
if (0 == strlen(ispp_info[index].media_dev_path))
break;
if (0 == strncmp(ispp_info[index].media_dev_path, devpath, sizeof(ispp_info[index].media_dev_path))) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp info of path %s exists!", devpath);
return &ispp_info[index];
}
}
if (index >= MAX_CAM_NUM)
return NULL;
#if defined(ISP_HW_V30)
// parse driver pattern: soc:rkisp0-vir0
int model_idx = -1;
char* rkispp = strstr(device->info.driver, "rkispp");
if (rkispp) {
int ispp_idx = atoi(rkispp + strlen("rkispp"));
char* vir = strstr(device->info.driver, "vir");
if (vir) {
int vir_idx = atoi(vir + strlen("vir"));
model_idx = ispp_idx * 4 + vir_idx;
}
}
if (model_idx == -1) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "wrong ispp media driver info: %s", device->info.driver);
return NULL;
}
ispp_info[index].model_idx = model_idx;
#else
if (strcmp(device->info.model, "rkispp0") == 0 ||
strcmp(device->info.model, "rkispp") == 0)
ispp_info[index].model_idx = 0;
else if (strcmp(device->info.model, "rkispp1") == 0)
ispp_info[index].model_idx = 1;
else if (strcmp(device->info.model, "rkispp2") == 0)
ispp_info[index].model_idx = 2;
else if (strcmp(device->info.model, "rkispp3") == 0)
ispp_info[index].model_idx = 3;
else
ispp_info[index].model_idx = -1;
#endif
strncpy(ispp_info[index].media_dev_path, devpath, sizeof(ispp_info[index].media_dev_path));
entity = media_get_entity_by_name(device, "rkispp_input_image", strlen("rkispp_input_image"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_input_image_path, entity_name, sizeof(ispp_info[index].pp_input_image_path));
}
}
entity = media_get_entity_by_name(device, "rkispp_m_bypass", strlen("rkispp_m_bypass"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_m_bypass_path, entity_name, sizeof(ispp_info[index].pp_m_bypass_path));
}
}
entity = media_get_entity_by_name(device, "rkispp_scale0", strlen("rkispp_scale0"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_scale0_path, entity_name, sizeof(ispp_info[index].pp_scale0_path));
}
}
entity = media_get_entity_by_name(device, "rkispp_scale1", strlen("rkispp_scale1"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_scale1_path, entity_name, sizeof(ispp_info[index].pp_scale1_path));
}
}
entity = media_get_entity_by_name(device, "rkispp_scale2", strlen("rkispp_scale2"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_scale2_path, entity_name, sizeof(ispp_info[index].pp_scale2_path));
}
}
entity = media_get_entity_by_name(device, "rkispp_tnr_params", strlen("rkispp_tnr_params"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_tnr_params_path, entity_name, sizeof(ispp_info[index].pp_tnr_params_path));
}
}
entity = media_get_entity_by_name(device, "rkispp_tnr_stats", strlen("rkispp_tnr_stats"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_tnr_stats_path, entity_name, sizeof(ispp_info[index].pp_tnr_stats_path));
}
}
entity = media_get_entity_by_name(device, "rkispp_nr_params", strlen("rkispp_nr_params"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_nr_params_path, entity_name, sizeof(ispp_info[index].pp_nr_params_path));
}
}
entity = media_get_entity_by_name(device, "rkispp_nr_stats", strlen("rkispp_nr_stats"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_nr_stats_path, entity_name, sizeof(ispp_info[index].pp_nr_stats_path));
}
}
entity = media_get_entity_by_name(device, "rkispp_fec_params", strlen("rkispp_fec_params"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_fec_params_path, entity_name, sizeof(ispp_info[index].pp_fec_params_path));
}
}
entity = media_get_entity_by_name(device, "rkispp-subdev", strlen("rkispp-subdev"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(ispp_info[index].pp_dev_path, entity_name, sizeof(ispp_info[index].pp_dev_path));
}
}
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "model(%s): ispp_info(%d): ispp-subdev entity name: %s\n",
device->info.model, index,
ispp_info[index].pp_dev_path);
return &ispp_info[index];
}
#endif
static rk_aiq_isp_t*
get_isp_subdevs(struct media_device *device, const char *devpath, rk_aiq_isp_t* isp_info)
{
media_entity *entity = NULL;
const char *entity_name = NULL;
int index = 0;
if(!device || !isp_info || !devpath)
return NULL;
for(index = 0; index < MAX_CAM_NUM; index++) {
if (0 == strlen(isp_info[index].media_dev_path)) {
isp_info[index].logic_id = index;
break;
}
if (0 == strncmp(isp_info[index].media_dev_path, devpath, sizeof(isp_info[index].media_dev_path))) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp info of path %s exists!", devpath);
return &isp_info[index];
}
}
if (index >= MAX_CAM_NUM)
return NULL;
#if defined(ISP_HW_V30)
// parse driver pattern: soc:rkisp0-vir0
int model_idx = -1;
char* rkisp = strstr(device->info.driver, "rkisp");
if (rkisp) {
char* str_unite = NULL;
str_unite = strstr(device->info.driver, "unite");
if (str_unite) {
model_idx = 0;
} else {
int isp_idx = atoi(rkisp + strlen("rkisp"));
char* vir = strstr(device->info.driver, "vir");
if (vir) {
int vir_idx = atoi(vir + strlen("vir"));
model_idx = isp_idx * 4 + vir_idx;
isp_info[index].phy_id = isp_idx;
}
}
}
if (model_idx == -1) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "wrong isp media driver info: %s", device->info.driver);
return NULL;
}
isp_info[index].model_idx = model_idx;
#else
if (strcmp(device->info.model, "rkisp0") == 0 ||
strcmp(device->info.model, "rkisp") == 0)
isp_info[index].model_idx = 0;
else if (strcmp(device->info.model, "rkisp1") == 0)
isp_info[index].model_idx = 1;
else if (strcmp(device->info.model, "rkisp2") == 0)
isp_info[index].model_idx = 2;
else if (strcmp(device->info.model, "rkisp3") == 0)
isp_info[index].model_idx = 3;
else
isp_info[index].model_idx = -1;
#endif
strncpy(isp_info[index].media_dev_path, devpath, sizeof(isp_info[index].media_dev_path));
entity = media_get_entity_by_name(device, "rkisp-isp-subdev", strlen("rkisp-isp-subdev"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].isp_dev_path, entity_name, sizeof(isp_info[index].isp_dev_path));
}
}
entity = media_get_entity_by_name(device, "rkisp-csi-subdev", strlen("rkisp-csi-subdev"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].csi_dev_path, entity_name, sizeof(isp_info[index].csi_dev_path));
}
}
entity = media_get_entity_by_name(device, "rkisp-mpfbc-subdev", strlen("rkisp-mpfbc-subdev"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].mpfbc_dev_path, entity_name, sizeof(isp_info[index].mpfbc_dev_path));
}
}
entity = media_get_entity_by_name(device, "rkisp_mainpath", strlen("rkisp_mainpath"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].main_path, entity_name, sizeof(isp_info[index].main_path));
}
}
entity = media_get_entity_by_name(device, "rkisp_selfpath", strlen("rkisp_selfpath"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].self_path, entity_name, sizeof(isp_info[index].self_path));
}
}
entity = media_get_entity_by_name(device, "rkisp_rawwr0", strlen("rkisp_rawwr0"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].rawwr0_path, entity_name, sizeof(isp_info[index].rawwr0_path));
}
}
entity = media_get_entity_by_name(device, "rkisp_rawwr1", strlen("rkisp_rawwr1"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].rawwr1_path, entity_name, sizeof(isp_info[index].rawwr1_path));
}
}
entity = media_get_entity_by_name(device, "rkisp_rawwr2", strlen("rkisp_rawwr2"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].rawwr2_path, entity_name, sizeof(isp_info[index].rawwr2_path));
}
}
entity = media_get_entity_by_name(device, "rkisp_rawwr3", strlen("rkisp_rawwr3"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].rawwr3_path, entity_name, sizeof(isp_info[index].rawwr3_path));
}
}
entity = media_get_entity_by_name(device, "rkisp_dmapath", strlen("rkisp_dmapath"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].dma_path, entity_name, sizeof(isp_info[index].dma_path));
}
}
entity = media_get_entity_by_name(device, "rkisp_rawrd0_m", strlen("rkisp_rawrd0_m"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].rawrd0_m_path, entity_name, sizeof(isp_info[index].rawrd0_m_path));
}
}
entity = media_get_entity_by_name(device, "rkisp_rawrd1_l", strlen("rkisp_rawrd1_l"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].rawrd1_l_path, entity_name, sizeof(isp_info[index].rawrd1_l_path));
}
}
entity = media_get_entity_by_name(device, "rkisp_rawrd2_s", strlen("rkisp_rawrd2_s"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].rawrd2_s_path, entity_name, sizeof(isp_info[index].rawrd2_s_path));
}
}
entity = media_get_entity_by_name(device, "rkisp-statistics", strlen("rkisp-statistics"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].stats_path, entity_name, sizeof(isp_info[index].stats_path));
}
}
entity = media_get_entity_by_name(device, "rkisp-input-params", strlen("rkisp-input-params"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].input_params_path, entity_name, sizeof(isp_info[index].input_params_path));
}
}
entity = media_get_entity_by_name(device, "rkisp-mipi-luma", strlen("rkisp-mipi-luma"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].mipi_luma_path, entity_name, sizeof(isp_info[index].mipi_luma_path));
}
}
entity = media_get_entity_by_name(device, "rockchip-mipi-dphy-rx", strlen("rockchip-mipi-dphy-rx"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].mipi_dphy_rx_path, entity_name, sizeof(isp_info[index].mipi_dphy_rx_path));
}
} else {
entity = media_get_entity_by_name(device, "rockchip-csi2-dphy0", strlen("rockchip-csi2-dphy0"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(isp_info[index].mipi_dphy_rx_path, entity_name, sizeof(isp_info[index].mipi_dphy_rx_path));
}
}
}
entity = media_get_entity_by_name(device, "rkcif_dvp", strlen("rkcif_dvp"));
if(entity)
isp_info[index].linked_dvp = true;
else
isp_info[index].linked_dvp = false;
entity = media_get_entity_by_name(device, "rkcif-dvp", strlen("rkcif-dvp"));
if(entity)
isp_info[index].linked_dvp = true;
else
isp_info[index].linked_dvp = false;
const char* linked_entity_name_strs[] = {
"rkcif-dvp",
"rkcif_dvp",
"rkcif_lite_mipi_lvds",
"rkcif_mipi_lvds",
"rkcif_mipi_lvds1",
"rkcif_mipi_lvds2",
"rkcif_mipi_lvds3",
"rkcif_mipi_lvds4",
"rkcif_mipi_lvds5",
"rkcif-mipi-lvds",
"rkcif-mipi-lvds1",
"rkcif-mipi-lvds2",
"rkcif-mipi-lvds3",
"rkcif-mipi-lvds4",
"rkcif-mipi-lvds5",
NULL
};
int vicap_idx = 0;
for (int i = 0; linked_entity_name_strs[i] != NULL; i++) {
entity = media_get_entity_by_name(device, linked_entity_name_strs[i], strlen(linked_entity_name_strs[i]));
if (entity) {
strncpy(isp_info[index].linked_vicap[vicap_idx], entity->info.name, sizeof(isp_info[index].linked_vicap[vicap_idx]));
isp_info[index].linked_sensor = true;
if (vicap_idx++ >= MAX_ISP_LINKED_VICAP_CNT) {
break;
}
}
}
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "model(%s): isp_info(%d): ispp-subdev entity name: %s\n",
device->info.model, index,
isp_info[index].isp_dev_path);
return &isp_info[index];
}
static rk_aiq_cif_info_t*
get_cif_subdevs(struct media_device *device, const char *devpath, rk_aiq_cif_info_t* cif_info)
{
media_entity *entity = NULL;
const char *entity_name = NULL;
int index = 0;
if(!device || !devpath || !cif_info)
return NULL;
for(index = 0; index < MAX_CAM_NUM; index++) {
if (0 == strlen(cif_info[index].media_dev_path))
break;
if (0 == strncmp(cif_info[index].media_dev_path, devpath, sizeof(cif_info[index].media_dev_path))) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp info of path %s exists!", devpath);
return &cif_info[index];
}
}
if (index >= MAX_CAM_NUM)
return NULL;
cif_info[index].model_idx = index;
strncpy(cif_info[index].media_dev_path, devpath, sizeof(cif_info[index].media_dev_path) - 1);
entity = media_get_entity_by_name(device, "stream_cif_mipi_id0", strlen("stream_cif_mipi_id0"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_id0, entity_name, sizeof(cif_info[index].mipi_id0) - 1);
}
}
entity = media_get_entity_by_name(device, "stream_cif_mipi_id1", strlen("stream_cif_mipi_id1"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_id1, entity_name, sizeof(cif_info[index].mipi_id1) - 1);
}
}
entity = media_get_entity_by_name(device, "stream_cif_mipi_id2", strlen("stream_cif_mipi_id2"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_id2, entity_name, sizeof(cif_info[index].mipi_id2) - 1);
}
}
entity = media_get_entity_by_name(device, "stream_cif_mipi_id3", strlen("stream_cif_mipi_id3"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_id3, entity_name, sizeof(cif_info[index].mipi_id3) - 1);
}
}
entity = media_get_entity_by_name(device, "rkcif_scale_ch0", strlen("rkcif_scale_ch0"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_scl0, entity_name, sizeof(cif_info[index].mipi_scl0) - 1);
}
}
entity = media_get_entity_by_name(device, "rkcif_scale_ch1", strlen("rkcif_scale_ch1"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_scl1, entity_name, sizeof(cif_info[index].mipi_scl1) - 1);
}
}
entity = media_get_entity_by_name(device, "rkcif_scale_ch2", strlen("rkcif_scale_ch2"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_scl2, entity_name, sizeof(cif_info[index].mipi_scl2) - 1);
}
}
entity = media_get_entity_by_name(device, "rkcif_scale_ch3", strlen("rkcif_scale_ch3"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_scl3, entity_name, sizeof(cif_info[index].mipi_scl3) - 1);
}
}
entity = media_get_entity_by_name(device, "stream_cif_dvp_id0", strlen("stream_cif_dvp_id0"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].dvp_id0, entity_name, sizeof(cif_info[index].dvp_id0) - 1);
}
}
entity = media_get_entity_by_name(device, "stream_cif_dvp_id1", strlen("stream_cif_dvp_id1"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].dvp_id1, entity_name, sizeof(cif_info[index].dvp_id1) - 1);
}
}
entity = media_get_entity_by_name(device, "stream_cif_dvp_id2", strlen("stream_cif_dvp_id2"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].dvp_id2, entity_name, sizeof(cif_info[index].dvp_id2) - 1);
}
}
entity = media_get_entity_by_name(device, "stream_cif_dvp_id3", strlen("stream_cif_dvp_id3"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].dvp_id3, entity_name, sizeof(cif_info[index].dvp_id3) - 1);
}
}
entity = media_get_entity_by_name(device, "rkcif-mipi-luma", strlen("rkisp-mipi-luma"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_luma_path, entity_name, sizeof(cif_info[index].mipi_luma_path) - 1);
}
}
entity = media_get_entity_by_name(device, "rockchip-mipi-csi2", strlen("rockchip-mipi-csi2"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_csi2_sd_path, entity_name, sizeof(cif_info[index].mipi_csi2_sd_path) - 1);
}
}
entity = media_get_entity_by_name(device, "rkcif-lvds-subdev", strlen("rkcif-lvds-subdev"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].lvds_sd_path, entity_name, sizeof(cif_info[index].lvds_sd_path) - 1);
}
}
entity = media_get_entity_by_name(device, "rkcif-lite-lvds-subdev", strlen("rkcif-lite-lvds-subdev"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].lvds_sd_path, entity_name, sizeof(cif_info[index].lvds_sd_path) - 1);
}
}
entity = media_get_entity_by_name(device, "rockchip-mipi-dphy-rx", strlen("rockchip-mipi-dphy-rx"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_dphy_rx_path, entity_name, sizeof(cif_info[index].mipi_dphy_rx_path) - 1);
}
} else {
entity = media_get_entity_by_name(device, "rockchip-csi2-dphy0", strlen("rockchip-csi2-dphy0"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].mipi_dphy_rx_path, entity_name, sizeof(cif_info[index].mipi_dphy_rx_path) - 1);
}
}
}
entity = media_get_entity_by_name(device, "stream_cif", strlen("stream_cif"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].stream_cif_path, entity_name, sizeof(cif_info[index].stream_cif_path) - 1);
}
}
entity = media_get_entity_by_name(device, "rkcif-dvp-sof", strlen("rkcif-dvp-sof"));
if(entity) {
entity_name = media_entity_get_devname (entity);
if(entity_name) {
strncpy(cif_info[index].dvp_sof_sd_path, entity_name, sizeof(cif_info[index].dvp_sof_sd_path) - 1);
}
}
return &cif_info[index];
}
static
XCamReturn
SensorInfoCopy(rk_sensor_full_info_t *finfo, rk_aiq_static_info_t *info) {
int fs_num, i = 0;
rk_aiq_sensor_info_t *sinfo = NULL;
//info->media_node_index = finfo->media_node_index;
strncpy(info->lens_info.len_name, finfo->len_name.c_str(), sizeof(info->lens_info.len_name));
sinfo = &info->sensor_info;
strncpy(sinfo->sensor_name, finfo->sensor_name.c_str(), sizeof(sinfo->sensor_name));
fs_num = finfo->frame_size.size();
if (fs_num) {
for (auto iter = finfo->frame_size.begin(); iter != finfo->frame_size.end() && i < 10; ++iter, i++) {
sinfo->support_fmt[i].width = (*iter).width;
sinfo->support_fmt[i].height = (*iter).height;
sinfo->support_fmt[i].format = (*iter).format;
sinfo->support_fmt[i].fps = (*iter).fps;
sinfo->support_fmt[i].hdr_mode = (*iter).hdr_mode;
}
sinfo->num = i;
}
if (finfo->module_index_str.size()) {
sinfo->phyId = atoi(finfo->module_index_str.c_str() + 1);
} else {
sinfo->phyId = -1;
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CamHwIsp20::selectIqFile(const char* sns_ent_name, char* iqfile_name)
{
if (!sns_ent_name || !iqfile_name)
return XCAM_RETURN_ERROR_SENSOR;
const struct rkmodule_base_inf* base_inf = NULL;
const char *sensor_name, *module_name, *lens_name;
char sensor_name_full[32];
std::string str(sns_ent_name);
auto it = CamHwIsp20::mSensorHwInfos.find(str);
if (it == CamHwIsp20::mSensorHwInfos.end()) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_ent_name);
return XCAM_RETURN_ERROR_SENSOR;
}
base_inf = &(it->second.ptr()->mod_info.base);
if (!strlen(base_inf->module) || !strlen(base_inf->sensor) ||
!strlen(base_inf->lens)) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "no camera module info, check the drv !");
return XCAM_RETURN_ERROR_SENSOR;
}
sensor_name = base_inf->sensor;
strncpy(sensor_name_full, sensor_name, 32);
module_name = base_inf->module;
lens_name = base_inf->lens;
if (strlen(module_name) && strlen(lens_name)) {
sprintf(iqfile_name, "%s_%s_%s.json",
sensor_name_full, module_name, lens_name);
} else {
sprintf(iqfile_name, "%s.json", sensor_name_full);
}
return XCAM_RETURN_NO_ERROR;
}
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
rk_aiq_static_info_t*
CamHwIsp20::getStaticCamHwInfoByPhyId(const char* sns_ent_name, uint16_t index)
{
if (sns_ent_name) {
std::string str(sns_ent_name);
auto it = mCamHwInfos.find(str);
if (it != mCamHwInfos.end()) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "find camerainfo of %s!", sns_ent_name);
return it->second.ptr();
} else {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "camerainfo of %s not fount!", sns_ent_name);
}
} else {
std::string index_str{"m"};
if (index < 10) {
index_str.append("0");
}
index_str.append(std::to_string(index));
auto it = std::find_if(
std::begin(mCamHwInfos), std::end(mCamHwInfos),
[&](const std::pair<std::string, SmartPtr<rk_aiq_static_info_t>>& info) -> bool {
return !info.first.compare(0, 3, index_str);
});
if (it != mCamHwInfos.end()) {
return it->second.ptr();
}
}
return NULL;
}
rk_aiq_static_info_t*
CamHwIsp20::getStaticCamHwInfo(const char* sns_ent_name, uint16_t index)
{
if (sns_ent_name) {
std::string str(sns_ent_name);
auto it = mCamHwInfos.find(str);
if (it != mCamHwInfos.end()) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "find camerainfo of %s!", sns_ent_name);
return it->second.ptr();
} else {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "camerainfo of %s not fount!", sns_ent_name);
}
} else {
if (index < mCamHwInfos.size()) {
int i = 0;
for (auto it = mCamHwInfos.begin(); it != mCamHwInfos.end(); it++, i++) {
if (i == index)
return it->second.ptr();
}
}
}
return NULL;
}
XCamReturn
CamHwIsp20::clearStaticCamHwInfo()
{
/* std::map<std::string, SmartPtr<rk_aiq_static_info_t>>::iterator it1; */
/* std::map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it2; */
/* for (it1 = mCamHwInfos.begin(); it1 != mCamHwInfos.end(); it1++) { */
/* rk_aiq_static_info_t *ptr = it1->second.ptr(); */
/* delete ptr; */
/* } */
/* for (it2 = mSensorHwInfos.begin(); it2 != mSensorHwInfos.end(); it2++) { */
/* rk_sensor_full_info_t *ptr = it2->second.ptr(); */
/* delete ptr; */
/* } */
mCamHwInfos.clear();
mSensorHwInfos.clear();
return XCAM_RETURN_NO_ERROR;
}
void
CamHwIsp20::findAttachedSubdevs(struct media_device *device, uint32_t count, rk_sensor_full_info_t *s_info)
{
const struct media_entity_desc *entity_info = NULL;
struct media_entity *entity = NULL;
uint32_t k;
for (k = 0; k < count; ++k) {
entity = media_get_entity (device, k);
entity_info = media_entity_get_info(entity);
if ((NULL != entity_info) && (entity_info->type == MEDIA_ENT_T_V4L2_SUBDEV_LENS)) {
if ((entity_info->name[0] == 'm') &&
(strncmp(entity_info->name, s_info->module_index_str.c_str(), 3) == 0)) {
if (entity_info->flags == 1)
s_info->module_ircut_dev_name = std::string(media_entity_get_devname(entity));
else//vcm
s_info->module_lens_dev_name = std::string(media_entity_get_devname(entity));
}
} else if ((NULL != entity_info) && (entity_info->type == MEDIA_ENT_T_V4L2_SUBDEV_FLASH)) {
if ((entity_info->name[0] == 'm') &&
(strncmp(entity_info->name, s_info->module_index_str.c_str(), 3) == 0)) {
/* check if entity name has the format string mxx_x_xxx-irxxx */
if (strstr(entity_info->name, "-ir") != NULL) {
s_info->module_flash_ir_dev_name[s_info->flash_ir_num++] =
std::string(media_entity_get_devname(entity));
} else
s_info->module_flash_dev_name[s_info->flash_num++] =
std::string(media_entity_get_devname(entity));
}
}
}
// query flash infos
if (s_info->flash_num) {
SmartPtr<FlashLightHw> fl = new FlashLightHw(s_info->module_flash_dev_name, s_info->flash_num);
fl->init(1);
s_info->fl_strth_adj_sup = fl->isStrengthAdj();
fl->deinit();
}
if (s_info->flash_ir_num) {
SmartPtr<FlashLightHw> fl_ir = new FlashLightHw(s_info->module_flash_ir_dev_name, s_info->flash_ir_num);
fl_ir->init(1);
s_info->fl_ir_strth_adj_sup = fl_ir->isStrengthAdj();
fl_ir->deinit();
}
}
XCamReturn
CamHwIsp20::initCamHwInfos()
{
char sys_path[64], devpath[32];
FILE *fp = NULL;
struct media_device *device = NULL;
int nents, j = 0, i = 0, node_index = 0;
const struct media_entity_desc *entity_info = NULL;
struct media_entity *entity = NULL;
xcam_mem_clear (CamHwIsp20::mIspHwInfos);
xcam_mem_clear (CamHwIsp20::mCifHwInfos);
while (i < MAX_MEDIA_INDEX) {
node_index = i;
snprintf (sys_path, 64, "/dev/media%d", i++);
fp = fopen (sys_path, "r");
if (!fp)
continue;
fclose (fp);
device = media_device_new (sys_path);
if (!device) {
continue;
}
/* Enumerate entities, pads and links. */
media_device_enumerate (device);
rk_aiq_isp_t* isp_info = NULL;
rk_aiq_cif_info_t* cif_info = NULL;
bool dvp_itf = false;
if (strcmp(device->info.model, "rkispp0") == 0 ||
strcmp(device->info.model, "rkispp1") == 0 ||
strcmp(device->info.model, "rkispp2") == 0 ||
strcmp(device->info.model, "rkispp3") == 0 ||
strcmp(device->info.model, "rkispp") == 0) {
#if defined(ISP_HW_V20)
rk_aiq_ispp_t* ispp_info = get_ispp_subdevs(device, sys_path, CamHwIsp20::mIspHwInfos.ispp_info);
if (ispp_info)
ispp_info->valid = true;
#endif
goto media_unref;
} else if (strcmp(device->info.model, "rkisp0") == 0 ||
strcmp(device->info.model, "rkisp1") == 0 ||
strcmp(device->info.model, "rkisp2") == 0 ||
strcmp(device->info.model, "rkisp3") == 0 ||
strcmp(device->info.model, "rkisp") == 0) {
isp_info = get_isp_subdevs(device, sys_path, CamHwIsp20::mIspHwInfos.isp_info);
if (strstr(device->info.driver, "rkisp-unite")) {
isp_info->is_multi_isp_mode = true;
mIsMultiIspMode = true;
mMultiIspExtendedPixel = RKMOUDLE_UNITE_EXTEND_PIXEL;
} else {
isp_info->is_multi_isp_mode = false;
mIsMultiIspMode = false;
mMultiIspExtendedPixel = 0;
}
isp_info->valid = true;
} else if (strcmp(device->info.model, "rkcif") == 0 ||
strcmp(device->info.model, "rkcif-dvp") == 0 ||
strcmp(device->info.model, "rkcif_dvp") == 0 ||
strstr(device->info.model, "rkcif_mipi_lvds") ||
strstr(device->info.model, "rkcif-mipi-lvds") ||
strcmp(device->info.model, "rkcif_lite_mipi_lvds") == 0) {
cif_info = get_cif_subdevs(device, sys_path, CamHwIsp20::mCifHwInfos.cif_info);
strncpy(cif_info->model_str, device->info.model, sizeof(cif_info->model_str));
if (strcmp(device->info.model, "rkcif_dvp") == 0 || strcmp(device->info.model, "rkcif-dvp") == 0)
dvp_itf = true;
} else {
goto media_unref;
}
nents = media_get_entities_count (device);
for (j = 0; j < nents; ++j) {
entity = media_get_entity (device, j);
entity_info = media_entity_get_info(entity);
if ((NULL != entity_info) && (entity_info->type == MEDIA_ENT_T_V4L2_SUBDEV_SENSOR)) {
if (strstr(entity_info->name, "1608")) {
// [baron] skip psy-sensor(m_09_RK1608Dphy), save cif inf addr.
if (cif_info) {
CamHwIsp20::rk1608_share_inf.reference_mipi_cif = cif_info;
}
continue;
}
rk_aiq_static_info_t *info = new rk_aiq_static_info_t();
rk_sensor_full_info_t *s_full_info = new rk_sensor_full_info_t();
s_full_info->media_node_index = node_index;
strncpy(devpath, media_entity_get_devname(entity), sizeof(devpath) - 1);
devpath[sizeof(devpath) - 1] = '\0';
s_full_info->device_name = std::string(devpath);
s_full_info->sensor_name = std::string(entity_info->name);
s_full_info->parent_media_dev = std::string(sys_path);
parse_module_info(s_full_info);
get_sensor_caps(s_full_info);
if (cif_info) {
s_full_info->linked_to_isp = false;
s_full_info->cif_info = cif_info;
s_full_info->isp_info = NULL;
s_full_info->dvp_itf = dvp_itf;
// [baron] add flag for 1608 sensor
s_full_info->linked_to_1608 = false;
info->_is_1608_sensor = false;
} else if (isp_info) {
s_full_info->linked_to_isp = true;
isp_info->linked_sensor = true;
isp_info->isMultiplex = false;
s_full_info->isp_info = isp_info;
#if defined(ISP_HW_V30)
// FIXME: Just support isp3x(rk3588-8/9camera).
for (int vi_idx = 0; vi_idx < MAX_ISP_LINKED_VICAP_CNT; vi_idx++) {
if (strlen(isp_info->linked_vicap[vi_idx]) > 0) {
strcpy(CamHwIsp20::rk1608_share_inf.reference_name, isp_info->linked_vicap[vi_idx]);
s_full_info->cif_info = CamHwIsp20::rk1608_share_inf.reference_mipi_cif;
info->_is_1608_sensor = true;
s_full_info->linked_to_1608 = true;
}
}
#endif
} else {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "sensor device mount error!\n");
}
#if 0
printf(" >>>>>>>>> sensor(%s): cif addr(%p), link_to_1608[%d], share_vi(%s)\n",
entity_info->name,
s_full_info->cif_info,
s_full_info->linked_to_1608,
CamHwIsp20::rk1608_share_inf.reference_name
);
#endif
findAttachedSubdevs(device, nents, s_full_info);
SensorInfoCopy(s_full_info, info);
info->has_lens_vcm = s_full_info->module_lens_dev_name.empty() ? false : true;
info->has_fl = s_full_info->flash_num > 0 ? true : false;
info->has_irc = s_full_info->module_ircut_dev_name.empty() ? false : true;
info->fl_strth_adj_sup = s_full_info->fl_ir_strth_adj_sup;
info->fl_ir_strth_adj_sup = s_full_info->fl_ir_strth_adj_sup;
if (s_full_info->isp_info)
info->is_multi_isp_mode = s_full_info->isp_info->is_multi_isp_mode;
info->multi_isp_extended_pixel = mMultiIspExtendedPixel;
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "Init sensor %s with Multi-ISP Mode:%d Extended Pixels:%d ",
s_full_info->sensor_name.c_str(), info->is_multi_isp_mode,
info->multi_isp_extended_pixel);
CamHwIsp20::mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
CamHwIsp20::mCamHwInfos[s_full_info->sensor_name] = info;
}
}
media_unref:
media_device_unref (device);
}
#if defined(ISP_HW_V30)
// judge isp if multiplex by multiple cams
rk_aiq_isp_t* isp_info = NULL;
for (i = 0; i < MAX_CAM_NUM; i++) {
isp_info = &CamHwIsp20::mIspHwInfos.isp_info[i];
if (isp_info->valid) {
for (j = i - 1; j >= 0; j--) {
if (isp_info->phy_id == CamHwIsp20::mIspHwInfos.isp_info[j].phy_id) {
isp_info->isMultiplex = true;
CamHwIsp20::mIspHwInfos.isp_info[j].isMultiplex = true;
}
}
}
}
#endif
std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator iter;
for(iter = CamHwIsp20::mSensorHwInfos.begin(); \
iter != CamHwIsp20::mSensorHwInfos.end(); iter++) {
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "match the sensor_name(%s) media link\n", (iter->first).c_str());
SmartPtr<rk_sensor_full_info_t> s_full_info = iter->second;
/*
* The ISP and ISPP match links through the media device model
*/
if (s_full_info->linked_to_isp) {
for (i = 0; i < MAX_CAM_NUM; i++) {
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "isp model_idx: %d, ispp(%d) model_idx: %d\n",
s_full_info->isp_info->model_idx,
i,
CamHwIsp20::mIspHwInfos.ispp_info[i].model_idx);
if (CamHwIsp20::mIspHwInfos.ispp_info[i].valid &&
(s_full_info->isp_info->model_idx == CamHwIsp20::mIspHwInfos.ispp_info[i].model_idx)) {
s_full_info->ispp_info = &CamHwIsp20::mIspHwInfos.ispp_info[i];
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "isp(%d) link to ispp(%d)\n",
s_full_info->isp_info->model_idx,
CamHwIsp20::mIspHwInfos.ispp_info[i].model_idx);
CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx =
atoi(s_full_info->ispp_info->media_dev_path + strlen("/dev/media"));
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "sensor %s adapted to pp media %d:%s\n",
s_full_info->sensor_name.c_str(),
CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx,
s_full_info->ispp_info->media_dev_path);
break;
}
}
} else {
/*
* Determine which isp that vipCap is linked
*/
for (i = 0; i < MAX_CAM_NUM; i++) {
rk_aiq_isp_t* isp_info = &CamHwIsp20::mIspHwInfos.isp_info[i];
for (int vicap_idx = 0; vicap_idx < MAX_ISP_LINKED_VICAP_CNT; vicap_idx++) {
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "vicap %s, linked_vicap %s",
s_full_info->cif_info->model_str, isp_info->linked_vicap[vicap_idx]);
if (strcmp(s_full_info->cif_info->model_str, isp_info->linked_vicap[vicap_idx]) == 0) {
s_full_info->isp_info = &CamHwIsp20::mIspHwInfos.isp_info[i];
CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->is_multi_isp_mode =
s_full_info->isp_info->is_multi_isp_mode;
CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]
->multi_isp_extended_pixel = mMultiIspExtendedPixel;
if (CamHwIsp20::mIspHwInfos.ispp_info[i].valid)
s_full_info->ispp_info = &CamHwIsp20::mIspHwInfos.ispp_info[i];
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "vicap link to isp(%d) to ispp(%d)\n",
s_full_info->isp_info->model_idx,
s_full_info->ispp_info ? s_full_info->ispp_info->model_idx : -1);
CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx =
s_full_info->ispp_info ? atoi(s_full_info->ispp_info->media_dev_path + strlen("/dev/media")) :
-1;
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "sensor %s adapted to pp media %d:%s\n",
s_full_info->sensor_name.c_str(),
CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->sensor_info.binded_strm_media_idx,
s_full_info->ispp_info ? s_full_info->ispp_info->media_dev_path : "null");
CamHwIsp20::mIspHwInfos.isp_info[i].linked_sensor = true;
}
}
}
}
if (!s_full_info->isp_info/* || !s_full_info->ispp_info*/) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get isp or ispp info fail, something gos wrong!");
} else {
//CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->linked_isp_info = *s_full_info->isp_info;
//CamHwIsp20::mCamHwInfos[s_full_info->sensor_name]->linked_ispp_info = *s_full_info->ispp_info;
}
}
/* Look for free isp&ispp link to fake camera */
for (i = 0; i < MAX_CAM_NUM; i++) {
if (CamHwIsp20::mIspHwInfos.isp_info[i].valid &&
!CamHwIsp20::mIspHwInfos.isp_info[i].linked_sensor) {
rk_aiq_static_info_t *hwinfo = new rk_aiq_static_info_t();
rk_sensor_full_info_t *fullinfo = new rk_sensor_full_info_t();
fullinfo->isp_info = &CamHwIsp20::mIspHwInfos.isp_info[i];
if (CamHwIsp20::mIspHwInfos.ispp_info[i].valid) {
fullinfo->ispp_info = &CamHwIsp20::mIspHwInfos.ispp_info[i];
hwinfo->sensor_info.binded_strm_media_idx =
atoi(fullinfo->ispp_info->media_dev_path + strlen("/dev/media"));
}
fullinfo->media_node_index = -1;
fullinfo->device_name = std::string("/dev/null");
fullinfo->sensor_name = std::string("FakeCamera");
fullinfo->sensor_name += std::to_string(i);
fullinfo->parent_media_dev = std::string("/dev/null");
fullinfo->linked_to_isp = true;
hwinfo->sensor_info.support_fmt[0].hdr_mode = NO_HDR;
hwinfo->sensor_info.support_fmt[1].hdr_mode = HDR_X2;
hwinfo->sensor_info.support_fmt[2].hdr_mode = HDR_X3;
hwinfo->sensor_info.num = 3;
CamHwIsp20::mIspHwInfos.isp_info[i].linked_sensor = true;
SensorInfoCopy(fullinfo, hwinfo);
hwinfo->has_lens_vcm = false;
hwinfo->has_fl = false;
hwinfo->has_irc = false;
hwinfo->fl_strth_adj_sup = 0;
hwinfo->fl_ir_strth_adj_sup = 0;
hwinfo->is_multi_isp_mode = fullinfo->isp_info->is_multi_isp_mode;
hwinfo->multi_isp_extended_pixel = mMultiIspExtendedPixel;
CamHwIsp20::mSensorHwInfos[fullinfo->sensor_name] = fullinfo;
CamHwIsp20::mCamHwInfos[fullinfo->sensor_name] = hwinfo;
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "fake camera %d link to isp(%d) to ispp(%d)\n",
i,
fullinfo->isp_info->model_idx,
fullinfo->ispp_info ? fullinfo->ispp_info->model_idx : -1);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "sensor %s adapted to pp media %d:%s\n",
fullinfo->sensor_name.c_str(),
CamHwIsp20::mCamHwInfos[fullinfo->sensor_name]->sensor_info.binded_strm_media_idx,
fullinfo->ispp_info ? fullinfo->ispp_info->media_dev_path : "null");
}
}
get_isp_ver(&CamHwIsp20::mIspHwInfos);
for (auto &item : mCamHwInfos)
item.second->isp_hw_ver = mIspHwInfos.hw_ver_info.isp_ver;
return XCAM_RETURN_NO_ERROR;
}
const char*
CamHwIsp20::getBindedSnsEntNmByVd(const char* vd)
{
if (!vd)
return NULL;
std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator iter;
for(iter = CamHwIsp20::mSensorHwInfos.begin(); \
iter != CamHwIsp20::mSensorHwInfos.end(); iter++) {
SmartPtr<rk_sensor_full_info_t> s_full_info = iter->second;
// skip 1608-dphy 'sensor'
if (strstr(s_full_info->sensor_name.c_str(), "1608"))
continue;
if (!s_full_info->isp_info)
continue;
bool stream_vd = false;
if (s_full_info->ispp_info) {
if (strstr(s_full_info->ispp_info->pp_m_bypass_path, vd) ||
strstr(s_full_info->ispp_info->pp_scale0_path, vd) ||
strstr(s_full_info->ispp_info->pp_scale1_path, vd) ||
strstr(s_full_info->ispp_info->pp_scale2_path, vd))
stream_vd = true;
} else {
if (strstr(s_full_info->isp_info->main_path, vd) ||
strstr(s_full_info->isp_info->self_path, vd))
stream_vd = true;
}
if (stream_vd) {
// check linked
if ((strstr(s_full_info->sensor_name.c_str(), "FakeCamera") == NULL) &&
(strstr(s_full_info->sensor_name.c_str(), "_s_") == NULL)) {
FILE *fp = NULL;
struct media_device *device = NULL;
uint32_t j = 0, i = 0;
const struct media_entity_desc *entity_info = NULL;
struct media_entity *entity = NULL;
media_pad *src_pad_s = NULL;
char sys_path[64];
snprintf (sys_path, 64, "/dev/media%d", s_full_info->media_node_index);
if (0 != access(sys_path, F_OK))
continue;
device = media_device_new (sys_path);
if (!device)
return nullptr;
/* Enumerate entities, pads and links. */
media_device_enumerate (device);
entity = media_get_entity_by_name(device,
s_full_info->sensor_name.c_str(),
s_full_info->sensor_name.size());
entity_info = media_entity_get_info(entity);
if (entity && entity->num_links > 0) {
if (entity->links[0].flags == MEDIA_LNK_FL_ENABLED) {
media_device_unref (device);
return s_full_info->sensor_name.c_str();
}
}
media_device_unref (device);
} else
return s_full_info->sensor_name.c_str();
}
}
return NULL;
}
#if defined(ISP_HW_V20)
XCamReturn
CamHwIsp20::init_pp(rk_sensor_full_info_t *s_info)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
SmartPtr<PollThread> isp20IsppPollthread;
if (!s_info->ispp_info)
return ret;
if (!strlen(s_info->ispp_info->media_dev_path))
return ret;
_ispp_sd = new V4l2SubDevice(s_info->ispp_info->pp_dev_path);
_ispp_sd ->open();
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "pp_dev_path: %s\n", s_info->ispp_info->pp_dev_path);
mTnrStreamProcUnit = new TnrStreamProcUnit(s_info);
mTnrStreamProcUnit->set_devices(this, _ispp_sd);
mNrStreamProcUnit = new NrStreamProcUnit(s_info);
mNrStreamProcUnit->set_devices(this, _ispp_sd);
mFecParamStream = new FecParamStream(s_info);
mFecParamStream->set_devices(this, _ispp_sd);
return ret;
}
#endif
XCamReturn
CamHwIsp20::init(const char* sns_ent_name)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
SmartPtr<BaseSensorHw> sensorHw;
SmartPtr<LensHw> lensHw;
SmartPtr<V4l2Device> mipi_tx_devs[3];
SmartPtr<V4l2Device> mipi_rx_devs[3];
std::string sensor_name(sns_ent_name);
ENTER_CAMHW_FUNCTION();
std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
if ((it = mSensorHwInfos.find(sensor_name)) == mSensorHwInfos.end()) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_ent_name);
return XCAM_RETURN_ERROR_SENSOR;
}
rk_sensor_full_info_t *s_info = it->second.ptr();
sensorHw = new SensorHw(s_info->device_name.c_str());
sensorHw->setCamPhyId(mCamPhyId);
mSensorDev = sensorHw;
mSensorDev->open();
sensorHw->setTbInfo (mTbInfo.is_pre_aiq);
Isp20Params::setCamPhyId(mCamPhyId);
strncpy(sns_name, sns_ent_name, sizeof(sns_name) - 1);
sns_name[sizeof(sns_name) - 1] = '\0';
// normal env.
if (s_info->linked_to_isp) {
_linked_to_isp = true;
_linked_to_1608 = false;
} else {
_linked_to_isp = false;
_linked_to_1608 = false;
}
// 1608 sensor env.
if (s_info->linked_to_1608) {
_linked_to_isp = false;
_linked_to_1608 = true;
// [baron] Record the number of use sensors(valid 1608 sensor)
CamHwIsp20::rk1608_share_inf.en_sns_num++;
}
mIspCoreDev = new V4l2SubDevice(s_info->isp_info->isp_dev_path);
mIspCoreDev->open();
if (strlen(s_info->isp_info->mipi_luma_path)) {
if (_linked_to_isp) {
mIspLumaDev = new V4l2Device(s_info->isp_info->mipi_luma_path);
} else
mIspLumaDev = new V4l2Device(s_info->cif_info->mipi_luma_path);
mIspLumaDev->open();
}
mIspStatsDev = new V4l2Device (s_info->isp_info->stats_path);
mIspStatsDev->open();
mIspParamsDev = new V4l2Device (s_info->isp_info->input_params_path);
mIspParamsDev->open();
if(!s_info->module_lens_dev_name.empty()) {
lensHw = new LensHw(s_info->module_lens_dev_name.c_str());
mLensDev = lensHw;
mLensDev->open();
}
#if defined(ISP_HW_V20) || defined(ISP_HW_V21)
else {
// af soft stats need this device on 356x 1126
lensHw = new LensHw(NULL);
mLensDev = lensHw;
}
#endif
if(!s_info->module_ircut_dev_name.empty()) {
mIrcutDev = new V4l2SubDevice(s_info->module_ircut_dev_name.c_str());
mIrcutDev->open();
}
if (!_linked_to_isp) {
if (strlen(s_info->cif_info->mipi_csi2_sd_path) > 0) {
_cif_csi2_sd = new V4l2SubDevice (s_info->cif_info->mipi_csi2_sd_path);
} else if (strlen(s_info->cif_info->lvds_sd_path) > 0) {
_cif_csi2_sd = new V4l2SubDevice (s_info->cif_info->lvds_sd_path);
} else if (strlen(s_info->cif_info->dvp_sof_sd_path) > 0) {
_cif_csi2_sd = new V4l2SubDevice (s_info->cif_info->dvp_sof_sd_path);
} else {
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "_cif_csi2_sd is null! \n");
}
_cif_csi2_sd->open();
}
#if defined(ISP_HW_V20)
init_pp(s_info);
#endif
#if defined(RKAIQ_ENABLE_SPSTREAM)
mIspSpDev = new V4l2Device (s_info->isp_info->self_path);//rkisp_selfpath
mIspSpDev->open();
mSpStreamUnit = new SPStreamProcUnit(mIspSpDev, ISP_POLL_SP, mIspHwInfos.hw_ver_info.isp_ver);
mSpStreamUnit->set_devices(this, mIspCoreDev, _ispp_sd, mLensDev);
#endif
mPdafStreamUnit = new PdafStreamProcUnit(ISP_POLL_PDAF_STATS);
mPdafStreamUnit->set_devices(this);
#ifndef USE_RAWSTREAM_LIB
auto buf_it = std::find_if(
std::begin(mDevBufCntMap), std::end(mDevBufCntMap),
[&](const std::pair<std::string, int>& buf_cnt_map) {
return (
!buf_cnt_map.first.compare("rkraw_tx") || !buf_cnt_map.first.compare("rkraw_rx") ||
!buf_cnt_map.first.compare(0, sizeof("stream_cif_mipi_id"), "stream_cif_mipi_id") ||
!buf_cnt_map.first.compare(0, sizeof("rkisp_rawwr"), "rkisp_rawwr"));
});
int buf_cnt = 0;
if (buf_it != mDevBufCntMap.end()) {
buf_cnt = buf_it->second;
}
if (!_linked_to_1608) {
mRawCapUnit = new RawStreamCapUnit(s_info, _linked_to_isp, buf_cnt);
mRawProcUnit = new RawStreamProcUnit(s_info, _linked_to_isp, buf_cnt);
// set sensor stream flag.
mRawCapUnit->setSensorCategory(false);
mRawProcUnit->setSensorCategory(false);
} else {
// 1608 sensor
if (NULL == CamHwIsp20::rk1608_share_inf.raw_cap_unit.ptr()) {
// [baron] just new buffer in 1st.
mRawCapUnit = new RawStreamCapUnit(s_info, _linked_to_isp, buf_cnt);
CamHwIsp20::rk1608_share_inf.raw_cap_unit = mRawCapUnit;
}
mRawProcUnit = new RawStreamProcUnit(s_info, _linked_to_isp, buf_cnt);
if (mRawProcUnit.ptr()) {
// [baron] save multi rx addr for 1 tx.
CamHwIsp20::rk1608_share_inf.raw_proc_unit[mCamPhyId] = mRawProcUnit.ptr();
}
// update tx by bakeup tx.
mRawCapUnit = CamHwIsp20::rk1608_share_inf.raw_cap_unit;
mRawCapUnit->setSensorCategory(true);
mRawProcUnit->setSensorCategory(true);
}
mRawCapUnit->set_devices(mIspCoreDev, this, mRawProcUnit.ptr());
mRawProcUnit->set_devices(mIspCoreDev, this);
mRawCapUnit->setCamPhyId(mCamPhyId);
mRawProcUnit->setCamPhyId(mCamPhyId);
#endif
//cif scale
if (!_linked_to_isp && !_linked_to_1608) {
if (strlen(s_info->cif_info->mipi_scl0))
mCifScaleStream = new CifSclStream();
}
//isp stats
mIspStatsStream = new RKStatsStream(mIspStatsDev, ISP_POLL_3A_STATS);
mIspStatsStream->setPollCallback (this);
mIspStatsStream->set_event_handle_dev(sensorHw);
if(lensHw.ptr()) {
mIspStatsStream->set_focus_handle_dev(lensHw);
}
mIspStatsStream->set_rx_handle_dev(this);
mIspStatsStream->setCamPhyId(mCamPhyId);
//luma
if (mIspLumaDev.ptr()) {
mLumaStream = new RKStream(mIspLumaDev, ISP_POLL_LUMA);
mLumaStream->setPollCallback (this);
}
#ifndef DISABLE_PARAMS_POLL_THREAD
//isp params
mIspParamStream = new RKStream(mIspParamsDev, ISP_POLL_PARAMS);
mIspParamStream->setCamPhyId(mCamPhyId);
mIspParamStream->setPollCallback (this);
#endif
if (s_info->flash_num) {
mFlashLight = new FlashLightHw(s_info->module_flash_dev_name, s_info->flash_num);
mFlashLight->init(s_info->flash_num);
}
if (s_info->flash_ir_num) {
mFlashLightIr = new FlashLightHw(s_info->module_flash_ir_dev_name, s_info->flash_ir_num);
mFlashLightIr->init(s_info->flash_ir_num);
}
#if defined(ISP_HW_V20)
xcam_mem_clear (_full_active_ispp_params);
#endif
_state = CAM_HW_STATE_INITED;
EXIT_CAMHW_FUNCTION();
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CamHwIsp20::deInit()
{
if (mPdafStreamUnit.ptr())
mPdafStreamUnit->deinit();
if (mFlashLight.ptr())
mFlashLight->deinit();
if (mFlashLightIr.ptr())
mFlashLightIr->deinit();
std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
if (strlen(sns_name) == 0 || (it = mSensorHwInfos.find(sns_name)) == mSensorHwInfos.end()) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", strlen(sns_name) ? sns_name : "");
return XCAM_RETURN_ERROR_SENSOR;
}
rk_sensor_full_info_t *s_info = it->second.ptr();
int isp_index = s_info->isp_info->logic_id;
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "sensor_name(%s) is linked to isp_index(%d)",
sns_name, isp_index);
if (!mNoReadBack) {
setupHdrLink(RK_AIQ_WORKING_MODE_ISP_HDR3, isp_index, false);
setupHdrLink_vidcap(_hdr_mode, isp_index, false);
}
{
// TODO: These parameters only deinited when the first sensor deinit!
if (CamHwIsp20::rk1608_share_inf.raw_cap_unit.ptr()) {
CamHwIsp20::rk1608_share_inf.raw_cap_unit = NULL;
for (int i = 0; i < CAM_INDEX_FOR_1608; i++) {
CamHwIsp20::rk1608_share_inf.raw_proc_unit[i] = NULL;
}
// [Stage 01] {init} <-> {deinit}.
CamHwIsp20::rk1608_share_inf.en_sns_num = 0; // last sensor valid!
CamHwIsp20::rk1608_share_inf.us_open_cnt = 0;
// [Stage 02] {Prepare} <-> {deinit}
CamHwIsp20::rk1608_share_inf.us_prepare_cnt = 0; // prepare stage use
}
CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId] = 1; // prepare stage use
}
_state = CAM_HW_STATE_INVALID;
if (strstr(sns_name, "_s_")) {
rawReproc_deInit(sns_name);
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CamHwIsp20::poll_buffer_ready (SmartPtr<VideoBuffer> &buf)
{
if (buf->_buf_type == ISP_POLL_3A_STATS) {
// stats is comming, means that next params should be ready
#ifndef DISABLE_PARAMS_ASSEMBLER
if (/*mNoReadBack*/true) {
if (buf->get_sequence() > 0)
mParamsAssembler->forceReady(buf->get_sequence() + 1);
// set all ready params to drv
while (_state == CAM_HW_STATE_STARTED &&
mParamsAssembler->ready()) {
if (setIspConfig() != XCAM_RETURN_NO_ERROR)
break;
}
}
#endif
} else if (buf->_buf_type == ISP_POLL_PARAMS) {
V4l2BufferProxy* v4lbuf = buf.get_cast_ptr<V4l2BufferProxy>();
struct isp2x_isp_params_cfg* data = (struct isp2x_isp_params_cfg*)(v4lbuf->get_v4l2_userptr());
static int frame_id0_cnt = 0;
if (mTbInfo.is_pre_aiq) {
if (data->frame_id == 0) {
++frame_id0_cnt;
}
LOGK_CAMHW("<TB> poll param id %d cnt %d", data->frame_id, frame_id0_cnt);
}
if (!mTbInfo.is_pre_aiq && frame_id0_cnt < 1) {
return XCAM_RETURN_NO_ERROR;
}
}
return CamHwBase::poll_buffer_ready(buf);
}
XCamReturn
CamHwIsp20::setupPipelineFmtCif(struct v4l2_subdev_selection& sns_sd_sel,
struct v4l2_subdev_format& sns_sd_fmt,
__u32 sns_v4l_pix_fmt)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
int8_t bpp = 0;
pixFmt2Bpp(sns_v4l_pix_fmt, bpp);
#ifndef USE_RAWSTREAM_LIB
if (mIsMultiIspMode && !mNoReadBack) {
ret = mRawCapUnit->set_csi_mem_word_big_align(sns_sd_sel.r.width, sns_sd_sel.r.height,
sns_v4l_pix_fmt, bpp);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "tx set csi_mem_word_big_align failed!\n");
return ret;
}
ret = mRawProcUnit->set_csi_mem_word_big_align(sns_sd_sel.r.width, sns_sd_sel.r.height,
sns_v4l_pix_fmt, bpp);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "rx set csi_mem_word_big_align failed!\n");
return ret;
}
}
// TODO: set cif crop according to sensor crop bounds
if (!_linked_to_1608) {
mRawCapUnit->set_tx_format(sns_sd_sel, sns_v4l_pix_fmt);
} else {
// [baron] Only processed the first time
if (CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId]) {
// [baron] Timing issue, for 1608.
mRawCapUnit->set_tx_format(sns_sd_sel, sns_v4l_pix_fmt);
}
}
mRawProcUnit->set_rx_format(sns_sd_sel, sns_v4l_pix_fmt);
#endif
//set cif scale fmt
if (mCifScaleStream.ptr()) {
mCifScaleStream->set_format(sns_sd_sel, sns_v4l_pix_fmt, bpp);
}
// set isp sink fmt, same as sensor bounds - crop
struct v4l2_subdev_format isp_sink_fmt;
memset(&isp_sink_fmt, 0, sizeof(isp_sink_fmt));
isp_sink_fmt.pad = 0;
isp_sink_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
ret = mIspCoreDev->getFormat(isp_sink_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev fmt failed !\n");
return ret;
}
isp_sink_fmt.format.width = sns_sd_sel.r.width;
isp_sink_fmt.format.height = sns_sd_sel.r.height;
isp_sink_fmt.format.code = sns_sd_fmt.format.code;
ret = mIspCoreDev->setFormat(isp_sink_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev fmt failed !\n");
return ret;
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp sink fmt info: fmt 0x%x, %dx%d !",
isp_sink_fmt.format.code, isp_sink_fmt.format.width, isp_sink_fmt.format.height);
// set selection, isp needn't do the crop
struct v4l2_subdev_selection aSelection;
memset(&aSelection, 0, sizeof(aSelection));
aSelection.which = V4L2_SUBDEV_FORMAT_ACTIVE;
aSelection.pad = 0;
aSelection.flags = 0;
aSelection.target = V4L2_SEL_TGT_CROP;
aSelection.r.width = sns_sd_sel.r.width;
aSelection.r.height = sns_sd_sel.r.height;
aSelection.r.left = 0;
aSelection.r.top = 0;
ret = mIspCoreDev->set_selection (aSelection);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev crop failed !\n");
return ret;
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp sink crop info: %dx%d@%d,%d !",
aSelection.r.width, aSelection.r.height,
aSelection.r.left, aSelection.r.top);
// set isp rkisp-isp-subdev src crop
aSelection.pad = 2;
#if 1 // isp src has no crop
ret = mIspCoreDev->set_selection (aSelection);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev source crop failed !\n");
return ret;
}
#endif
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp src crop info: %dx%d@%d,%d !",
aSelection.r.width, aSelection.r.height,
aSelection.r.left, aSelection.r.top);
// set isp rkisp-isp-subdev src pad fmt
struct v4l2_subdev_format isp_src_fmt;
memset(&isp_src_fmt, 0, sizeof(isp_src_fmt));
isp_src_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
isp_src_fmt.pad = 2;
ret = mIspCoreDev->getFormat(isp_src_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get mIspCoreDev src fmt failed !\n");
return ret;
}
isp_src_fmt.format.width = aSelection.r.width;
isp_src_fmt.format.height = aSelection.r.height;
ret = mIspCoreDev->setFormat(isp_src_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev src fmt failed !\n");
return ret;
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp src fmt info: fmt 0x%x, %dx%d !",
isp_src_fmt.format.code, isp_src_fmt.format.width, isp_src_fmt.format.height);
return ret;
}
XCamReturn
CamHwIsp20::setupPipelineFmtIsp(struct v4l2_subdev_selection& sns_sd_sel,
struct v4l2_subdev_format& sns_sd_fmt,
__u32 sns_v4l_pix_fmt)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
#ifndef USE_RAWSTREAM_LIB
if (!_linked_to_1608 || CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId]) {
mRawCapUnit->set_tx_format(sns_sd_fmt, sns_v4l_pix_fmt);
}
mRawProcUnit->set_rx_format(sns_sd_fmt, sns_v4l_pix_fmt);
#endif
// set scale fmt
if (mCifScaleStream.ptr()) {
int8_t bpp = 0;
pixFmt2Bpp(sns_v4l_pix_fmt, bpp);
mCifScaleStream->set_format(sns_sd_sel, sns_v4l_pix_fmt, bpp);
}
#ifndef ANDROID_OS // Android camera hal will set pipeline itself
// set isp sink fmt, same as sensor fmt
struct v4l2_subdev_format isp_sink_fmt;
memset(&isp_sink_fmt, 0, sizeof(isp_sink_fmt));
isp_sink_fmt.pad = 0;
isp_sink_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
ret = mIspCoreDev->getFormat(isp_sink_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev fmt failed !\n");
return ret;
}
isp_sink_fmt.format.width = sns_sd_fmt.format.width;
isp_sink_fmt.format.height = sns_sd_fmt.format.height;
isp_sink_fmt.format.code = sns_sd_fmt.format.code;
ret = mIspCoreDev->setFormat(isp_sink_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev fmt failed !\n");
return ret;
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp sink fmt info: fmt 0x%x, %dx%d !",
isp_sink_fmt.format.code, isp_sink_fmt.format.width, isp_sink_fmt.format.height);
// set selection, isp do the crop
struct v4l2_subdev_selection aSelection;
memset(&aSelection, 0, sizeof(aSelection));
aSelection.which = V4L2_SUBDEV_FORMAT_ACTIVE;
aSelection.pad = 0;
aSelection.flags = 0;
aSelection.target = V4L2_SEL_TGT_CROP;
aSelection.r.width = sns_sd_sel.r.width;
aSelection.r.height = sns_sd_sel.r.height;
aSelection.r.left = sns_sd_sel.r.left;
aSelection.r.top = sns_sd_sel.r.top;
ret = mIspCoreDev->set_selection (aSelection);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev crop failed !\n");
return ret;
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp sink crop info: %dx%d@%d,%d !",
aSelection.r.width, aSelection.r.height,
aSelection.r.left, aSelection.r.top);
// set isp rkisp-isp-subdev src crop
aSelection.pad = 2;
aSelection.target = V4L2_SEL_TGT_CROP;
aSelection.r.left = 0;
aSelection.r.top = 0;
aSelection.r.width = sns_sd_sel.r.width;
aSelection.r.height = sns_sd_sel.r.height;
#if 1 // isp src has no crop
ret = mIspCoreDev->set_selection (aSelection);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev source crop failed !\n");
return ret;
}
#endif
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp src crop info: %dx%d@%d,%d !",
aSelection.r.width, aSelection.r.height,
aSelection.r.left, aSelection.r.top);
// set isp rkisp-isp-subdev src pad fmt
struct v4l2_subdev_format isp_src_fmt;
isp_src_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
isp_src_fmt.pad = 2;
ret = mIspCoreDev->getFormat(isp_src_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get mIspCoreDev src fmt failed !\n");
return ret;
}
isp_src_fmt.format.width = aSelection.r.width;
isp_src_fmt.format.height = aSelection.r.height;
ret = mIspCoreDev->setFormat(isp_src_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set mIspCoreDev src fmt failed !\n");
return ret;
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp src fmt info: fmt 0x%x, %dx%d !",
isp_src_fmt.format.code, isp_src_fmt.format.width, isp_src_fmt.format.height);
#endif
return ret;
}
XCamReturn
CamHwIsp20::setupPipelineFmt()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
// get sensor v4l2 pixfmt
BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
rk_aiq_exposure_sensor_descriptor sns_des;
if (mSensorSubdev->get_sensor_desc(&sns_des)) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "getSensorModeData failed \n");
return XCAM_RETURN_ERROR_UNKNOWN;
}
__u32 sns_v4l_pix_fmt = sns_des.sensor_pixelformat;
struct v4l2_subdev_format sns_sd_fmt;
// get sensor real outupt size
memset(&sns_sd_fmt, 0, sizeof(sns_sd_fmt));
sns_sd_fmt.pad = 0;
sns_sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
ret = mSensorDev->getFormat(sns_sd_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get sensor fmt failed !\n");
return ret;
}
// get sensor crop bounds
struct v4l2_subdev_selection sns_sd_sel;
memset(&sns_sd_sel, 0, sizeof(sns_sd_sel));
ret = mSensorDev->get_selection(0, V4L2_SEL_TGT_CROP_BOUNDS, sns_sd_sel);
if (ret) {
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "get_selection failed !\n");
// TODO, some sensor driver has not implemented this
// ioctl now
sns_sd_sel.r.width = sns_sd_fmt.format.width;
sns_sd_sel.r.height = sns_sd_fmt.format.height;
ret = XCAM_RETURN_NO_ERROR;
}
// with librkrawstream, usr may change raw image, such as crop or rotate.
// in this case, pipeline format is differ from sensor format.
if(userSensorWidth && userSensorHeight){
sns_sd_sel.r.width = userSensorWidth;
sns_sd_sel.r.height = userSensorHeight;
}
if(userSensorFmtCode){
sns_sd_fmt.format.code = userSensorFmtCode;
}
if (!_linked_to_isp && _crop_rect.width && _crop_rect.height) {
struct v4l2_format mipi_tx_fmt;
memset(&mipi_tx_fmt, 0, sizeof(mipi_tx_fmt));
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "vicap get_crop %dx%d@%d,%d\n",
_crop_rect.width, _crop_rect.height, _crop_rect.left, _crop_rect.top);
#ifndef USE_RAWSTREAM_LIB
if (!_linked_to_1608) {
ret = mRawCapUnit->get_tx_device(0)->get_format(mipi_tx_fmt);
} else {
if (CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId]) {
ret = mRawCapUnit->get_tx_device(0)->get_format(mipi_tx_fmt);
}
}
#endif
mipi_tx_fmt.fmt.pix.width = _crop_rect.width;
mipi_tx_fmt.fmt.pix.height = _crop_rect.height;
#ifndef USE_RAWSTREAM_LIB
if (!_linked_to_1608) {
ret = mRawCapUnit->get_tx_device(0)->set_format(mipi_tx_fmt);
} else {
if (CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId]) {
ret = mRawCapUnit->get_tx_device(0)->set_format(mipi_tx_fmt);
}
}
#endif
sns_sd_sel.r.width = _crop_rect.width;
sns_sd_sel.r.height = _crop_rect.height;
sns_sd_fmt.format.width = _crop_rect.width;
sns_sd_fmt.format.height = _crop_rect.height;
ret = XCAM_RETURN_NO_ERROR;
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "sensor fmt info: bounds %dx%d, crop %dx%d@%d,%d !",
sns_sd_sel.r.width, sns_sd_sel.r.height,
sns_sd_fmt.format.width, sns_sd_fmt.format.height,
sns_sd_sel.r.left, sns_sd_sel.r.top);
if (_linked_to_isp)
ret = setupPipelineFmtIsp(sns_sd_sel, sns_sd_fmt, sns_v4l_pix_fmt);
else
ret = setupPipelineFmtCif(sns_sd_sel, sns_sd_fmt, sns_v4l_pix_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set ispcore fmt failed !\n");
return ret;
}
#if defined(ISP_HW_V20)
if (!_ispp_sd.ptr())
return ret;
struct v4l2_subdev_format isp_src_fmt;
isp_src_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
isp_src_fmt.pad = 2;
ret = mIspCoreDev->getFormat(isp_src_fmt);
// set ispp format, same as isp_src_fmt
isp_src_fmt.pad = 0;
ret = _ispp_sd->setFormat(isp_src_fmt);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set _ispp_sd sink fmt failed !\n");
return ret;
}
#if 0//not use
struct v4l2_subdev_selection aSelection;
memset(&aSelection, 0, sizeof(aSelection));
aSelection.which = V4L2_SUBDEV_FORMAT_ACTIVE;
aSelection.pad = 0;
aSelection.target = V4L2_SEL_TGT_CROP_BOUNDS;
aSelection.flags = 0;
aSelection.r.left = 0;
aSelection.r.top = 0;
aSelection.r.width = isp_src_fmt.format.width;
aSelection.r.height = isp_src_fmt.format.height;
#if 0
ret = _ispp_sd->set_selection (aSelection);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set _ispp_sd crop bound failed !\n");
return ret;
}
#endif
aSelection.target = V4L2_SEL_TGT_CROP;
ret = _ispp_sd->set_selection (aSelection);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set _ispp_sd crop failed !\n");
return ret;
}
#endif
// set sp format to NV12 as default
if (mIspSpDev.ptr()) {
struct v4l2_selection selection;
memset(&selection, 0, sizeof(selection));
selection.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
selection.target = V4L2_SEL_TGT_CROP;
selection.flags = 0;
selection.r.left = 0;
selection.r.top = 0;
selection.r.width = isp_src_fmt.format.width;
selection.r.height = isp_src_fmt.format.height;
ret = mIspSpDev->set_selection (selection);
struct v4l2_format fmt;
ret = mIspSpDev->get_format (fmt);
if (ret) {
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "get mIspSpDev fmt failed !\n");
//return;
}
if (V4L2_PIX_FMT_FBCG == fmt.fmt.pix.pixelformat) {
mIspSpDev->set_format(/*isp_src_fmt.format.width*/1920,
/*isp_src_fmt.format.height*/1080,
V4L2_PIX_FMT_NV12,
V4L2_FIELD_NONE, 0);
}
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "ispp sd fmt info: %dx%d",
isp_src_fmt.format.width, isp_src_fmt.format.height);
#endif
return ret;
}
XCamReturn
CamHwIsp20::setupHdrLink_vidcap(int hdr_mode, int cif_index, bool enable)
{
media_device *device = NULL;
media_entity *entity = NULL;
media_pad *src_pad_s = NULL, *src_pad_m = NULL, *src_pad_l = NULL, *sink_pad = NULL;
// TODO: have some bugs now
return XCAM_RETURN_NO_ERROR;
if (_linked_to_isp)
return XCAM_RETURN_NO_ERROR;
// TODO: normal mode
device = media_device_new (mCifHwInfos.cif_info[cif_index].media_dev_path);
/* Enumerate entities, pads and links. */
media_device_enumerate (device);
entity = media_get_entity_by_name(device, "rockchip-mipi-csi2", strlen("rockchip-mipi-csi2"));
if(entity) {
src_pad_s = (media_pad *)media_entity_get_pad(entity, 1);
if (!src_pad_s) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rockchip-mipi-csi2 source pad0 failed !\n");
goto FAIL;
}
} else {
entity = media_get_entity_by_name(device, "rkcif-lvds-subdev", strlen("rkcif-lvds-subdev"));
if(entity) {
src_pad_s = (media_pad *)media_entity_get_pad(entity, 1);
if (!src_pad_s) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkcif-lvds-subdev source pad0 failed !\n");
goto FAIL;
}
} else {
entity = media_get_entity_by_name(device, "rkcif-lite-lvds-subdev", strlen("rkcif-lite-lvds-subdev"));
if(entity) {
src_pad_s = (media_pad *)media_entity_get_pad(entity, 1);
if (!src_pad_s) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkcif-lite-lvds-subdev source pad0 failed !\n");
goto FAIL;
}
}
}
}
entity = media_get_entity_by_name(device, "stream_cif_mipi_id0", strlen("stream_cif_mipi_id0"));
if(entity) {
sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
if (!sink_pad) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_mipi_id0 failed!\n");
goto FAIL;
}
}
entity = media_get_entity_by_name(device, "stream_cif_dvp_id0", strlen("stream_cif_dvp_id0"));
if(entity) {
sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
if (!sink_pad) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_dvp_id0 failed!\n");
goto FAIL;
}
}
if (enable)
media_setup_link(device, src_pad_s, sink_pad, MEDIA_LNK_FL_ENABLED);
else
media_setup_link(device, src_pad_s, sink_pad, 0);
entity = media_get_entity_by_name(device, "rockchip-mipi-csi2", strlen("rockchip-mipi-csi2"));
if(entity) {
src_pad_m = (media_pad *)media_entity_get_pad(entity, 2);
if (!src_pad_m) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rockchip-mipi-csi2 source pad0 failed !\n");
goto FAIL;
}
} else {
entity = media_get_entity_by_name(device, "rkcif-lvds-subdev", strlen("rkcif-lvds-subdev"));
if(entity) {
src_pad_m = (media_pad *)media_entity_get_pad(entity, 2);
if (!src_pad_m) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkcif-lvds-subdev source pad0 failed !\n");
goto FAIL;
}
} else {
entity = media_get_entity_by_name(device, "rkcif-lite-lvds-subdev", strlen("rkcif-lite-lvds-subdev"));
if(entity) {
src_pad_m = (media_pad *)media_entity_get_pad(entity, 2);
if (!src_pad_m) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkcif-lite-lvds-subdev source pad0 failed !\n");
goto FAIL;
}
}
}
}
entity = media_get_entity_by_name(device, "stream_cif_mipi_id1", strlen("stream_cif_mipi_id1"));
if(entity) {
sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
if (!sink_pad) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_mipi_id1 failed!\n");
goto FAIL;
}
}
entity = media_get_entity_by_name(device, "stream_cif_dvp_id1", strlen("stream_cif_dvp_id1"));
if(entity) {
sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
if (!sink_pad) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_dvp_id1 failed!\n");
goto FAIL;
}
}
if (enable)
media_setup_link(device, src_pad_m, sink_pad, MEDIA_LNK_FL_ENABLED);
else
media_setup_link(device, src_pad_m, sink_pad, 0);
#if 0
entity = media_get_entity_by_name(device, "rockchip-mipi-csi2", strlen("rockchip-mipi-csi2"));
if(entity) {
src_pad_l = (media_pad *)media_entity_get_pad(entity, 3);
if (!src_pad_l) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rockchip-mipi-csi2 source pad0 failed !\n");
goto FAIL;
}
}
entity = media_get_entity_by_name(device, "stream_cif_mipi_id2", strlen("stream_cif_mipi_id2"));
if(entity) {
sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
if (!sink_pad) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_mipi_id2 failed!\n");
goto FAIL;
}
}
entity = media_get_entity_by_name(device, "stream_cif_dvp_id2", strlen("stream_cif_dvp_id2"));
if(entity) {
sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
if (!sink_pad) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get pad of stream_cif_dvp_id2 failed!\n");
goto FAIL;
}
}
if (RK_AIQ_HDR_GET_WORKING_MODE(hdr_mode) == RK_AIQ_WORKING_MODE_ISP_HDR3) {
if (enable)
media_setup_link(device, src_pad_l, sink_pad, MEDIA_LNK_FL_ENABLED);
else
media_setup_link(device, src_pad_l, sink_pad, 0);
} else
media_setup_link(device, src_pad_l, sink_pad, 0);
#endif
media_device_unref (device);
return XCAM_RETURN_NO_ERROR;
FAIL:
media_device_unref (device);
return XCAM_RETURN_ERROR_FAILED;
}
XCamReturn
CamHwIsp20::setupHdrLink(int hdr_mode, int isp_index, bool enable)
{
media_device *device = NULL;
media_entity *entity = NULL;
media_pad *src_pad_s = NULL, *src_pad_m = NULL, *src_pad_l = NULL, *sink_pad = NULL;
device = media_device_new (mIspHwInfos.isp_info[isp_index].media_dev_path);
if (!device)
return XCAM_RETURN_ERROR_FAILED;
/* Enumerate entities, pads and links. */
media_device_enumerate (device);
entity = media_get_entity_by_name(device, "rkisp-isp-subdev", strlen("rkisp-isp-subdev"));
if(entity) {
sink_pad = (media_pad *)media_entity_get_pad(entity, 0);
if (!sink_pad) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get HDR sink pad failed!\n");
goto FAIL;
}
}
#if 0
entity = media_get_entity_by_name(device, mIspHwInfos.isp_info[isp_index].linked_vicap,
strlen(mIspHwInfos.isp_info[isp_index].linked_vicap));
if (entity) {
media_pad* linked_vicap_pad = (media_pad *)media_entity_get_pad(entity, 0);
if (linked_vicap_pad) {
if (enable) {
media_setup_link(device, linked_vicap_pad, sink_pad, 0);
} else {
media_setup_link(device, linked_vicap_pad, sink_pad, MEDIA_LNK_FL_ENABLED);
}
}
}
#endif
entity = media_get_entity_by_name(device, "rkisp_rawrd2_s", strlen("rkisp_rawrd2_s"));
if(entity) {
src_pad_s = (media_pad *)media_entity_get_pad(entity, 0);
if (!src_pad_s) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get HDR source pad s failed!\n");
goto FAIL;
}
}
if (src_pad_s && sink_pad) {
if (enable)
media_setup_link(device, src_pad_s, sink_pad, MEDIA_LNK_FL_ENABLED);
else
media_setup_link(device, src_pad_s, sink_pad, 0);
}
entity = media_get_entity_by_name(device, "rkisp_rawrd0_m", strlen("rkisp_rawrd0_m"));
if(entity) {
src_pad_m = (media_pad *)media_entity_get_pad(entity, 0);
if (!src_pad_m) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get HDR source pad m failed!\n");
goto FAIL;
}
}
if (src_pad_m && sink_pad) {
if (RK_AIQ_HDR_GET_WORKING_MODE(hdr_mode) >= RK_AIQ_WORKING_MODE_ISP_HDR2 && enable) {
media_setup_link(device, src_pad_m, sink_pad, MEDIA_LNK_FL_ENABLED);
} else
media_setup_link(device, src_pad_m, sink_pad, 0);
}
entity = media_get_entity_by_name(device, "rkisp_rawrd1_l", strlen("rkisp_rawrd1_l"));
if(entity) {
src_pad_l = (media_pad *)media_entity_get_pad(entity, 0);
if (!src_pad_l) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get HDR source pad l failed!\n");
goto FAIL;
}
}
if (src_pad_l && sink_pad) {
if (RK_AIQ_HDR_GET_WORKING_MODE(hdr_mode) == RK_AIQ_WORKING_MODE_ISP_HDR3 && enable) {
media_setup_link(device, src_pad_l, sink_pad, MEDIA_LNK_FL_ENABLED);
} else
media_setup_link(device, src_pad_l, sink_pad, 0);
}
media_device_unref (device);
return XCAM_RETURN_NO_ERROR;
FAIL:
media_device_unref (device);
return XCAM_RETURN_ERROR_FAILED;
}
XCamReturn
CamHwIsp20::setExpDelayInfo(int mode)
{
ENTER_CAMHW_FUNCTION();
BaseSensorHw* sensorHw;
sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
if(mode != RK_AIQ_WORKING_MODE_NORMAL) {
sensorHw->set_exp_delay_info(_cur_calib_infos.sensor.CISExpUpdate.Hdr.time_update,
_cur_calib_infos.sensor.CISExpUpdate.Hdr.gain_update,
_cur_calib_infos.sensor.CISDcgSet.Hdr.support_en ? \
_cur_calib_infos.sensor.CISExpUpdate.Hdr.dcg_update : -1);
sint32_t timeDelay = _cur_calib_infos.sensor.CISExpUpdate.Hdr.time_update;
sint32_t gainDelay = _cur_calib_infos.sensor.CISExpUpdate.Hdr.gain_update;
_exp_delay = timeDelay > gainDelay ? timeDelay : gainDelay;
} else {
sensorHw->set_exp_delay_info(_cur_calib_infos.sensor.CISExpUpdate.Linear.time_update,
_cur_calib_infos.sensor.CISExpUpdate.Linear.gain_update,
_cur_calib_infos.sensor.CISDcgSet.Linear.support_en ? \
_cur_calib_infos.sensor.CISExpUpdate.Linear.dcg_update : -1);
sint32_t timeDelay = _cur_calib_infos.sensor.CISExpUpdate.Linear.time_update;
sint32_t gainDelay = _cur_calib_infos.sensor.CISExpUpdate.Linear.gain_update;
_exp_delay = timeDelay > gainDelay ? timeDelay : gainDelay;
}
EXIT_CAMHW_FUNCTION();
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CamHwIsp20::setLensVcmCfg(struct rkmodule_inf& mod_info)
{
ENTER_CAMHW_FUNCTION();
LensHw* lensHw = mLensDev.get_cast_ptr<LensHw>();
rk_aiq_lens_vcmcfg old_cfg, new_cfg;
int old_maxpos, new_maxpos;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
if (lensHw) {
ret = lensHw->getLensVcmCfg(old_cfg);
if (ret != XCAM_RETURN_NO_ERROR)
return ret;
ret = lensHw->getLensVcmMaxlogpos(old_maxpos);
if (ret != XCAM_RETURN_NO_ERROR)
return ret;
CalibDbV2_Af_VcmCfg_t* vcmcfg = &_cur_calib_infos.af.vcmcfg;
float posture_diff = vcmcfg->posture_diff;
new_cfg = old_cfg;
if (vcmcfg->start_current != -1) {
new_cfg.start_ma = vcmcfg->start_current;
}
if (vcmcfg->rated_current != -1) {
new_cfg.rated_ma = vcmcfg->rated_current;
}
if (vcmcfg->step_mode != -1) {
new_cfg.step_mode = vcmcfg->step_mode;
}
if (vcmcfg->start_current == -1 && vcmcfg->rated_current == -1 && vcmcfg->step_mode == -1) {
if (mod_info.af.flag) {
new_cfg.start_ma = mod_info.af.af_otp[0].vcm_start;
new_cfg.rated_ma = mod_info.af.af_otp[0].vcm_end;
if (posture_diff != 0) {
int range = new_cfg.rated_ma - new_cfg.start_ma;
int start_ma = new_cfg.start_ma;
int rated_ma = new_cfg.rated_ma;
new_cfg.start_ma = start_ma - (int)(range * posture_diff);
new_cfg.rated_ma = rated_ma + (int)(range * posture_diff);
LOGD_AF("posture_diff %f, start_ma %d -> %d, rated_ma %d -> %d",
posture_diff, start_ma, new_cfg.start_ma, rated_ma, new_cfg.rated_ma);
}
}
}
if ((new_cfg.start_ma != old_cfg.start_ma) ||
(new_cfg.rated_ma != old_cfg.rated_ma) ||
(new_cfg.step_mode != old_cfg.step_mode)) {
ret = lensHw->setLensVcmCfg(new_cfg);
}
new_maxpos = old_maxpos;
if (vcmcfg->max_logical_pos > 0) {
new_maxpos = vcmcfg->max_logical_pos;
}
if (old_maxpos != new_maxpos) {
ret = lensHw->setLensVcmMaxlogpos(new_maxpos);
}
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::get_sensor_pdafinfo(rk_sensor_full_info_t *sensor_info,
rk_sensor_pdaf_info_t *pdaf_info) {
XCamReturn ret = XCAM_RETURN_NO_ERROR;
struct rkmodule_channel_info channel;
memset(&channel, 0, sizeof(struct rkmodule_channel_info));
V4l2SubDevice vdev(sensor_info->device_name.c_str());
ret = vdev.open();
if (ret != XCAM_RETURN_NO_ERROR) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to open dev (%s)", sensor_info->device_name.c_str());
return XCAM_RETURN_ERROR_FAILED;
}
pdaf_info->pdaf_support = false;
for (int i = 0; i < 4; i++) {
channel.index = i;
if (vdev.io_control(RKMODULE_GET_CHANNEL_INFO, &channel) == 0) {
if (channel.bus_fmt == MEDIA_BUS_FMT_SPD_2X8) {
pdaf_info->pdaf_support = true;
pdaf_info->pdaf_vc = i;
pdaf_info->pdaf_code = channel.bus_fmt;
pdaf_info->pdaf_width = channel.width;
pdaf_info->pdaf_height = channel.height;
if (channel.data_bit == 10)
pdaf_info->pdaf_pixelformat = V4L2_PIX_FMT_SRGGB10;
else if (channel.data_bit == 12)
pdaf_info->pdaf_pixelformat = V4L2_PIX_FMT_SRGGB12;
else if (channel.data_bit == 8)
pdaf_info->pdaf_pixelformat = V4L2_PIX_FMT_SRGGB8;
else
pdaf_info->pdaf_pixelformat = V4L2_PIX_FMT_SRGGB16;
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "channel.bus_fmt 0x%x, pdaf_width %d, pdaf_height %d",
channel.bus_fmt, pdaf_info->pdaf_width, pdaf_info->pdaf_height);
break;
}
}
}
if (pdaf_info->pdaf_support) {
if (sensor_info->linked_to_isp) {
switch (pdaf_info->pdaf_vc) {
case 0:
strcpy(pdaf_info->pdaf_vdev, sensor_info->isp_info->rawwr0_path);
break;
case 1:
strcpy(pdaf_info->pdaf_vdev, sensor_info->isp_info->rawwr1_path);
break;
case 2:
strcpy(pdaf_info->pdaf_vdev, sensor_info->isp_info->rawwr2_path);
break;
case 3:
default:
strcpy(pdaf_info->pdaf_vdev, sensor_info->isp_info->rawwr3_path);
break;
}
} else {
switch (pdaf_info->pdaf_vc) {
case 0:
strcpy(pdaf_info->pdaf_vdev, sensor_info->cif_info->mipi_id0);
break;
case 1:
strcpy(pdaf_info->pdaf_vdev, sensor_info->cif_info->mipi_id1);
break;
case 2:
strcpy(pdaf_info->pdaf_vdev, sensor_info->cif_info->mipi_id2);
break;
case 3:
default:
strcpy(pdaf_info->pdaf_vdev, sensor_info->cif_info->mipi_id3);
break;
}
}
}
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "%s: pdaf_vdev %s", __func__, pdaf_info->pdaf_vdev);
vdev.close();
return ret;
}
bool CamHwIsp20::isOnlineByWorkingMode()
{
return true;
}
void
CamHwIsp20::setCalib(const CamCalibDbV2Context_t* calibv2)
{
mCalibDbV2 = calibv2;
CalibDbV2_MFNR_t* mfnr =
(CalibDbV2_MFNR_t*)CALIBDBV2_GET_MODULE_PTR((void*)(mCalibDbV2), mfnr_v1);
if (mfnr) {
_cur_calib_infos.mfnr.enable = mfnr->TuningPara.enable;
_cur_calib_infos.mfnr.motion_detect_en = mfnr->TuningPara.motion_detect_en;
} else {
_cur_calib_infos.mfnr.enable = false;
_cur_calib_infos.mfnr.motion_detect_en = false;
}
CalibDb_Aec_ParaV2_t* aec =
(CalibDb_Aec_ParaV2_t*)CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, ae_calib);
if (aec) {
_cur_calib_infos.aec.IrisType = aec->IrisCtrl.IrisType;
} else {
_cur_calib_infos.aec.IrisType = IRISV2_DC_TYPE;
}
if (CHECK_ISP_HW_V32()) {
CalibDbV2_AFV31_t *af_v31 =
(CalibDbV2_AFV31_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, af_v31));
if (af_v31) {
_cur_calib_infos.af.vcmcfg = af_v31->TuningPara.vcmcfg;
} else {
memset(&_cur_calib_infos.af.vcmcfg, 0, sizeof(CalibDbV2_Af_VcmCfg_t));
}
memset(&_cur_calib_infos.af.ldg_param, 0, sizeof(CalibDbV2_Af_LdgParam_t));
} else if (CHECK_ISP_HW_V30()) {
CalibDbV2_AFV30_t *af_v30 =
(CalibDbV2_AFV30_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, af_v30));
if (af_v30) {
_cur_calib_infos.af.vcmcfg = af_v30->TuningPara.vcmcfg;
} else {
memset(&_cur_calib_infos.af.vcmcfg, 0, sizeof(CalibDbV2_Af_VcmCfg_t));
}
memset(&_cur_calib_infos.af.ldg_param, 0, sizeof(CalibDbV2_Af_LdgParam_t));
} else if (CHECK_ISP_HW_V32_LITE()) {
CalibDbV2_AFV32_t *af_v32 =
(CalibDbV2_AFV32_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, af_v32));
if (af_v32) {
_cur_calib_infos.af.vcmcfg = af_v32->TuningPara.vcmcfg;
} else {
memset(&_cur_calib_infos.af.vcmcfg, 0, sizeof(CalibDbV2_Af_VcmCfg_t));
}
memset(&_cur_calib_infos.af.ldg_param, 0, sizeof(CalibDbV2_Af_LdgParam_t));
} else {
CalibDbV2_AF_t *af =
(CalibDbV2_AF_t*)CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, af);
if (af) {
_cur_calib_infos.af.vcmcfg = af->TuningPara.vcmcfg;
_cur_calib_infos.af.ldg_param = af->TuningPara.ldg_param;
_cur_calib_infos.af.highlight = af->TuningPara.highlight;
} else {
memset(&_cur_calib_infos.af.vcmcfg, 0, sizeof(CalibDbV2_Af_VcmCfg_t));
memset(&_cur_calib_infos.af.ldg_param, 0, sizeof(CalibDbV2_Af_LdgParam_t));
}
}
CalibDb_Sensor_ParaV2_t* sensor_calib =
(CalibDb_Sensor_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, sensor_calib));
if (sensor_calib) {
_cur_calib_infos.sensor.CISDcgSet = sensor_calib->CISDcgSet;
_cur_calib_infos.sensor.CISExpUpdate = sensor_calib->CISExpUpdate;
} else {
memset(&_cur_calib_infos.sensor, 0,
sizeof(_cur_calib_infos.sensor));
}
// update infos to sensor hw
setExpDelayInfo(_hdr_mode);
}
XCamReturn
CamHwIsp20::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
BaseSensorHw* sensorHw = NULL;
LensHw* lensHw = mLensDev.get_cast_ptr<LensHw>();
ENTER_CAMHW_FUNCTION();
XCAM_ASSERT (mCalibDbV2);
_hdr_mode = mode;
Isp20Params::set_working_mode(_hdr_mode);
std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
if ((it = mSensorHwInfos.find(sns_name)) == mSensorHwInfos.end()) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_name);
return XCAM_RETURN_ERROR_SENSOR;
}
rk_sensor_full_info_t *s_info = it->second.ptr();
int isp_index = s_info->isp_info->logic_id;
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "sensor_name(%s) is linked to isp_index(%d)",
sns_name, isp_index);
if ((_hdr_mode > 0 && isOnlineByWorkingMode()) ||
(!_linked_to_isp && !mVicapIspPhyLinkSupported)) {
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "use read back mode!");
mNoReadBack = false;
}
// multimplex mode should be using readback mode
if (s_info->isp_info->isMultiplex)
mNoReadBack = false;
if (mTbInfo.prd_type == RK_AIQ_PRD_TYPE_TB_DOORLOCK ||
mTbInfo.prd_type == RK_AIQ_PRD_TYPE_TB_BATIPC) {
mNoReadBack = true;
}
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "isp hw working mode: %s !", mNoReadBack ? "online" : "readback");
//sof event
if (!mIspSofStream.ptr()) {
if (mNoReadBack) {
if (mTbInfo.prd_type == RK_AIQ_PRD_TYPE_TB_DOORLOCK ||
mTbInfo.prd_type == RK_AIQ_PRD_TYPE_TB_BATIPC) {
mIspSofStream = new RKSofEventStream(_cif_csi2_sd, ISP_POLL_SOF);
} else {
mIspSofStream = new RKSofEventStream(mIspCoreDev, ISP_POLL_SOF);
}
} else {
if (_linked_to_isp)
mIspSofStream = new RKSofEventStream(mIspCoreDev, ISP_POLL_SOF);
else
mIspSofStream = new RKSofEventStream(_cif_csi2_sd, ISP_POLL_SOF, _linked_to_1608);
}
mIspSofStream->setPollCallback (this);
}
_isp_stream_status = ISP_STREAM_STATUS_INVALID;
if (/*mIsGroupMode*/true) {
mIspStremEvtTh = new RkStreamEventPollThread("StreamEvt",
new V4l2Device (s_info->isp_info->input_params_path),
this);
}
if (!mNoReadBack) {
setupHdrLink(RK_AIQ_HDR_GET_WORKING_MODE(_hdr_mode), isp_index, true);
if (!_linked_to_isp) {
int cif_index = s_info->cif_info->model_idx;
setupHdrLink_vidcap(_hdr_mode, cif_index, true);
}
} else
setupHdrLink(RK_AIQ_WORKING_MODE_ISP_HDR3, isp_index, false);
sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
ret = sensorHw->set_working_mode(mode);
if (ret) {
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "set sensor mode error !");
return ret;
}
if (mIsGroupMode) {
ret = sensorHw->set_sync_mode(mIsMain ? INTERNAL_MASTER_MODE : EXTERNAL_MASTER_MODE);
if (ret) {
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "set sensor group mode error !\n");
}
} else {
sensorHw->set_sync_mode(NO_SYNC_MODE);
}
#ifndef USE_RAWSTREAM_LIB
mRawCapUnit->set_working_mode(mode);
mRawProcUnit->set_working_mode(mode);
#endif
setExpDelayInfo(mode);
setLensVcmCfg(s_info->mod_info);
xcam_mem_clear(_lens_des);
if (lensHw)
lensHw->getLensModeData(_lens_des);
#if defined(ISP_HW_V20)
_ispp_module_init_ens = 0;
#endif
ret = setupPipelineFmt();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setupPipelineFmt err: %d\n", ret);
}
struct v4l2_subdev_format isp_src_fmt;
memset(&isp_src_fmt, 0, sizeof(isp_src_fmt));
isp_src_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
isp_src_fmt.pad = 2;
ret = mIspCoreDev->getFormat(isp_src_fmt);
#if defined(RKAIQ_HAVE_MULTIISP)
if (ret == XCAM_RETURN_NO_ERROR && s_info->isp_info->is_multi_isp_mode) {
uint16_t extended_pixel = mMultiIspExtendedPixel;
uint32_t width = isp_src_fmt.format.width;
uint32_t height = isp_src_fmt.format.height;
mParamsSplitter = new IspParamsSplitter();
mParamsSplitter->SetPicInfo({0, 0, width, height})
.SetLeftIspRect({0, 0, width / 2 + extended_pixel, height})
.SetRightIspRect({width / 2 - extended_pixel, 0, width / 2 + extended_pixel, height});
IspParamsSplitter::Rectangle f = mParamsSplitter->GetPicInfo();
IspParamsSplitter::Rectangle l = mParamsSplitter->GetLeftIspRect();
IspParamsSplitter::Rectangle r = mParamsSplitter->GetRightIspRect();
LOGD_ANALYZER(
"Set Multi-ISP Mode ParamSplitter:\n"
" Extended Pixel%d\n"
" F : { %u, %u, %u, %u }\n"
" L : { %u, %u, %u, %u }\n"
" R : { %u, %u, %u, %u }\n",
extended_pixel,
f.x, f.y, f.w, f.h,
l.x, l.y, l.w, l.h,
r.x, r.y, r.w, r.h);
}
#endif
#ifndef USE_RAWSTREAM_LIB
if (!_linked_to_isp && !mNoReadBack) {
if (!_linked_to_1608) {
mRawCapUnit->prepare_cif_mipi();
} else {
if (CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId]) {
mRawCapUnit->prepare_cif_mipi();
CamHwIsp20::rk1608_share_inf.first_en[mCamPhyId] = 0;
}
}
}
#endif
#if defined(RKAIQ_ENABLE_SPSTREAM)
if ((_cur_calib_infos.mfnr.enable && _cur_calib_infos.mfnr.motion_detect_en) || _cur_calib_infos.af.ldg_param.enable) {
mSpStreamUnit->prepare(&_cur_calib_infos.af.ldg_param, &_cur_calib_infos.af.highlight);
}
#endif
CalibDbV2_Af_Pdaf_t *pdaf = NULL;
if (CHECK_ISP_HW_V30()) {
CalibDbV2_AFV30_t *af_v30 =
(CalibDbV2_AFV30_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, af_v30));
pdaf = &af_v30->TuningPara.pdaf;
}
get_sensor_pdafinfo(s_info, &mPdafInfo);
if (mPdafInfo.pdaf_support && pdaf && pdaf->enable) {
mPdafInfo.pdaf_lrdiffline = pdaf->pdLRInDiffLine;
mPdafStreamUnit->prepare(&mPdafInfo);
} else {
mPdafInfo.pdaf_support = false;
}
if (mCifScaleStream.ptr()) {
mCifScaleStream->set_working_mode(mode);
mCifScaleStream->prepare();
}
_state = CAM_HW_STATE_PREPARED;
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::start()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
BaseSensorHw* sensorHw = NULL;
LensHw* lensHw = NULL;
ENTER_CAMHW_FUNCTION();
sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
lensHw = mLensDev.get_cast_ptr<LensHw>();
if (_state != CAM_HW_STATE_PREPARED &&
_state != CAM_HW_STATE_STOPPED) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "camhw state err: %d\n", ret);
return XCAM_RETURN_ERROR_FAILED;
}
#ifndef DISABLE_PARAMS_ASSEMBLER
// set inital params
if (mParamsAssembler.ptr()) {
mParamsAssembler->setCamPhyId(mCamPhyId);
ret = mParamsAssembler->start();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "params assembler start err: %d\n", ret);
}
if (mParamsAssembler->ready())
setIspConfig();
}
#endif
if (mLumaStream.ptr())
mLumaStream->start();
if (mIspSofStream.ptr()) {
mIspSofStream->setCamPhyId(mCamPhyId);
mIspSofStream->start();
}
if (_linked_to_isp)
mIspCoreDev->subscribe_event(V4L2_EVENT_FRAME_SYNC);
if (mIspStremEvtTh.ptr()) {
ret = mIspStremEvtTh->start();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "start isp stream event failed: %d\n", ret);
}
} else {
ret = hdr_mipi_start_mode(_hdr_mode);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
}
}
ret = mIspCoreDev->start();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "start isp core dev err: %d\n", ret);
}
if (mIspStatsStream.ptr())
mIspStatsStream->start();
if (mFlashLight.ptr()) {
ret = mFlashLight->start();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "start flashlight err: %d\n", ret);
}
}
if (mFlashLightIr.ptr()) {
ret = mFlashLightIr->start();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "start flashlight ir err: %d\n", ret);
}
}
#if defined(RKAIQ_ENABLE_SPSTREAM)
if ((_cur_calib_infos.mfnr.enable && _cur_calib_infos.mfnr.motion_detect_en) || _cur_calib_infos.af.ldg_param.enable) {
mSpStreamUnit->start();
}
#endif
if (mPdafInfo.pdaf_support) {
mPdafStreamUnit->start();
}
#ifndef DISABLE_PARAMS_POLL_THREAD
if (mIspParamStream.ptr())
mIspParamStream->startThreadOnly();
#endif
#if defined(ISP_HW_V20)
if (mNrStreamProcUnit.ptr())
mNrStreamProcUnit->start();
if (mTnrStreamProcUnit.ptr())
mTnrStreamProcUnit->start();
if (mFecParamStream.ptr())
mFecParamStream->start();
#endif
sensorHw->start();
if (lensHw)
lensHw->start();
_is_exit = false;
_state = CAM_HW_STATE_STARTED;
#ifndef DISABLE_PARAMS_ASSEMBLER
// in fastboot server stage, F1 param maybe ready
// before _state = CAM_HW_STATE_STARTED.
if (mParamsAssembler->ready())
setIspConfig();
#endif
LOGK_CAMHW("cid[%d] %s success. isGroup:%d, isOnline:%d, isMultiIsp:%d, init_ens:0x%llx",
mCamPhyId, __func__, mIsGroupMode, mNoReadBack, mIsMultiIspMode, _isp_module_ens);
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::hdr_mipi_prepare_mode(int mode)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
int new_mode = RK_AIQ_HDR_GET_WORKING_MODE(mode);
#ifndef USE_RAWSTREAM_LIB
if (!mNoReadBack) {
bool init_state = true;
if (_linked_to_1608) {
if (CamHwIsp20::rk1608_share_inf.us_prepare_cnt > 0) {
init_state = false;
}
CamHwIsp20::rk1608_share_inf.us_prepare_cnt++;
if (CamHwIsp20::rk1608_share_inf.us_prepare_cnt > 10)
CamHwIsp20::rk1608_share_inf.us_prepare_cnt = 10;
}
if (new_mode == RK_AIQ_WORKING_MODE_NORMAL) {
if (!_linked_to_1608) {
ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_0);
} else {
if (init_state) {
ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_0);
}
}
ret = mRawProcUnit->prepare(MIPI_STREAM_IDX_0);
} else if (new_mode == RK_AIQ_WORKING_MODE_ISP_HDR2) {
if (!_linked_to_1608) {
ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_0 | MIPI_STREAM_IDX_1);
} else {
if (init_state) {
ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_0 | MIPI_STREAM_IDX_1);
}
}
ret = mRawProcUnit->prepare(MIPI_STREAM_IDX_0 | MIPI_STREAM_IDX_1);
} else {
if (!_linked_to_1608) {
ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_ALL);
} else {
if (init_state) {
ret = mRawCapUnit->prepare(MIPI_STREAM_IDX_ALL);
}
}
ret = mRawProcUnit->prepare(MIPI_STREAM_IDX_ALL);
}
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
}
}
#endif
return ret;
}
XCamReturn
CamHwIsp20::hdr_mipi_start_mode(int mode)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s enter", __FUNCTION__);
#ifndef USE_RAWSTREAM_LIB
if (!mNoReadBack) {
if (!_linked_to_1608) {
mRawCapUnit->start(mode);
mRawProcUnit->start(mode);
} else {
SmartLock locker(_sync_1608_mutex);
bool stream_on = false;
CamHwIsp20::rk1608_share_inf.us_stream_cnt++;
if (CamHwIsp20::rk1608_share_inf.us_stream_cnt > 10)
CamHwIsp20::rk1608_share_inf.us_stream_cnt = 10;
if (CamHwIsp20::rk1608_share_inf.us_stream_cnt >= CamHwIsp20::rk1608_share_inf.en_sns_num) {
// only processed the last streaming
stream_on = true;
}
if (stream_on) {
mRawCapUnit->start(mode);
}
mRawProcUnit->start(mode);
if (stream_on) {
_sync_1608_done = true;
_sync_done_cond.broadcast();
} else {
_sync_1608_done = false;
}
}
}
#endif
if (mCifScaleStream.ptr())
mCifScaleStream->start();
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "%s exit", __FUNCTION__);
return ret;
}
XCamReturn
CamHwIsp20::hdr_mipi_stop()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
#ifndef USE_RAWSTREAM_LIB
mRawProcUnit->stop();
if (!_linked_to_1608) {
mRawCapUnit->stop();
} else {
bool stop_en = false;
CamHwIsp20::rk1608_share_inf.us_stop_cnt++;
if (CamHwIsp20::rk1608_share_inf.us_stop_cnt > 10)
CamHwIsp20::rk1608_share_inf.us_stop_cnt = 10;
if (CamHwIsp20::rk1608_share_inf.us_stop_cnt == CamHwIsp20::rk1608_share_inf.en_sns_num) {
stop_en = true;
}
if (stop_en) {
mRawCapUnit->stop();
}
}
#endif
if (mCifScaleStream.ptr())
mCifScaleStream->stop();
return ret;
}
XCamReturn CamHwIsp20::stop()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
BaseSensorHw* sensorHw = NULL;
LensHw* lensHw = NULL;
ENTER_CAMHW_FUNCTION();
if (_state == CAM_HW_STATE_STOPPED)
return ret;
if (mIspStatsStream.ptr())
mIspStatsStream->stop();
if (mLumaStream.ptr())
mLumaStream->stop();
if (mIspSofStream.ptr())
mIspSofStream->stop();
#if defined(RKAIQ_ENABLE_SPSTREAM)
if ((_cur_calib_infos.mfnr.enable && _cur_calib_infos.mfnr.motion_detect_en) || _cur_calib_infos.af.ldg_param.enable) {
mSpStreamUnit->stop();
}
#endif
if (mPdafInfo.pdaf_support) {
mPdafStreamUnit->stop();
}
// stop after pollthread, ensure that no new events
// come into snesorHw
sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
sensorHw->stop();
lensHw = mLensDev.get_cast_ptr<LensHw>();
if (lensHw)
lensHw->stop();
if (_linked_to_isp)
mIspCoreDev->unsubscribe_event(V4L2_EVENT_FRAME_SYNC);
ret = mIspCoreDev->stop();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "stop isp core dev err: %d\n", ret);
}
#ifndef DISABLE_PARAMS_ASSEMBLER
if (mParamsAssembler.ptr())
mParamsAssembler->stop();
#endif
if (mIspStremEvtTh.ptr()) {
mIspStremEvtTh->stop();
if (/*_isp_stream_status == ISP_STREAM_STATUS_STREAM_ON*/true) {
SmartLock locker(_stop_cond_mutex);
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "stop isp stream");
#ifndef DISABLE_PARAMS_POLL_THREAD
if (mIspParamStream.ptr())
mIspParamStream->stop();
#else
if (mIspParamsDev.ptr())
mIspParamsDev->stop();
#endif
hdr_mipi_stop();
_isp_stream_status = ISP_STREAM_STATUS_INVALID;
}
} else {
#ifndef DISABLE_PARAMS_POLL_THREAD
if (mIspParamStream.ptr())
mIspParamStream->stop();
#else
if (mIspParamsDev.ptr())
mIspParamsDev->stop();
#endif
if (!mNoReadBack) {
ret = hdr_mipi_stop();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi stop err: %d\n", ret);
}
}
}
#if defined(ISP_HW_V20)
if (mTnrStreamProcUnit.ptr())
mTnrStreamProcUnit->stop();
if (mNrStreamProcUnit.ptr())
mNrStreamProcUnit->stop();
if (mFecParamStream.ptr())
mFecParamStream->stop();
#endif
if (mFlashLight.ptr()) {
ret = mFlashLight->stop();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "stop flashlight err: %d\n", ret);
}
}
if (mFlashLightIr.ptr()) {
mFlashLightIr->keep_status(mKpHwSt);
ret = mFlashLightIr->stop();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "stop flashlight ir err: %d\n", ret);
}
}
if (!mKpHwSt)
setIrcutParams(false);
{
SmartLock locker (_isp_params_cfg_mutex);
_camIsp3aResult.clear();
_effecting_ispparam_map.clear();
}
{
// TODO: [baron] PAL/NTSC mode convert[Start / Stop]. recovery cnt.
// [Stage 02] {start} <-> {stop}
CamHwIsp20::rk1608_share_inf.us_stream_cnt = 0;
if (CamHwIsp20::rk1608_share_inf.us_stop_cnt >= CamHwIsp20::rk1608_share_inf.en_sns_num) {
// ensure all valid 1608-sensor stoped.
CamHwIsp20::rk1608_share_inf.us_stop_cnt = 0;
}
}
_state = CAM_HW_STATE_STOPPED;
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn CamHwIsp20::pause()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
BaseSensorHw* sensorHw = NULL;
if (mIspStatsStream.ptr())
mIspStatsStream->stop();
if (mIspSofStream.ptr())
mIspSofStream->stop();
if (mLumaStream.ptr())
mLumaStream->stop();
if (!mNoReadBack)
hdr_mipi_stop();
sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
sensorHw->stop();
#ifndef DISABLE_PARAMS_POLL_THREAD
if (mIspParamStream.ptr())
mIspParamStream->stop();
#else
if (mIspParamsDev.ptr())
mIspParamsDev->stop();
#endif
#if defined(ISP_HW_V20)
if (mTnrStreamProcUnit.ptr())
mTnrStreamProcUnit->start();
if (mNrStreamProcUnit.ptr())
mNrStreamProcUnit->stop();
if (mFecParamStream.ptr())
mFecParamStream->stop();
#endif
#ifndef DISABLE_PARAMS_ASSEMBLER
if (mParamsAssembler.ptr())
mParamsAssembler->stop();
#endif
if (mPdafStreamUnit.ptr())
mPdafStreamUnit->stop();
{
SmartLock locker (_isp_params_cfg_mutex);
_camIsp3aResult.clear();
_effecting_ispparam_map.clear();
}
_state = CAM_HW_STATE_PAUSED;
return ret;
}
XCamReturn CamHwIsp20::swWorkingModeDyn(int mode)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
BaseSensorHw* sensorHw = NULL;
if (_linked_to_isp || mNoReadBack) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "sensor linked to isp, not supported now!");
return XCAM_RETURN_ERROR_FAILED;
}
sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
ret = sensorHw->set_working_mode(mode);
if (ret) {
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "set sensor mode error !");
return ret;
}
setExpDelayInfo(mode);
Isp20Params::set_working_mode(mode);
#if 0 // for quick switch, not used now
int old_mode = RK_AIQ_HDR_GET_WORKING_MODE(_hdr_mode);
int new_mode = RK_AIQ_HDR_GET_WORKING_MODE(mode);
//set hdr mode to drv
if (mIspCoreDev.ptr()) {
int drv_mode = ISP2X_HDR_MODE_NOMAL;
if (new_mode == RK_AIQ_WORKING_MODE_ISP_HDR3)
drv_mode = ISP2X_HDR_MODE_X3;
else if (new_mode == RK_AIQ_WORKING_MODE_ISP_HDR2)
drv_mode = ISP2X_HDR_MODE_X2;
if (mIspCoreDev->io_control (RKISP_CMD_SW_HDR_MODE_QUICK, &drv_mode) < 0) {
ret = XCAM_RETURN_ERROR_FAILED;
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set RKISP_CMD_SW_HDR_MODE_QUICK failed");
return ret;
}
}
// reconfig tx,rx stream
if (!old_mode && new_mode) {
// normal to hdr
if (new_mode == RK_AIQ_WORKING_MODE_ISP_HDR3)
hdr_mipi_start(MIPI_STREAM_IDX_1 | MIPI_STREAM_IDX_2);
else
hdr_mipi_start(MIPI_STREAM_IDX_1);
} else if (old_mode && !new_mode) {
// hdr to normal
if (new_mode == RK_AIQ_WORKING_MODE_ISP_HDR3)
hdr_mipi_stop(MIPI_STREAM_IDX_1 | MIPI_STREAM_IDX_2);
else
hdr_mipi_stop(MIPI_STREAM_IDX_1);
} else if (old_mode == RK_AIQ_WORKING_MODE_ISP_HDR3 &&
new_mode == RK_AIQ_WORKING_MODE_ISP_HDR2) {
// hdr3 to hdr2
hdr_mipi_stop(MIPI_STREAM_IDX_1);
} else if (old_mode == RK_AIQ_WORKING_MODE_ISP_HDR2 &&
new_mode == RK_AIQ_WORKING_MODE_ISP_HDR3) {
// hdr3 to hdr2
hdr_mipi_start(MIPI_STREAM_IDX_2);
} else {
// do nothing
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "do nothing, old mode %d, new mode %d\n",
_hdr_mode, mode);
}
#endif
_hdr_mode = mode;
#ifndef USE_RAWSTREAM_LIB
mRawCapUnit->set_working_mode(mode);
mRawProcUnit->set_working_mode(mode);
// remap _mipi_tx_devs for cif
if (!_linked_to_isp && !mNoReadBack) {
mRawCapUnit->prepare_cif_mipi();
}
#endif
return ret;
}
XCamReturn CamHwIsp20::resume()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
BaseSensorHw* sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
#ifndef DISABLE_PARAMS_ASSEMBLER
// set inital params
ret = mParamsAssembler->start();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "params assembler start err: %d\n", ret);
}
if (mParamsAssembler->ready())
setIspConfig();
#endif
ret = hdr_mipi_start_mode(_hdr_mode);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
}
sensorHw->start();
if (mIspSofStream.ptr())
mIspSofStream->start();
#ifndef DISABLE_PARAMS_POLL_THREAD
if (mIspParamStream.ptr())
mIspParamStream->startThreadOnly();
#endif
if (mLumaStream.ptr())
mLumaStream->start();
if (mIspStatsStream.ptr())
mIspStatsStream->start();
#if defined(ISP_HW_V20)
if (mTnrStreamProcUnit.ptr())
mTnrStreamProcUnit->start();
if (mNrStreamProcUnit.ptr())
mNrStreamProcUnit->start();
if (mFecParamStream.ptr())
mFecParamStream->start();
#endif
if (mPdafStreamUnit.ptr())
mPdafStreamUnit->start();
_state = CAM_HW_STATE_STARTED;
return ret;
}
#if defined(ISP_HW_V20)
void
CamHwIsp20::gen_full_ispp_params(const struct rkispp_params_cfg* update_params,
struct rkispp_params_cfg* full_params)
{
XCAM_ASSERT (update_params);
XCAM_ASSERT (full_params);
int end = RK_ISP2X_PP_MAX_ID - RK_ISP2X_PP_TNR_ID;
ENTER_CAMHW_FUNCTION();
for (int i = 0; i < end; i++)
if (update_params->module_en_update & (1 << i)) {
full_params->module_en_update |= 1 << i;
// clear old bit value
full_params->module_ens &= ~(1 << i);
// set new bit value
full_params->module_ens |= update_params->module_ens & (1LL << i);
}
for (int i = 0; i < end; i++)
if (update_params->module_cfg_update & (1 << i)) {
full_params->module_cfg_update |= 1 << i;
}
EXIT_CAMHW_FUNCTION();
}
#endif
#if 0
void CamHwIsp20::dump_isp_config(struct isp2x_isp_params_cfg* isp_params,
SmartPtr<RkAiqIspParamsProxy> aiq_results,
SmartPtr<RkAiqIspParamsProxy> aiq_other_results)
{
rk_aiq_isp_meas_params_v20_t* isp20_meas_result =
static_cast<rk_aiq_isp_meas_params_v20_t*>(aiq_results->data().ptr());
rk_aiq_isp_other_params_v20_t* isp20_other_result =
static_cast<rk_aiq_isp_other_params_v20_t*>(aiq_other_results->data().ptr());
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp_params mask: 0x%llx-0x%llx-0x%llx\n",
isp_params->module_en_update,
isp_params->module_ens,
isp_params->module_cfg_update);
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "aiq_results: ae-lite.winnum=%d; ae-big2.winnum=%d, sub[1].size: [%dx%d]\n",
isp20_meas_result->aec_meas.rawae0.wnd_num,
isp20_meas_result->aec_meas.rawae1.wnd_num,
isp20_meas_result->aec_meas.rawae1.subwin[1].h_size,
isp20_meas_result->aec_meas.rawae1.subwin[1].v_size);
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp_params: ae-lite.winnum=%d; ae-big2.winnum=%d, sub[1].size: [%dx%d]\n",
isp_params->meas.rawae0.wnd_num,
isp_params->meas.rawae1.wnd_num,
isp_params->meas.rawae1.subwin[1].h_size,
isp_params->meas.rawae1.subwin[1].v_size);
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp_params: win size: [%dx%d]-[%dx%d]-[%dx%d]-[%dx%d]\n",
isp_params->meas.rawae0.win.h_size,
isp_params->meas.rawae0.win.v_size,
isp_params->meas.rawae3.win.h_size,
isp_params->meas.rawae3.win.v_size,
isp_params->meas.rawae1.win.h_size,
isp_params->meas.rawae1.win.v_size,
isp_params->meas.rawae2.win.h_size,
isp_params->meas.rawae2.win.v_size);
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp_params: debayer:");
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "clip_en:%d, dist_scale:%d, filter_c_en:%d, filter_g_en:%d",
isp_params->others.debayer_cfg.clip_en,
isp_params->others.debayer_cfg.dist_scale,
isp_params->others.debayer_cfg.filter_c_en,
isp_params->others.debayer_cfg.filter_g_en);
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "gain_offset:%d,hf_offset:%d,max_ratio:%d,offset:%d,order_max:%d",
isp_params->others.debayer_cfg.gain_offset,
isp_params->others.debayer_cfg.hf_offset,
isp_params->others.debayer_cfg.max_ratio,
isp_params->others.debayer_cfg.offset,
isp_params->others.debayer_cfg.order_max);
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "order_min:%d, shift_num:%d, thed0:%d, thed1:%d",
isp_params->others.debayer_cfg.order_min,
isp_params->others.debayer_cfg.shift_num,
isp_params->others.debayer_cfg.thed0,
isp_params->others.debayer_cfg.thed1);
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "filter1:[%d, %d, %d, %d, %d]",
isp_params->others.debayer_cfg.filter1_coe1,
isp_params->others.debayer_cfg.filter1_coe2,
isp_params->others.debayer_cfg.filter1_coe3,
isp_params->others.debayer_cfg.filter1_coe4,
isp_params->others.debayer_cfg.filter1_coe5);
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "filter2:[%d, %d, %d, %d, %d]",
isp_params->others.debayer_cfg.filter2_coe1,
isp_params->others.debayer_cfg.filter2_coe2,
isp_params->others.debayer_cfg.filter2_coe3,
isp_params->others.debayer_cfg.filter2_coe4,
isp_params->others.debayer_cfg.filter2_coe5);
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "isp_params: gic: \n"
"edge_open:%d, regmingradthrdark2:%d, regmingradthrdark1:%d, regminbusythre:%d\n"
"regdarkthre:%d,regmaxcorvboth:%d,regdarktthrehi:%d,regkgrad2dark:%d,regkgrad1dark:%d\n"
"regstrengthglobal_fix:%d, regdarkthrestep:%d, regkgrad2:%d, regkgrad1:%d\n"
"reggbthre:%d, regmaxcorv:%d, regmingradthr2:%d, regmingradthr1:%d, gr_ratio:%d\n"
"dnloscale:%d, dnhiscale:%d, reglumapointsstep:%d, gvaluelimitlo:%d, gvaluelimithi:%d\n"
"fratiohilimt1:%d, strength_fix:%d, noise_cuten:%d, noise_coe_a:%d, noise_coe_b:%d, diff_clip:%d\n",
isp_params->others.gic_cfg.edge_open,
isp_params->others.gic_cfg.regmingradthrdark2,
isp_params->others.gic_cfg.regmingradthrdark1,
isp_params->others.gic_cfg.regminbusythre,
isp_params->others.gic_cfg.regdarkthre,
isp_params->others.gic_cfg.regmaxcorvboth,
isp_params->others.gic_cfg.regdarktthrehi,
isp_params->others.gic_cfg.regkgrad2dark,
isp_params->others.gic_cfg.regkgrad1dark,
isp_params->others.gic_cfg.regstrengthglobal_fix,
isp_params->others.gic_cfg.regdarkthrestep,
isp_params->others.gic_cfg.regkgrad2,
isp_params->others.gic_cfg.regkgrad1,
isp_params->others.gic_cfg.reggbthre,
isp_params->others.gic_cfg.regmaxcorv,
isp_params->others.gic_cfg.regmingradthr2,
isp_params->others.gic_cfg.regmingradthr1,
isp_params->others.gic_cfg.gr_ratio,
isp_params->others.gic_cfg.dnloscale,
isp_params->others.gic_cfg.dnhiscale,
isp_params->others.gic_cfg.reglumapointsstep,
isp_params->others.gic_cfg.gvaluelimitlo,
isp_params->others.gic_cfg.gvaluelimithi,
isp_params->others.gic_cfg.fusionratiohilimt1,
isp_params->others.gic_cfg.regstrengthglobal_fix,
isp_params->others.gic_cfg.noise_cut_en,
isp_params->others.gic_cfg.noise_coe_a,
isp_params->others.gic_cfg.noise_coe_b,
isp_params->others.gic_cfg.diff_clip);
for(int i = 0; i < ISP2X_GIC_SIGMA_Y_NUM; i++) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "sigma_y[%d]=%d\n", i, isp_params->others.gic_cfg.sigma_y[i]);
}
#if 0 //TODO Merge
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "aiq_results: gic: dnloscale=%f, dnhiscale=%f,gvaluelimitlo=%f,gvaluelimithi=%f,fusionratiohilimt1=%f"
"textureStrength=%f,globalStrength=%f,noiseCurve_0=%f,noiseCurve_1=%f",
isp20_other_result->gic.dnloscale, isp20_other_result->gic.dnhiscale,
isp20_other_result->gic.gvaluelimitlo, isp20_other_result->gic.gvaluelimithi,
isp20_other_result->gic.fusionratiohilimt1, isp20_other_result->gic.textureStrength,
isp20_other_result->gic.globalStrength, isp20_other_result->gic.noiseCurve_0,
isp20_other_result->gic.noiseCurve_1);
for(int i = 0; i < ISP2X_GIC_SIGMA_Y_NUM; i++) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "sigma[%d]=%f\n", i, isp20_other_result->gic.sigma_y[i]);
}
#endif
}
#endif
#if defined(ISP_HW_V20)
XCamReturn
CamHwIsp20::setIsppSharpFbcRot(struct rkispp_sharp_config* shp_cfg)
{
// check if sharp enable
// check if fec disable
if ((_ispp_module_init_ens & ISPP_MODULE_SHP) &&
!(_ispp_module_init_ens & ISPP_MODULE_FEC)) {
switch (_sharp_fbc_rotation) {
case RK_AIQ_ROTATION_0 :
shp_cfg->rotation = 0;
break;
case RK_AIQ_ROTATION_90 :
shp_cfg->rotation = 1;
break;
case RK_AIQ_ROTATION_270 :
shp_cfg->rotation = 3;
break;
default:
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "wrong rotation %d\n", _sharp_fbc_rotation);
return XCAM_RETURN_ERROR_PARAM;
}
} else {
if (_sharp_fbc_rotation != RK_AIQ_ROTATION_0) {
shp_cfg->rotation = 0;
_sharp_fbc_rotation = RK_AIQ_ROTATION_0;
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't set sharp config, check fec & sharp config\n");
return XCAM_RETURN_ERROR_PARAM;
}
}
LOGD("sharp rotation %d", _sharp_fbc_rotation);
return XCAM_RETURN_NO_ERROR;
}
#endif
XCamReturn
CamHwIsp20::showOtpPdafData(struct rkmodule_pdaf_inf *otp_pdaf)
{
unsigned int gainmap_w, gainmap_h;
unsigned int dccmap_w, dccmap_h;
char print_buf[256];
unsigned int i, j;
if (otp_pdaf->flag) {
gainmap_w = otp_pdaf->gainmap_width;
gainmap_h = otp_pdaf->gainmap_height;
dccmap_w = otp_pdaf->dccmap_width;
dccmap_h = otp_pdaf->dccmap_height;
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "[RKPDAFOTPParam]");
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "flag=%d;", otp_pdaf->flag);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "gainmap_width=%d;", gainmap_w);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "gainmap_height=%d;", gainmap_h);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "gainmap_table=");
for (i = 0; i < gainmap_h; i++) {
memset(print_buf, 0, sizeof(print_buf));
for (j = 0; j < gainmap_w; j++) {
sprintf(print_buf + strlen(print_buf), "%d ", otp_pdaf->gainmap[i * gainmap_w + j]);
}
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "%s", print_buf);
}
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dcc_mode=%d;", otp_pdaf->dcc_mode);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dcc_dir=%d;", otp_pdaf->dcc_dir);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dccmap_width=%d;", otp_pdaf->dccmap_width);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dccmap_height=%d;", otp_pdaf->dccmap_height);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dccmap_table=");
for (i = 0; i < dccmap_h; i++) {
memset(print_buf, 0, sizeof(print_buf));
for (j = 0; j < dccmap_w; j++) {
sprintf(print_buf + strlen(print_buf), "%d ", otp_pdaf->dccmap[i * dccmap_w + j]);
}
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "%s", print_buf);
}
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "pd_offset=0x%x;", otp_pdaf->pd_offset);
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CamHwIsp20::showOtpAfData(struct rkmodule_af_inf *af_inf)
{
unsigned int i;
if (af_inf->flag) {
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "[RKAFOTPParam]");
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "flag=%d;", af_inf->flag);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "dir_cnt=%d;", af_inf->dir_cnt);
for (i = 0; i < af_inf->dir_cnt; i++) {
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "af_inf=%d;", af_inf->af_otp[i].vcm_dir);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "af_macro=%d;", af_inf->af_otp[i].vcm_start);
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "af_macro=%d;", af_inf->af_otp[i].vcm_end);
}
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CamHwIsp20::getSensorModeData(const char* sns_ent_name,
rk_aiq_exposure_sensor_descriptor& sns_des)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
struct v4l2_subdev_selection select;
ret = mSensorSubdev->getSensorModeData(sns_ent_name, sns_des);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "getSensorModeData failed \n");
return ret;
}
xcam_mem_clear (select);
ret = mIspCoreDev->get_selection(0, V4L2_SEL_TGT_CROP, select);
if (ret == XCAM_RETURN_NO_ERROR) {
sns_des.isp_acq_width = select.r.width;
sns_des.isp_acq_height = select.r.height;
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "get isp acq,w: %d, h: %d\n",
sns_des.isp_acq_width,
sns_des.isp_acq_height);
} else {
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "get selecttion error \n");
sns_des.isp_acq_width = sns_des.sensor_output_width;
sns_des.isp_acq_height = sns_des.sensor_output_height;
ret = XCAM_RETURN_NO_ERROR;
}
if(userSensorWidth && userSensorHeight){
sns_des.sensor_output_width = userSensorWidth;
sns_des.sensor_output_height = userSensorHeight;
sns_des.isp_acq_width = sns_des.sensor_output_width;
sns_des.isp_acq_height = sns_des.sensor_output_height;
}
xcam_mem_clear (sns_des.lens_des);
if (mLensSubdev)
mLensSubdev->getLensModeData(sns_des.lens_des);
auto iter_sns_info = mSensorHwInfos.find(sns_name);
if (iter_sns_info == mSensorHwInfos.end()) {
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_name);
} else {
struct rkmodule_inf *minfo = &(iter_sns_info->second->mod_info);
if (minfo->awb.flag) {
memcpy(&sns_des.otp_awb, &minfo->awb, sizeof(minfo->awb));
} else {
sns_des.otp_awb.flag = 0;
}
if (minfo->lsc.flag)
sns_des.otp_lsc = &minfo->lsc;
else
sns_des.otp_lsc = nullptr;
if (minfo->af.flag) {
sns_des.otp_af = &minfo->af;
showOtpAfData(sns_des.otp_af);
} else {
sns_des.otp_af = nullptr;
}
if (minfo->pdaf.flag) {
sns_des.otp_pdaf = &minfo->pdaf;
showOtpPdafData(sns_des.otp_pdaf);
} else {
sns_des.otp_pdaf = nullptr;
}
}
return ret;
}
XCamReturn
CamHwIsp20::setExposureParams(SmartPtr<RkAiqExpParamsProxy>& expPar)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
//exp
ret = mSensorSubdev->setExposureParams(expPar);
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::setIrisParams(SmartPtr<RkAiqIrisParamsProxy>& irisPar, CalibDb_IrisTypeV2_t irisType)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
if(irisType == IRISV2_P_TYPE) {
//P-iris
int step = irisPar->data()->PIris.step;
bool update = irisPar->data()->PIris.update;
if (mLensSubdev && update) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||set P-Iris step: %d", step);
if (mLensSubdev->setPIrisParams(step) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set P-Iris step failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
}
} else if(irisType == IRISV2_DC_TYPE) {
//DC-iris
int PwmDuty = irisPar->data()->DCIris.pwmDuty;
bool update = irisPar->data()->DCIris.update;
if (mLensSubdev && update) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||set DC-Iris PwmDuty: %d", PwmDuty);
if (mLensSubdev->setDCIrisParams(PwmDuty) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set DC-Iris PwmDuty failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
}
} else if(irisType == IRISV2_HDC_TYPE) {
//HDC-iris
int target = irisPar->data()->HDCIris.target;
bool update = irisPar->data()->HDCIris.update;
if (mLensSubdev && update) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||set HDC-Iris Target: %d", target);
if (mLensSubdev->setHDCIrisParams(target) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set HDC-Iris target failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
}
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::getIrisParams(SmartPtr<RkAiqIrisParamsProxy>& irisPar, CalibDb_IrisTypeV2_t irisType)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
if(irisType == IRISV2_HDC_TYPE) {
//HDC-iris
int adc = 0;
int position = 0;
if (mLensSubdev) {
if (mLensSubdev->getHDCIrisParams(&adc) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get HDC-Iris adc failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
if (mLensSubdev->getZoomParams(&position) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get zoom result failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||get HDC-Iris ADC: %d get zoomPos: %d\n", adc, position);
irisPar->data()->HDCIris.adc = adc;
irisPar->data()->HDCIris.zoomPos = position;
}
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::setFocusParams(SmartPtr<RkAiqFocusParamsProxy>& focus_params)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
rk_aiq_focus_params_t* p_focus = &focus_params->data()->result;
bool focus_valid = p_focus->lens_pos_valid;
bool zoom_valid = p_focus->zoom_pos_valid;
bool focus_correction = p_focus->focus_correction;
bool zoom_correction = p_focus->zoom_correction;
bool zoomfocus_modifypos = p_focus->zoomfocus_modifypos;
bool end_zoom_chg = p_focus->end_zoom_chg;
bool vcm_config_valid = p_focus->vcm_config_valid;
if (!mLensSubdev)
goto OUT;
if (zoomfocus_modifypos)
mLensSubdev->ZoomFocusModifyPosition(focus_params);
if (focus_correction)
mLensSubdev->FocusCorrection();
if (zoom_correction)
mLensSubdev->ZoomCorrection();
if (focus_valid && !zoom_valid) {
if (mLensSubdev->setFocusParams(focus_params) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set focus result failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
} else if ((focus_valid && zoom_valid) || end_zoom_chg) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||setZoomFocusParams");
if (mLensSubdev->setZoomFocusParams(focus_params) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set setZoomFocusParams failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
}
rk_aiq_lens_vcmcfg lens_cfg;
if (mLensSubdev && vcm_config_valid) {
mLensSubdev->getLensVcmCfg(lens_cfg);
lens_cfg.start_ma = p_focus->vcm_start_ma;
lens_cfg.rated_ma = p_focus->vcm_end_ma;
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||set vcm config: %d, %d", lens_cfg.start_ma, lens_cfg.rated_ma);
if (mLensSubdev->setLensVcmCfg(lens_cfg) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set vcm config failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
}
OUT:
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::getZoomPosition(int& position)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
if (mLensSubdev) {
if (mLensSubdev->getZoomParams(&position) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get zoom result failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||get zoom result: %d", position);
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::setLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
if (mLensSubdev) {
if (mLensSubdev->setLensVcmCfg(lens_cfg) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set vcm config failed");
return XCAM_RETURN_ERROR_IOCTL;
}
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::FocusCorrection()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
if (mLensSubdev) {
if (mLensSubdev->FocusCorrection() < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "focus correction failed");
return XCAM_RETURN_ERROR_IOCTL;
}
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::ZoomCorrection()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
if (mLensSubdev) {
if (mLensSubdev->ZoomCorrection() < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "zoom correction failed");
return XCAM_RETURN_ERROR_IOCTL;
}
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::getLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
if (mLensSubdev) {
if (mLensSubdev->getLensVcmCfg(lens_cfg) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get vcm config failed");
return XCAM_RETURN_ERROR_IOCTL;
}
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::setAngleZ(float angleZ)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
if (mLensSubdev) {
if (mLensSubdev->setAngleZ(angleZ) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setAngleZ failed");
return XCAM_RETURN_ERROR_IOCTL;
}
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::getFocusPosition(int& position)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
SmartPtr<LensHw> mLensSubdev = mLensDev.dynamic_cast_ptr<LensHw>();
if (mLensSubdev.ptr()) {
if (mLensSubdev->getFocusParams(&position) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get focus position failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "|||get focus position: %d", position);
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::setCpslParams(SmartPtr<RkAiqCpslParamsProxy>& cpsl_params)
{
ENTER_CAMHW_FUNCTION();
XCamReturn ret = XCAM_RETURN_NO_ERROR;
RKAiqCpslInfoWrapper_t* cpsl_setting = cpsl_params->data().ptr();
if (cpsl_setting->update_fl) {
rk_aiq_flash_setting_t* fl_setting = &cpsl_setting->fl;
if (mFlashLight.ptr()) {
ret = mFlashLight->set_params(*fl_setting);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set flashlight params err: %d\n", ret);
}
}
}
if (cpsl_setting->update_ir) {
rk_aiq_ir_setting_t* ir_setting = &cpsl_setting->ir;
ret = setIrcutParams(ir_setting->irc_on);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set ir params err: %d\n", ret);
}
rk_aiq_flash_setting_t* fl_ir_setting = &cpsl_setting->fl_ir;
if (mFlashLightIr.ptr()) {
ret = mFlashLightIr->set_params(*fl_ir_setting);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set flashlight ir params err: %d\n", ret);
}
}
}
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::setHdrProcessCount(rk_aiq_luma_params_t luma_params)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
#ifndef USE_RAWSTREAM_LIB
mRawProcUnit->set_hdr_frame_readback_infos(luma_params.frame_id, luma_params.hdrProcessCnt);
#endif
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::getEffectiveIspParams(rkisp_effect_params_v20& ispParams, uint32_t frame_id)
{
ENTER_CAMHW_FUNCTION();
std::map<uint32_t, SmartPtr<RkAiqIspEffParamsProxy>>::iterator it;
uint32_t search_id = frame_id == uint32_t(-1) ? 0 : frame_id;
SmartLock locker (_isp_params_cfg_mutex);
if (_effecting_ispparam_map.size() == 0) {
if (frame_id != 0 && _state == CAM_HW_STATE_STARTED)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "camId: %d, can't search id %d, _effecting_ispparam_map is %d\n",
mCamPhyId, frame_id, _effecting_ispparam_map.size());
return XCAM_RETURN_ERROR_PARAM;
}
it = _effecting_ispparam_map.find(search_id);
// havn't found
if (it == _effecting_ispparam_map.end()) {
std::map<uint32_t, SmartPtr<RkAiqIspEffParamsProxy>>::reverse_iterator rit;
rit = _effecting_ispparam_map.rbegin();
do {
LOGV_CAMHW_SUBM(ISP20HW_SUBM, "camId: %d, traverse _effecting_ispparam_map to find id %d, current id is [%d]\n",
mCamPhyId, search_id, rit->first);
if (search_id >= rit->first ) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "camId: %d, can't find id %d, get latest id %d in _effecting_ispparam_map\n",
mCamPhyId, search_id, rit->first);
break;
}
} while (++rit != _effecting_ispparam_map.rend());
if (rit == _effecting_ispparam_map.rend()) {
if (_effecting_ispparam_map.size() > 0) {
ispParams = _effecting_ispparam_map.rbegin()->second->data()->result;
return XCAM_RETURN_NO_ERROR;
}
LOGE_CAMHW_SUBM(ISP20HW_SUBM,
"camId: %d, can't find the latest effecting ispparams for id %d, impossible case !",
mCamPhyId, frame_id);
return XCAM_RETURN_ERROR_PARAM;
}
ispParams = rit->second->data()->result;
} else {
ispParams = it->second->data()->result;
}
EXIT_CAMHW_FUNCTION();
return XCAM_RETURN_NO_ERROR;
}
#if 0
void CamHwIsp20::dumpRawnrFixValue(struct isp2x_rawnr_cfg * pRawnrCfg )
{
printf("%s:(%d) enter \n", __FUNCTION__, __LINE__);
int i = 0;
//(0x0004)
printf("(0x0004) gauss_en:%d log_bypass:%d \n",
pRawnrCfg->gauss_en,
pRawnrCfg->log_bypass);
//(0x0008 - 0x0010)
printf("(0x0008 - 0x0010) filtpar0-2:%d %d %d \n",
pRawnrCfg->filtpar0,
pRawnrCfg->filtpar1,
pRawnrCfg->filtpar2);
//(0x0014 - 0x001c)
printf("(0x0014 - 0x001c) dgain0-2:%d %d %d \n",
pRawnrCfg->dgain0,
pRawnrCfg->dgain1,
pRawnrCfg->dgain2);
//(0x0020 - 0x002c)
for(int i = 0; i < ISP2X_RAWNR_LUMA_RATION_NUM; i++) {
printf("(0x0020 - 0x002c) luration[%d]:%d \n",
i, pRawnrCfg->luration[i]);
}
//(0x0030 - 0x003c)
for(int i = 0; i < ISP2X_RAWNR_LUMA_RATION_NUM; i++) {
printf("(0x0030 - 0x003c) lulevel[%d]:%d \n",
i, pRawnrCfg->lulevel[i]);
}
//(0x0040)
printf("(0x0040) gauss:%d \n",
pRawnrCfg->gauss);
//(0x0044)
printf("(0x0044) sigma:%d \n",
pRawnrCfg->sigma);
//(0x0048)
printf("(0x0048) pix_diff:%d \n",
pRawnrCfg->pix_diff);
//(0x004c)
printf("(0x004c) thld_diff:%d \n",
pRawnrCfg->thld_diff);
//(0x0050)
printf("(0x0050) gas_weig_scl1:%d gas_weig_scl2:%d thld_chanelw:%d \n",
pRawnrCfg->gas_weig_scl1,
pRawnrCfg->gas_weig_scl2,
pRawnrCfg->thld_chanelw);
//(0x0054)
printf("(0x0054) lamda:%d \n",
pRawnrCfg->lamda);
//(0x0058 - 0x005c)
printf("(0x0058 - 0x005c) fixw0-3:%d %d %d %d\n",
pRawnrCfg->fixw0,
pRawnrCfg->fixw1,
pRawnrCfg->fixw2,
pRawnrCfg->fixw3);
//(0x0060 - 0x0068)
printf("(0x0060 - 0x0068) wlamda0-2:%d %d %d\n",
pRawnrCfg->wlamda0,
pRawnrCfg->wlamda1,
pRawnrCfg->wlamda2);
//(0x006c)
printf("(0x006c) rgain_filp-2:%d bgain_filp:%d\n",
pRawnrCfg->rgain_filp,
pRawnrCfg->bgain_filp);
printf("%s:(%d) exit \n", __FUNCTION__, __LINE__);
}
void CamHwIsp20::dumpTnrFixValue(struct rkispp_tnr_config * pTnrCfg)
{
int i = 0;
printf("%s:(%d) enter \n", __FUNCTION__, __LINE__);
//0x0080
printf("(0x0080) opty_en:%d optc_en:%d gain_en:%d\n",
pTnrCfg->opty_en,
pTnrCfg->optc_en,
pTnrCfg->gain_en);
//0x0088
printf("(0x0088) pk0_y:%d pk1_y:%d pk0_c:%d pk1_c:%d \n",
pTnrCfg->pk0_y,
pTnrCfg->pk1_y,
pTnrCfg->pk0_c,
pTnrCfg->pk1_c);
//0x008c
printf("(0x008c) glb_gain_cur:%d glb_gain_nxt:%d \n",
pTnrCfg->glb_gain_cur,
pTnrCfg->glb_gain_nxt);
//0x0090
printf("(0x0090) glb_gain_cur_div:%d gain_glb_filt_sqrt:%d \n",
pTnrCfg->glb_gain_cur_div,
pTnrCfg->glb_gain_cur_sqrt);
//0x0094 - 0x0098
for(i = 0; i < TNR_SIGMA_CURVE_SIZE - 1; i++) {
printf("(0x0094 - 0x0098) sigma_x[%d]:%d \n",
i, pTnrCfg->sigma_x[i]);
}
//0x009c - 0x00bc
for(i = 0; i < TNR_SIGMA_CURVE_SIZE; i++) {
printf("(0x009c - 0x00bc) sigma_y[%d]:%d \n",
i, pTnrCfg->sigma_y[i]);
}
//0x00c4 - 0x00cc
//dir_idx = 0;
for(i = 0; i < TNR_LUMA_CURVE_SIZE; i++) {
printf("(0x00c4 - 0x00cc) luma_curve[%d]:%d \n",
i, pTnrCfg->luma_curve[i]);
}
//0x00d0
printf("(0x00d0) txt_th0_y:%d txt_th1_y:%d \n",
pTnrCfg->txt_th0_y,
pTnrCfg->txt_th1_y);
//0x00d4
printf("(0x00d0) txt_th0_c:%d txt_th1_c:%d \n",
pTnrCfg->txt_th0_c,
pTnrCfg->txt_th1_c);
//0x00d8
printf("(0x00d8) txt_thy_dlt:%d txt_thc_dlt:%d \n",
pTnrCfg->txt_thy_dlt,
pTnrCfg->txt_thc_dlt);
//0x00dc - 0x00ec
for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
printf("(0x00dc - 0x00ec) gfcoef_y0[%d]:%d \n",
i, pTnrCfg->gfcoef_y0[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x00dc - 0x00ec) gfcoef_y1[%d]:%d \n",
i, pTnrCfg->gfcoef_y1[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x00dc - 0x00ec) gfcoef_y2[%d]:%d \n",
i, pTnrCfg->gfcoef_y2[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x00dc - 0x00ec) gfcoef_y3[%d]:%d \n",
i, pTnrCfg->gfcoef_y3[i]);
}
//0x00f0 - 0x0100
for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
printf("(0x00f0 - 0x0100) gfcoef_yg0[%d]:%d \n",
i, pTnrCfg->gfcoef_yg0[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x00f0 - 0x0100) gfcoef_yg1[%d]:%d \n",
i, pTnrCfg->gfcoef_yg1[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x00f0 - 0x0100) gfcoef_yg2[%d]:%d \n",
i, pTnrCfg->gfcoef_yg2[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x00f0 - 0x0100) gfcoef_yg3[%d]:%d \n",
i, pTnrCfg->gfcoef_yg3[i]);
}
//0x0104 - 0x0110
for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
printf("(0x0104 - 0x0110) gfcoef_yl0[%d]:%d \n",
i, pTnrCfg->gfcoef_yl0[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x0104 - 0x0110) gfcoef_yl1[%d]:%d \n",
i, pTnrCfg->gfcoef_yl1[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x0104 - 0x0110) gfcoef_yl2[%d]:%d \n",
i, pTnrCfg->gfcoef_yl2[i]);
}
//0x0114 - 0x0120
for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
printf("(0x0114 - 0x0120) gfcoef_cg0[%d]:%d \n",
i, pTnrCfg->gfcoef_cg0[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x0114 - 0x0120) gfcoef_cg1[%d]:%d \n",
i, pTnrCfg->gfcoef_cg1[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x0114 - 0x0120) gfcoef_cg2[%d]:%d \n",
i, pTnrCfg->gfcoef_cg2[i]);
}
//0x0124 - 0x012c
for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
printf("(0x0124 - 0x012c) gfcoef_cl0[%d]:%d \n",
i, pTnrCfg->gfcoef_cl0[i]);
}
for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
printf("(0x0124 - 0x012c) gfcoef_cl1[%d]:%d \n",
i, pTnrCfg->gfcoef_cl1[i]);
}
//0x0130 - 0x0134
//dir_idx = 0; i = lvl;
for(i = 0; i < TNR_SCALE_YG_SIZE; i++) {
printf("(0x0130 - 0x0134) scale_yg[%d]:%d \n",
i, pTnrCfg->scale_yg[i]);
}
//0x0138 - 0x013c
//dir_idx = 1; i = lvl;
for(i = 0; i < TNR_SCALE_YL_SIZE; i++) {
printf("(0x0138 - 0x013c) scale_yl[%d]:%d \n",
i, pTnrCfg->scale_yl[i]);
}
//0x0140 - 0x0148
//dir_idx = 0; i = lvl;
for(i = 0; i < TNR_SCALE_CG_SIZE; i++) {
printf("(0x0140 - 0x0148) scale_cg[%d]:%d \n",
i, pTnrCfg->scale_cg[i]);
printf("(0x0140 - 0x0148) scale_y2cg[%d]:%d \n",
i, pTnrCfg->scale_y2cg[i]);
}
//0x014c - 0x0154
//dir_idx = 1; i = lvl;
for(i = 0; i < TNR_SCALE_CL_SIZE; i++) {
printf("(0x014c - 0x0154) scale_cl[%d]:%d \n",
i, pTnrCfg->scale_cl[i]);
}
for(i = 0; i < TNR_SCALE_Y2CL_SIZE; i++) {
printf("(0x014c - 0x0154) scale_y2cl[%d]:%d \n",
i, pTnrCfg->scale_y2cl[i]);
}
//0x0158
for(i = 0; i < TNR_WEIGHT_Y_SIZE; i++) {
printf("(0x0158) weight_y[%d]:%d \n",
i, pTnrCfg->weight_y[i]);
}
printf("%s:(%d) exit \n", __FUNCTION__, __LINE__);
}
void CamHwIsp20::dumpUvnrFixValue(struct rkispp_nr_config * pNrCfg)
{
int i = 0;
printf("%s:(%d) exit \n", __FUNCTION__, __LINE__);
//0x0080
printf("(0x0088) uvnr_step1_en:%d uvnr_step2_en:%d nr_gain_en:%d uvnr_nobig_en:%d uvnr_big_en:%d\n",
pNrCfg->uvnr_step1_en,
pNrCfg->uvnr_step2_en,
pNrCfg->nr_gain_en,
pNrCfg->uvnr_nobig_en,
pNrCfg->uvnr_big_en);
//0x0084
printf("(0x0084) uvnr_gain_1sigma:%d \n",
pNrCfg->uvnr_gain_1sigma);
//0x0088
printf("(0x0088) uvnr_gain_offset:%d \n",
pNrCfg->uvnr_gain_offset);
//0x008c
printf("(0x008c) uvnr_gain_uvgain:%d uvnr_step2_en:%d uvnr_gain_t2gen:%d uvnr_gain_iso:%d\n",
pNrCfg->uvnr_gain_uvgain[0],
pNrCfg->uvnr_gain_uvgain[1],
pNrCfg->uvnr_gain_t2gen,
pNrCfg->uvnr_gain_iso);
//0x0090
printf("(0x0090) uvnr_t1gen_m3alpha:%d \n",
pNrCfg->uvnr_t1gen_m3alpha);
//0x0094
printf("(0x0094) uvnr_t1flt_mode:%d \n",
pNrCfg->uvnr_t1flt_mode);
//0x0098
printf("(0x0098) uvnr_t1flt_msigma:%d \n",
pNrCfg->uvnr_t1flt_msigma);
//0x009c
printf("(0x009c) uvnr_t1flt_wtp:%d \n",
pNrCfg->uvnr_t1flt_wtp);
//0x00a0-0x00a4
for(i = 0; i < NR_UVNR_T1FLT_WTQ_SIZE; i++) {
printf("(0x00a0-0x00a4) uvnr_t1flt_wtq[%d]:%d \n",
i, pNrCfg->uvnr_t1flt_wtq[i]);
}
//0x00a8
printf("(0x00a8) uvnr_t2gen_m3alpha:%d \n",
pNrCfg->uvnr_t2gen_m3alpha);
//0x00ac
printf("(0x00ac) uvnr_t2gen_msigma:%d \n",
pNrCfg->uvnr_t2gen_msigma);
//0x00b0
printf("(0x00b0) uvnr_t2gen_wtp:%d \n",
pNrCfg->uvnr_t2gen_wtp);
//0x00b4
for(i = 0; i < NR_UVNR_T2GEN_WTQ_SIZE; i++) {
printf("(0x00b4) uvnr_t2gen_wtq[%d]:%d \n",
i, pNrCfg->uvnr_t2gen_wtq[i]);
}
//0x00b8
printf("(0x00b8) uvnr_t2flt_msigma:%d \n",
pNrCfg->uvnr_t2flt_msigma);
//0x00bc
printf("(0x00bc) uvnr_t2flt_wtp:%d \n",
pNrCfg->uvnr_t2flt_wtp);
for(i = 0; i < NR_UVNR_T2FLT_WT_SIZE; i++) {
printf("(0x00bc) uvnr_t2flt_wt[%d]:%d \n",
i, pNrCfg->uvnr_t2flt_wt[i]);
}
printf("%s:(%d) entor \n", __FUNCTION__, __LINE__);
}
void CamHwIsp20::dumpYnrFixValue(struct rkispp_nr_config * pNrCfg)
{
printf("%s:(%d) enter \n", __FUNCTION__, __LINE__);
int i = 0;
//0x0104 - 0x0108
for(i = 0; i < NR_YNR_SGM_DX_SIZE; i++) {
printf("(0x0104 - 0x0108) ynr_sgm_dx[%d]:%d \n",
i, pNrCfg->ynr_sgm_dx[i]);
}
//0x010c - 0x012c
for(i = 0; i < NR_YNR_SGM_Y_SIZE; i++) {
printf("(0x010c - 0x012c) ynr_lsgm_y[%d]:%d \n",
i, pNrCfg->ynr_lsgm_y[i]);
}
//0x0130
for(i = 0; i < NR_YNR_CI_SIZE; i++) {
printf("(0x0130) ynr_lci[%d]:%d \n",
i, pNrCfg->ynr_lci[i]);
}
//0x0134
for(i = 0; i < NR_YNR_LGAIN_MIN_SIZE; i++) {
printf("(0x0134) ynr_lgain_min[%d]:%d \n",
i, pNrCfg->ynr_lgain_min[i]);
}
//0x0138
printf("(0x0138) ynr_lgain_max:%d \n",
pNrCfg->ynr_lgain_max);
//0x013c
printf("(0x013c) ynr_lmerge_bound:%d ynr_lmerge_ratio:%d\n",
pNrCfg->ynr_lmerge_bound,
pNrCfg->ynr_lmerge_ratio);
//0x0140
for(i = 0; i < NR_YNR_LWEIT_FLT_SIZE; i++) {
printf("(0x0140) ynr_lweit_flt[%d]:%d \n",
i, pNrCfg->ynr_lweit_flt[i]);
}
//0x0144 - 0x0164
for(i = 0; i < NR_YNR_SGM_Y_SIZE; i++) {
printf("(0x0144 - 0x0164) ynr_hsgm_y[%d]:%d \n",
i, pNrCfg->ynr_hsgm_y[i]);
}
//0x0168
for(i = 0; i < NR_YNR_CI_SIZE; i++) {
printf("(0x0168) ynr_hlci[%d]:%d \n",
i, pNrCfg->ynr_hlci[i]);
}
//0x016c
for(i = 0; i < NR_YNR_CI_SIZE; i++) {
printf("(0x016c) ynr_lhci[%d]:%d \n",
i, pNrCfg->ynr_lhci[i]);
}
//0x0170
for(i = 0; i < NR_YNR_CI_SIZE; i++) {
printf("(0x0170) ynr_hhci[%d]:%d \n",
i, pNrCfg->ynr_hhci[i]);
}
//0x0174
for(i = 0; i < NR_YNR_HGAIN_SGM_SIZE; i++) {
printf("(0x0174) ynr_hgain_sgm[%d]:%d \n",
i, pNrCfg->ynr_hgain_sgm[i]);
}
//0x0178 - 0x0188
for(i = 0; i < 5; i++) {
printf("(0x0178 - 0x0188) ynr_hweit_d[%d - %d]:%d %d %d %d \n",
i * 4 + 0, i * 4 + 3,
pNrCfg->ynr_hweit_d[i * 4 + 0],
pNrCfg->ynr_hweit_d[i * 4 + 1],
pNrCfg->ynr_hweit_d[i * 4 + 2],
pNrCfg->ynr_hweit_d[i * 4 + 3]);
}
//0x018c - 0x01a0
for(i = 0; i < 6; i++) {
printf("(0x018c - 0x01a0) ynr_hgrad_y[%d - %d]:%d %d %d %d \n",
i * 4 + 0, i * 4 + 3,
pNrCfg->ynr_hgrad_y[i * 4 + 0],
pNrCfg->ynr_hgrad_y[i * 4 + 1],
pNrCfg->ynr_hgrad_y[i * 4 + 2],
pNrCfg->ynr_hgrad_y[i * 4 + 3]);
}
//0x01a4 -0x01a8
for(i = 0; i < NR_YNR_HWEIT_SIZE; i++) {
printf("(0x01a4 -0x01a8) ynr_hweit[%d]:%d \n",
i, pNrCfg->ynr_hweit[i]);
}
//0x01b0
printf("(0x01b0) ynr_hmax_adjust:%d \n",
pNrCfg->ynr_hmax_adjust);
//0x01b4
printf("(0x01b4) ynr_hstrength:%d \n",
pNrCfg->ynr_hstrength);
//0x01b8
printf("(0x01b8) ynr_lweit_cmp0-1:%d %d\n",
pNrCfg->ynr_lweit_cmp[0],
pNrCfg->ynr_lweit_cmp[1]);
//0x01bc
printf("(0x01bc) ynr_lmaxgain_lv4:%d \n",
pNrCfg->ynr_lmaxgain_lv4);
//0x01c0 - 0x01e0
for(i = 0; i < NR_YNR_HSTV_Y_SIZE; i++) {
printf("(0x01c0 - 0x01e0 ) ynr_hstv_y[%d]:%d \n",
i, pNrCfg->ynr_hstv_y[i]);
}
//0x01e4 - 0x01e8
for(i = 0; i < NR_YNR_ST_SCALE_SIZE; i++) {
printf("(0x01e4 - 0x01e8 ) ynr_st_scale[%d]:%d \n",
i, pNrCfg->ynr_st_scale[i]);
}
printf("%s:(%d) exit \n", __FUNCTION__, __LINE__);
}
void CamHwIsp20::dumpSharpFixValue(struct rkispp_sharp_config * pSharpCfg)
{
printf("%s:(%d) enter \n", __FUNCTION__, __LINE__);
int i = 0;
//0x0080
printf("(0x0080) alpha_adp_en:%d yin_flt_en:%d edge_avg_en:%d\n",
pSharpCfg->alpha_adp_en,
pSharpCfg->yin_flt_en,
pSharpCfg->edge_avg_en);
//0x0084
printf("(0x0084) hbf_ratio:%d ehf_th:%d pbf_ratio:%d\n",
pSharpCfg->hbf_ratio,
pSharpCfg->ehf_th,
pSharpCfg->pbf_ratio);
//0x0088
printf("(0x0088) edge_thed:%d dir_min:%d smoth_th4:%d\n",
pSharpCfg->edge_thed,
pSharpCfg->dir_min,
pSharpCfg->smoth_th4);
//0x008c
printf("(0x008c) l_alpha:%d g_alpha:%d \n",
pSharpCfg->l_alpha,
pSharpCfg->g_alpha);
//0x0090
for(i = 0; i < 3; i++) {
printf("(0x0090) pbf_k[%d]:%d \n",
i, pSharpCfg->pbf_k[i]);
}
//0x0094 - 0x0098
for(i = 0; i < 6; i++) {
printf("(0x0094 - 0x0098) mrf_k[%d]:%d \n",
i, pSharpCfg->mrf_k[i]);
}
//0x009c -0x00a4
for(i = 0; i < 12; i++) {
printf("(0x009c -0x00a4) mbf_k[%d]:%d \n",
i, pSharpCfg->mbf_k[i]);
}
//0x00a8 -0x00ac
for(i = 0; i < 6; i++) {
printf("(0x00a8 -0x00ac) hrf_k[%d]:%d \n",
i, pSharpCfg->hrf_k[i]);
}
//0x00b0
for(i = 0; i < 3; i++) {
printf("(0x00b0) hbf_k[%d]:%d \n",
i, pSharpCfg->hbf_k[i]);
}
//0x00b4
for(i = 0; i < 3; i++) {
printf("(0x00b4) eg_coef[%d]:%d \n",
i, pSharpCfg->eg_coef[i]);
}
//0x00b8
for(i = 0; i < 3; i++) {
printf("(0x00b8) eg_smoth[%d]:%d \n",
i, pSharpCfg->eg_smoth[i]);
}
//0x00bc - 0x00c0
for(i = 0; i < 6; i++) {
printf("(0x00bc - 0x00c0) eg_gaus[%d]:%d \n",
i, pSharpCfg->eg_gaus[i]);
}
//0x00c4 - 0x00c8
for(i = 0; i < 6; i++) {
printf("(0x00c4 - 0x00c8) dog_k[%d]:%d \n",
i, pSharpCfg->dog_k[i]);
}
//0x00cc - 0x00d0
for(i = 0; i < SHP_LUM_POINT_SIZE; i++) {
printf("(0x00cc - 0x00d0) lum_point[%d]:%d \n",
i, pSharpCfg->lum_point[i]);
}
//0x00d4
printf("(0x00d4) pbf_shf_bits:%d mbf_shf_bits:%d hbf_shf_bits:%d\n",
pSharpCfg->pbf_shf_bits,
pSharpCfg->mbf_shf_bits,
pSharpCfg->hbf_shf_bits);
//0x00d8 - 0x00dc
for(i = 0; i < SHP_SIGMA_SIZE; i++) {
printf("(0x00d8 - 0x00dc) pbf_sigma[%d]:%d \n",
i, pSharpCfg->pbf_sigma[i]);
}
//0x00e0 - 0x00e4
for(i = 0; i < SHP_LUM_CLP_SIZE; i++) {
printf("(0x00e0 - 0x00e4) lum_clp_m[%d]:%d \n",
i, pSharpCfg->lum_clp_m[i]);
}
//0x00e8 - 0x00ec
for(i = 0; i < SHP_LUM_MIN_SIZE; i++) {
printf("(0x00e8 - 0x00ec) lum_min_m[%d]:%d \n",
i, pSharpCfg->lum_min_m[i]);
}
//0x00f0 - 0x00f4
for(i = 0; i < SHP_SIGMA_SIZE; i++) {
printf("(0x00f0 - 0x00f4) mbf_sigma[%d]:%d \n",
i, pSharpCfg->mbf_sigma[i]);
}
//0x00f8 - 0x00fc
for(i = 0; i < SHP_LUM_CLP_SIZE; i++) {
printf("(0x00f8 - 0x00fc) lum_clp_h[%d]:%d \n",
i, pSharpCfg->lum_clp_h[i]);
}
//0x0100 - 0x0104
for(i = 0; i < SHP_SIGMA_SIZE; i++) {
printf("(0x0100 - 0x0104) hbf_sigma[%d]:%d \n",
i, pSharpCfg->hbf_sigma[i]);
}
//0x0108 - 0x010c
for(i = 0; i < SHP_EDGE_LUM_THED_SIZE; i++) {
printf("(0x0108 - 0x010c) edge_lum_thed[%d]:%d \n",
i, pSharpCfg->edge_lum_thed[i]);
}
//0x0110 - 0x0114
for(i = 0; i < SHP_CLAMP_SIZE; i++) {
printf("(0x0110 - 0x0114) clamp_pos[%d]:%d \n",
i, pSharpCfg->clamp_pos[i]);
}
//0x0118 - 0x011c
for(i = 0; i < SHP_CLAMP_SIZE; i++) {
printf("(0x0118 - 0x011c) clamp_neg[%d]:%d \n",
i, pSharpCfg->clamp_neg[i]);
}
//0x0120 - 0x0124
for(i = 0; i < SHP_DETAIL_ALPHA_SIZE; i++) {
printf("(0x0120 - 0x0124) detail_alpha[%d]:%d \n",
i, pSharpCfg->detail_alpha[i]);
}
//0x0128
printf("(0x0128) rfl_ratio:%d rfh_ratio:%d\n",
pSharpCfg->rfl_ratio, pSharpCfg->rfh_ratio);
// mf/hf ratio
//0x012C
printf("(0x012C) m_ratio:%d h_ratio:%d\n",
pSharpCfg->m_ratio, pSharpCfg->h_ratio);
printf("%s:(%d) exit \n", __FUNCTION__, __LINE__);
}
#endif
XCamReturn
CamHwIsp20::setModuleCtl(rk_aiq_module_id_t moduleId, bool en)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
if (_cur_calib_infos.mfnr.enable && _cur_calib_infos.mfnr.motion_detect_en) {
if ((moduleId == RK_MODULE_TNR) && (en == false)) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "motion detect is running, operate not permit!");
return XCAM_RETURN_ERROR_FAILED;
}
}
setModuleStatus(moduleId, en);
return ret;
}
XCamReturn
CamHwIsp20::getModuleCtl(rk_aiq_module_id_t moduleId, bool &en)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
getModuleStatus(moduleId, en);
return ret;
}
XCamReturn CamHwIsp20::notify_capture_raw()
{
#ifndef USE_RAWSTREAM_LIB
if (mRawProcUnit.ptr())
return mRawProcUnit->notify_capture_raw();
else
#endif
return XCAM_RETURN_ERROR_FAILED;
}
XCamReturn CamHwIsp20::capture_raw_ctl(capture_raw_t type, int count, const char* capture_dir, char* output_dir)
{
#ifndef USE_RAWSTREAM_LIB
if (!mRawProcUnit.ptr())
return XCAM_RETURN_ERROR_FAILED;
if (type == CAPTURE_RAW_AND_YUV_SYNC)
return mRawProcUnit->capture_raw_ctl(type);
else if (type == CAPTURE_RAW_SYNC)
return mRawProcUnit->capture_raw_ctl(type, count, capture_dir, output_dir);
#endif
return XCAM_RETURN_ERROR_FAILED;
}
XCamReturn
CamHwIsp20::setIrcutParams(bool on)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
struct v4l2_control control;
xcam_mem_clear (control);
control.id = V4L2_CID_BAND_STOP_FILTER;
if(on)
control.value = IRCUT_STATE_CLOSED;
else
control.value = IRCUT_STATE_OPENED;
if (mIrcutDev.ptr()) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "set ircut value: %d", control.value);
if (mIrcutDev->io_control (VIDIOC_S_CTRL, &control) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "set ircut value failed to device!");
ret = XCAM_RETURN_ERROR_IOCTL;
}
}
EXIT_CAMHW_FUNCTION();
return ret;
}
uint64_t CamHwIsp20::getIspModuleEnState()
{
return _isp_module_ens;
}
XCamReturn CamHwIsp20::setSensorFlip(bool mirror, bool flip, int skip_frm_cnt)
{
BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
XCamReturn ret = XCAM_RETURN_NO_ERROR;
int32_t skip_frame_sequence = 0;
ret = mSensorSubdev->set_mirror_flip(mirror, flip, skip_frame_sequence);
/* struct timespec tp; */
/* clock_gettime(CLOCK_MONOTONIC, &tp); */
/* int64_t skip_ts = (int64_t)(tp.tv_sec) * 1000 * 1000 * 1000 + (int64_t)(tp.tv_nsec); */
#ifndef USE_RAWSTREAM_LIB
if (_state == CAM_HW_STATE_STARTED && skip_frame_sequence != -1) {
mRawCapUnit->skip_frames(skip_frm_cnt, skip_frame_sequence);
}
#endif
return ret;
}
XCamReturn CamHwIsp20::getSensorFlip(bool& mirror, bool& flip)
{
BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
return mSensorSubdev->get_mirror_flip(mirror, flip);
}
XCamReturn CamHwIsp20::setSensorCrop(rk_aiq_rect_t& rect)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
struct v4l2_crop crop;
#ifndef USE_RAWSTREAM_LIB
for (int i = 0; i < 3; i++) {
V4l2Device* mipi_tx = mRawCapUnit->get_tx_device(i).get_cast_ptr<V4l2Device>();
memset(&crop, 0, sizeof(crop));
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (mipi_tx) {
ret = mipi_tx->get_crop(crop);
crop.c.left = rect.left;
crop.c.top = rect.top;
crop.c.width = rect.width;
crop.c.height = rect.height;
ret = mipi_tx->set_crop(crop);
}
}
_crop_rect = rect;
#endif
return ret;
}
XCamReturn CamHwIsp20::getSensorCrop(rk_aiq_rect_t& rect)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
struct v4l2_crop crop;
#ifndef USE_RAWSTREAM_LIB
V4l2Device* mipi_tx = mRawCapUnit->get_tx_device(0).get_cast_ptr<V4l2Device>();
memset(&crop, 0, sizeof(crop));
ret = mipi_tx->get_crop(crop);
rect.left = crop.c.left;
rect.top = crop.c.top;
rect.width = crop.c.width;
rect.height = crop.c.height;
#endif
return ret;
}
void CamHwIsp20::setHdrGlobalTmoMode(uint32_t frame_id, bool mode)
{
if (mNoReadBack)
return;
#ifndef USE_RAWSTREAM_LIB
mRawProcUnit->set_hdr_global_tmo_mode(frame_id, mode);
#endif
}
void CamHwIsp20::setMulCamConc(bool cc)
{
#ifndef USE_RAWSTREAM_LIB
mRawProcUnit->setMulCamConc(cc);
if (cc)
mNoReadBack = false;
#endif
}
void CamHwIsp20::getShareMemOps(isp_drv_share_mem_ops_t** mem_ops)
{
this->alloc_mem = (alloc_mem_t)&CamHwIsp20::allocMemResource;
this->release_mem = (release_mem_t)&CamHwIsp20::releaseMemResource;
this->get_free_item = (get_free_item_t)&CamHwIsp20::getFreeItem;
*mem_ops = this;
}
void CamHwIsp20::allocMemResource(uint8_t id, void *ops_ctx, void *config, void **mem_ctx)
{
int ret = -1;
struct rkispp_fecbuf_info fecbuf_info;
struct rkisp_meshbuf_info cacbuf_info;
struct rkispp_fecbuf_size fecbuf_size;
struct rkisp_meshbuf_size cacbuf_size;
struct rkisp_info2ddr dbgbuf_info;
uint8_t offset = id * ISP3X_MESH_BUF_NUM;
CamHwIsp20 *isp20 = static_cast<CamHwIsp20*>((isp_drv_share_mem_ops_t*)ops_ctx);
rk_aiq_share_mem_config_t* share_mem_cfg = (rk_aiq_share_mem_config_t *)config;
SmartLock locker (isp20->_mem_mutex);
if (share_mem_cfg->mem_type == MEM_TYPE_LDCH) {
#if defined(ISP_HW_V20) || defined(ISP_HW_V21)
struct rkisp_ldchbuf_size ldchbuf_size;
struct rkisp_ldchbuf_info ldchbuf_info;
unsigned long cmd = RKISP_CMD_SET_LDCHBUF_SIZE;
ldchbuf_size.meas_width = share_mem_cfg->alloc_param.width;
ldchbuf_size.meas_height = share_mem_cfg->alloc_param.height;
#else
struct rkisp_meshbuf_info ldchbuf_info;
struct rkisp_meshbuf_size ldchbuf_size;
unsigned long cmd = RKISP_CMD_SET_MESHBUF_SIZE;
ldchbuf_size.unite_isp_id = id;
ldchbuf_size.module_id = ISP3X_MODULE_LDCH;
ldchbuf_size.meas_width = share_mem_cfg->alloc_param.width;
ldchbuf_size.meas_height = share_mem_cfg->alloc_param.height;
ldchbuf_size.buf_cnt = ISP2X_MESH_BUF_NUM;
#endif
ret = isp20->mIspCoreDev->io_control(cmd, &ldchbuf_size);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "alloc ldch buf failed!");
*mem_ctx = nullptr;
return;
}
xcam_mem_clear(ldchbuf_info);
#if defined(ISP_HW_V20) || defined(ISP_HW_V21)
cmd = RKISP_CMD_GET_LDCHBUF_INFO;
#else
ldchbuf_info.unite_isp_id = id;
ldchbuf_info.module_id = ISP3X_MODULE_LDCH;
cmd = RKISP_CMD_GET_MESHBUF_INFO;
#endif
ret = isp20->mIspCoreDev->io_control(cmd, &ldchbuf_info);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to get ldch buf info!!");
*mem_ctx = nullptr;
return;
}
rk_aiq_ldch_share_mem_info_t* mem_info_array =
(rk_aiq_ldch_share_mem_info_t*)(isp20->_ldch_drv_mem_ctx.mem_info);
for (int i = 0; i < ISP2X_MESH_BUF_NUM; i++) {
mem_info_array[offset + i].map_addr =
mmap(NULL, ldchbuf_info.buf_size[i], PROT_READ | PROT_WRITE, MAP_SHARED, ldchbuf_info.buf_fd[i], 0);
if (MAP_FAILED == mem_info_array[offset + i].map_addr)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to map ldch buf!!");
mem_info_array[offset + i].fd = ldchbuf_info.buf_fd[i];
mem_info_array[offset + i].size = ldchbuf_info.buf_size[i];
struct isp2x_mesh_head *head = (struct isp2x_mesh_head*)mem_info_array[offset + i].map_addr;
mem_info_array[offset + i].addr = (void*)((char*)mem_info_array[offset + i].map_addr + head->data_oft);
mem_info_array[offset + i].state = (char*)&head->stat;
}
*mem_ctx = (void*)(&isp20->_ldch_drv_mem_ctx);
#if defined(ISP_HW_V20)
} else if (share_mem_cfg->mem_type == MEM_TYPE_FEC) {
fecbuf_size.meas_width = share_mem_cfg->alloc_param.width;
fecbuf_size.meas_height = share_mem_cfg->alloc_param.height;
fecbuf_size.meas_mode = share_mem_cfg->alloc_param.reserved[0];
ret = isp20->_ispp_sd->io_control(RKISPP_CMD_SET_FECBUF_SIZE, &fecbuf_size);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "alloc fec buf failed!");
*mem_ctx = nullptr;
return;
}
xcam_mem_clear(fecbuf_info);
ret = isp20->_ispp_sd->io_control(RKISPP_CMD_GET_FECBUF_INFO, &fecbuf_info);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to get fec buf info!!");
*mem_ctx = nullptr;
return;
}
rk_aiq_fec_share_mem_info_t* mem_info_array =
(rk_aiq_fec_share_mem_info_t*)(isp20->_fec_drv_mem_ctx.mem_info);
for (int i = 0; i < FEC_MESH_BUF_NUM; i++) {
mem_info_array[i].map_addr =
mmap(NULL, fecbuf_info.buf_size[i], PROT_READ | PROT_WRITE, MAP_SHARED, fecbuf_info.buf_fd[i], 0);
if (MAP_FAILED == mem_info_array[i].map_addr)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to map fec buf!!");
mem_info_array[i].fd = fecbuf_info.buf_fd[i];
mem_info_array[i].size = fecbuf_info.buf_size[i];
struct rkispp_fec_head *head = (struct rkispp_fec_head*)mem_info_array[i].map_addr;
mem_info_array[i].meshxf =
(unsigned char*)mem_info_array[i].map_addr + head->meshxf_oft;
mem_info_array[i].meshyf =
(unsigned char*)mem_info_array[i].map_addr + head->meshyf_oft;
mem_info_array[i].meshxi =
(unsigned short*)((char*)mem_info_array[i].map_addr + head->meshxi_oft);
mem_info_array[i].meshyi =
(unsigned short*)((char*)mem_info_array[i].map_addr + head->meshyi_oft);
mem_info_array[i].state = (char*)&head->stat;
}
*mem_ctx = (void*)(&isp20->_fec_drv_mem_ctx);
#endif
} else if (share_mem_cfg->mem_type == MEM_TYPE_CAC) {
cacbuf_size.unite_isp_id = id;
cacbuf_size.module_id = ISP3X_MODULE_CAC;
cacbuf_size.meas_width = share_mem_cfg->alloc_param.width;
cacbuf_size.meas_height = share_mem_cfg->alloc_param.height;
cacbuf_size.buf_cnt = share_mem_cfg->alloc_param.reserved[0];
ret = isp20->mIspCoreDev->io_control(RKISP_CMD_SET_MESHBUF_SIZE, &cacbuf_size);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "alloc cac buf failed!");
*mem_ctx = nullptr;
return;
}
xcam_mem_clear(cacbuf_info);
cacbuf_info.unite_isp_id = id;
cacbuf_info.module_id = ISP3X_MODULE_CAC;
ret = isp20->mIspCoreDev->io_control(RKISP_CMD_GET_MESHBUF_INFO, &cacbuf_info);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to get cac buf info!!");
*mem_ctx = nullptr;
return;
}
rk_aiq_cac_share_mem_info_t* mem_info_array =
(rk_aiq_cac_share_mem_info_t*)(isp20->_cac_drv_mem_ctx.mem_info);
for (int i = 0; i < cacbuf_size.buf_cnt; i++) {
mem_info_array[offset + i].map_addr =
mmap(NULL, cacbuf_info.buf_size[i], PROT_READ | PROT_WRITE, MAP_SHARED, cacbuf_info.buf_fd[i], 0);
if (MAP_FAILED == mem_info_array[offset + i].map_addr) {
mem_info_array[offset + i].map_addr = NULL;
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to map cac buf!!");
*mem_ctx = nullptr;
return;
}
mem_info_array[offset + i].fd = cacbuf_info.buf_fd[i];
mem_info_array[offset + i].size = cacbuf_info.buf_size[i];
struct isp2x_mesh_head* head = (struct isp2x_mesh_head*)mem_info_array[offset + i].map_addr;
mem_info_array[offset + i].addr = (void*)((char*)mem_info_array[offset + i].map_addr + head->data_oft);
mem_info_array[offset + i].state = (char*)&head->stat;
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "Got CAC LUT fd %d for ISP %d", mem_info_array[offset + i].fd, id);
}
*mem_ctx = (void*)(&isp20->_cac_drv_mem_ctx);
} else if (share_mem_cfg->mem_type == MEM_TYPE_DBG_INFO) {
id = 0;
offset = id * RKISP_INFO2DDR_BUF_MAX;
dbgbuf_info.wsize = share_mem_cfg->alloc_param.width;
dbgbuf_info.vsize = share_mem_cfg->alloc_param.height;
dbgbuf_info.owner = (rkisp_info2ddr_owner)(share_mem_cfg->alloc_param.reserved[0]);
if (dbgbuf_info.owner == RKISP_INFO2DRR_OWNER_AWB) {
dbgbuf_info.u.awb.awb2ddr_sel = share_mem_cfg->alloc_param.reserved[1];
} else if (dbgbuf_info.owner == RKISP_INFO2DRR_OWNER_GAIN) {
dbgbuf_info.u.gain.gain2ddr_mode = share_mem_cfg->alloc_param.reserved[1];
} else {
*mem_ctx = nullptr;
return;
}
dbgbuf_info.buf_cnt = share_mem_cfg->alloc_param.reserved[2];
ret = isp20->mIspCoreDev->io_control(RKISP_CMD_INFO2DDR, &dbgbuf_info);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "alloc dbg buf failed!");
*mem_ctx = nullptr;
return;
}
rk_aiq_dbg_share_mem_info_t* mem_info_array =
(rk_aiq_dbg_share_mem_info_t*)(isp20->_dbg_drv_mem_ctx.mem_info);
for (int i = 0; i < dbgbuf_info.buf_cnt; i++) {
mem_info_array[offset + i].map_addr =
mmap(NULL, dbgbuf_info.wsize * dbgbuf_info.vsize, PROT_READ | PROT_WRITE, MAP_SHARED, dbgbuf_info.buf_fd[i], 0);
if (MAP_FAILED == mem_info_array[offset + i].map_addr) {
mem_info_array[offset + i].map_addr = NULL;
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "failed to map dbg buf!!");
*mem_ctx = nullptr;
return;
}
mem_info_array[offset + i].size = dbgbuf_info.wsize * dbgbuf_info.vsize;
mem_info_array[offset + i].fd = dbgbuf_info.buf_fd[i];
}
*mem_ctx = (void*)(&isp20->_dbg_drv_mem_ctx);
}
}
void CamHwIsp20::releaseMemResource(uint8_t id, void *mem_ctx)
{
int ret = -1;
drv_share_mem_ctx_t* drv_mem_ctx = (drv_share_mem_ctx_t*)mem_ctx;
if (mem_ctx == nullptr) return;
CamHwIsp20 *isp20 = (CamHwIsp20*)(drv_mem_ctx->ops_ctx);
uint8_t offset = id * ISP3X_MESH_BUF_NUM;
uint64_t module_id = 0;
SmartLock locker (isp20->_mem_mutex);
if (drv_mem_ctx->type == MEM_TYPE_LDCH) {
rk_aiq_ldch_share_mem_info_t* mem_info_array =
(rk_aiq_ldch_share_mem_info_t*)(drv_mem_ctx->mem_info);
for (int i = 0; i < ISP2X_MESH_BUF_NUM; i++) {
if (mem_info_array[offset + i].map_addr) {
if (mem_info_array[offset + i].state &&
(MESH_BUF_CHIPINUSE != mem_info_array[offset + i].state[0])) {
mem_info_array[offset + i].state[0] = MESH_BUF_INIT;
}
ret = munmap(mem_info_array[offset + i].map_addr, mem_info_array[offset + i].size);
if (ret < 0)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "munmap ldch buf info!!");
mem_info_array[offset + i].map_addr = NULL;
}
if (mem_info_array[offset + i].fd > 0) {
::close(mem_info_array[offset + i].fd);
mem_info_array[offset + i].fd = -1;
}
}
module_id = ISP2X_MODULE_LDCH;
} else if (drv_mem_ctx->type == MEM_TYPE_FEC) {
rk_aiq_fec_share_mem_info_t* mem_info_array =
(rk_aiq_fec_share_mem_info_t*)(drv_mem_ctx->mem_info);
for (int i = 0; i < FEC_MESH_BUF_NUM; i++) {
if (mem_info_array[i].map_addr) {
if (mem_info_array[i].state &&
(MESH_BUF_CHIPINUSE != mem_info_array[i].state[0])) {
mem_info_array[i].state[0] = MESH_BUF_INIT;
}
ret = munmap(mem_info_array[i].map_addr, mem_info_array[i].size);
if (ret < 0)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "munmap fec buf info!!");
mem_info_array[i].map_addr = NULL;
}
if (mem_info_array[i].fd > 0) {
::close(mem_info_array[i].fd);
mem_info_array[i].fd = -1;
}
}
} else if (drv_mem_ctx->type == MEM_TYPE_CAC) {
rk_aiq_cac_share_mem_info_t* mem_info_array =
(rk_aiq_cac_share_mem_info_t*)(drv_mem_ctx->mem_info);
for (int i = 0; i < ISP3X_MESH_BUF_NUM; i++) {
if (mem_info_array[offset + i].map_addr) {
if (mem_info_array[offset + i].state &&
(MESH_BUF_CHIPINUSE != mem_info_array[offset + i].state[0])) {
mem_info_array[offset + i].state[0] = MESH_BUF_INIT;
}
ret = munmap(mem_info_array[offset + i].map_addr, mem_info_array[offset + i].size);
if (ret < 0)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "munmap cac buf info!!");
mem_info_array[offset + i].map_addr = NULL;
}
if (mem_info_array[offset + i].fd > 0) {
::close(mem_info_array[offset + i].fd);
mem_info_array[offset + i].fd = -1;
}
}
module_id = ISP3X_MODULE_CAC;
} else if (drv_mem_ctx->type == MEM_TYPE_DBG_INFO) {
rk_aiq_dbg_share_mem_info_t* mem_info_array =
(rk_aiq_dbg_share_mem_info_t*)(drv_mem_ctx->mem_info);
if (mem_info_array == nullptr)
return;
struct rkisp_info2ddr info;
info.owner = RKISP_INFO2DRR_OWNER_NULL;
ret = isp20->mIspCoreDev->io_control(RKISP_CMD_INFO2DDR, &info);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "alloc dbg buf failed!");
return;
}
for (int i = 0; i < RKISP_INFO2DDR_BUF_MAX; i++) {
if (mem_info_array[offset + i].map_addr) {
ret = munmap(mem_info_array[offset + i].map_addr, mem_info_array[offset + i].size);
if (ret < 0)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "%dth,munmap dbg buf info!! error:%s, map_addr:%p, size:%d",
i, strerror(errno), mem_info_array[offset + i].map_addr,
mem_info_array[offset + i].size);
mem_info_array[offset + i].map_addr = NULL;
}
if (mem_info_array[offset + i].fd > 0) ::close(mem_info_array[offset + i].fd);
}
}
if (module_id != 0) {
ret = isp20->mIspCoreDev->io_control(RKISP_CMD_MESHBUF_FREE, &module_id);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "free dbg buf failed!");
}
}
}
void*
CamHwIsp20::getFreeItem(uint8_t id, void *mem_ctx)
{
unsigned int idx;
int retry_cnt = 3;
drv_share_mem_ctx_t* drv_mem_ctx = (drv_share_mem_ctx_t*)mem_ctx;
if (!mem_ctx || !drv_mem_ctx->ops_ctx) return nullptr;
CamHwIsp20 *isp20 = (CamHwIsp20*)(drv_mem_ctx->ops_ctx);
uint8_t offset = id * ISP3X_MESH_BUF_NUM;
SmartLock locker (isp20->_mem_mutex);
if (drv_mem_ctx->type == MEM_TYPE_LDCH) {
rk_aiq_ldch_share_mem_info_t* mem_info_array =
(rk_aiq_ldch_share_mem_info_t*)(drv_mem_ctx->mem_info);
do {
for (idx = 0; idx < ISP2X_MESH_BUF_NUM; idx++) {
if (mem_info_array[offset + idx].map_addr) {
if (mem_info_array[offset + idx].state &&
(0 == mem_info_array[offset + idx].state[0])) {
return (void*)&mem_info_array[offset + idx];
}
}
}
} while(retry_cnt--);
} else if (drv_mem_ctx->type == MEM_TYPE_FEC) {
rk_aiq_fec_share_mem_info_t* mem_info_array =
(rk_aiq_fec_share_mem_info_t*)(drv_mem_ctx->mem_info);
if (mem_info_array == nullptr) return nullptr;
do {
for (idx = 0; idx < FEC_MESH_BUF_NUM; idx++) {
if (mem_info_array[idx].map_addr) {
if (mem_info_array[idx].state && (0 == mem_info_array[idx].state[0])) {
return (void*)&mem_info_array[idx];
}
}
}
} while(retry_cnt--);
} else if (drv_mem_ctx->type == MEM_TYPE_CAC) {
rk_aiq_cac_share_mem_info_t* mem_info_array =
(rk_aiq_cac_share_mem_info_t*)(drv_mem_ctx->mem_info);
if (mem_info_array == nullptr) return nullptr;
do {
for (idx = 0; idx < ISP3X_MESH_BUF_NUM; idx++) {
if (mem_info_array[offset + idx].map_addr != nullptr) {
if (-1 != mem_info_array[offset + idx].fd) {
return (void*)&mem_info_array[offset + idx];
}
}
}
} while(retry_cnt--);
} else if (drv_mem_ctx->type == MEM_TYPE_DBG_INFO) {
rk_aiq_dbg_share_mem_info_t* mem_info_array =
(rk_aiq_dbg_share_mem_info_t*)(drv_mem_ctx->mem_info);
if (mem_info_array == nullptr) return nullptr;
do {
for (idx = 0; idx < RKISP_INFO2DDR_BUF_MAX; idx++) {
if (mem_info_array[offset + idx].map_addr) {
uint32_t state = *(uint32_t*)(mem_info_array[offset + idx].map_addr);
if (state == RKISP_INFO2DDR_BUF_INIT)
return (void*)&mem_info_array[offset + idx];
}
}
} while(retry_cnt--);
}
return NULL;
}
XCamReturn
CamHwIsp20::poll_event_ready (uint32_t sequence, int type)
{
// if (type == V4L2_EVENT_FRAME_SYNC && mIspEvtsListener) {
// SmartPtr<SensorHw> mSensor = mSensorDev.dynamic_cast_ptr<SensorHw>();
// SmartPtr<Isp20Evt> evtInfo = new Isp20Evt(this, mSensor);
// evtInfo->evt_code = type;
// evtInfo->sequence = sequence;
// evtInfo->expDelay = _exp_delay;
// return mIspEvtsListener->ispEvtsCb(evtInfo);
// }
return XCAM_RETURN_NO_ERROR;
}
SmartPtr<ispHwEvt_t>
CamHwIsp20::make_ispHwEvt (uint32_t sequence, int type, int64_t timestamp)
{
if (type == V4L2_EVENT_FRAME_SYNC) {
SmartPtr<SensorHw> mSensor = mSensorDev.dynamic_cast_ptr<SensorHw>();
SmartPtr<Isp20Evt> evtInfo = new Isp20Evt(this, mSensor);
evtInfo->evt_code = type;
evtInfo->sequence = sequence;
evtInfo->expDelay = _exp_delay;
evtInfo->setSofTimeStamp(timestamp);
return evtInfo;
}
return nullptr;
}
XCamReturn
CamHwIsp20::poll_event_failed (int64_t timestamp, const char *msg)
{
return XCAM_RETURN_ERROR_FAILED;
}
XCamReturn
CamHwIsp20::applyAnalyzerResult(SmartPtr<SharedItemBase> base, bool sync)
{
return dispatchResult(base);
}
XCamReturn
CamHwIsp20::applyAnalyzerResult(cam3aResultList& list)
{
return dispatchResult(list);
}
XCamReturn
CamHwIsp20::dispatchResult(cam3aResultList& list)
{
cam3aResultList isp_result_list;
for (auto& result : list) {
switch (result->getType()) {
case RESULT_TYPE_AEC_PARAM:
case RESULT_TYPE_HIST_PARAM:
case RESULT_TYPE_AWB_PARAM:
case RESULT_TYPE_AWBGAIN_PARAM:
case RESULT_TYPE_AF_PARAM:
case RESULT_TYPE_DPCC_PARAM:
case RESULT_TYPE_MERGE_PARAM:
case RESULT_TYPE_TMO_PARAM:
case RESULT_TYPE_CCM_PARAM:
case RESULT_TYPE_LSC_PARAM:
case RESULT_TYPE_BLC_PARAM:
case RESULT_TYPE_RAWNR_PARAM:
case RESULT_TYPE_GIC_PARAM:
case RESULT_TYPE_DEBAYER_PARAM:
case RESULT_TYPE_LDCH_PARAM:
case RESULT_TYPE_LUT3D_PARAM:
case RESULT_TYPE_DEHAZE_PARAM:
case RESULT_TYPE_AGAMMA_PARAM:
case RESULT_TYPE_ADEGAMMA_PARAM:
case RESULT_TYPE_WDR_PARAM:
case RESULT_TYPE_CSM_PARAM:
case RESULT_TYPE_CGC_PARAM:
case RESULT_TYPE_CONV422_PARAM:
case RESULT_TYPE_YUVCONV_PARAM:
case RESULT_TYPE_GAIN_PARAM:
case RESULT_TYPE_CP_PARAM:
case RESULT_TYPE_IE_PARAM:
case RESULT_TYPE_MOTION_PARAM:
isp_result_list.push_back(result);
break;
default:
dispatchResult(result);
break;
}
}
if (isp_result_list.size() > 0) {
handleIsp3aReslut(isp_result_list);
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CamHwIsp20::handleIsp3aReslut(cam3aResultList& list)
{
ENTER_CAMHW_FUNCTION();
XCamReturn ret = XCAM_RETURN_NO_ERROR;
if (_is_exit) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "set 3a config bypass since ia engine has stop");
return XCAM_RETURN_BYPASS;
}
bool restart = false;
if (_state == CAM_HW_STATE_PREPARED || _state == CAM_HW_STATE_STOPPED ||
_state == CAM_HW_STATE_PAUSED) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "hdr-debug: %s: first set ispparams\n",
__func__);
if (!mIspParamsDev->is_activated()) {
ret = mIspParamsDev->start();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "prepare isp params dev err: %d\n", ret);
}
ret = hdr_mipi_prepare_mode(_hdr_mode);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
}
}
for (auto& result : list) {
result->setId(0);
#ifndef DISABLE_PARAMS_ASSEMBLER
mParamsAssembler->addReadyCondition(result->getType());
#endif
}
restart = true;
}
#ifndef DISABLE_PARAMS_ASSEMBLER
mParamsAssembler->queue(list);
// set all ready params to drv
while (_state == CAM_HW_STATE_STARTED &&
mParamsAssembler->ready()) {
SmartLock locker(_stop_cond_mutex);
if (_isp_stream_status != ISP_STREAM_STATUS_STREAM_OFF) {
ret = setIspConfig();
if (ret != XCAM_RETURN_NO_ERROR)
break;
} else {
break;
}
}
#else
SmartLock locker(_stop_cond_mutex);
if (_isp_stream_status != ISP_STREAM_STATUS_STREAM_OFF || restart) {
ret = setIspConfig(&list);
}
#endif
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
CamHwIsp20::dispatchResult(SmartPtr<cam3aResult> result)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
if (!result.ptr())
return XCAM_RETURN_ERROR_PARAM;
LOG1("%s enter, msg type(0x%x)", __FUNCTION__, result->getType());
switch (result->getType())
{
case RESULT_TYPE_EXPOSURE_PARAM:
{
SmartPtr<RkAiqExpParamsProxy> exp = result.dynamic_cast_ptr<RkAiqExpParamsProxy>();
ret = setExposureParams(exp);
if (ret)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setExposureParams error %d id %d", ret, result->getId());
break;
}
case RESULT_TYPE_AEC_PARAM:
case RESULT_TYPE_HIST_PARAM:
case RESULT_TYPE_AWB_PARAM:
case RESULT_TYPE_AWBGAIN_PARAM:
case RESULT_TYPE_AF_PARAM:
case RESULT_TYPE_DPCC_PARAM:
case RESULT_TYPE_MERGE_PARAM:
case RESULT_TYPE_TMO_PARAM:
case RESULT_TYPE_CCM_PARAM:
case RESULT_TYPE_LSC_PARAM:
case RESULT_TYPE_BLC_PARAM:
case RESULT_TYPE_RAWNR_PARAM:
case RESULT_TYPE_GIC_PARAM:
case RESULT_TYPE_DEBAYER_PARAM:
case RESULT_TYPE_LDCH_PARAM:
case RESULT_TYPE_LUT3D_PARAM:
case RESULT_TYPE_DEHAZE_PARAM:
case RESULT_TYPE_AGAMMA_PARAM:
case RESULT_TYPE_ADEGAMMA_PARAM:
case RESULT_TYPE_WDR_PARAM:
case RESULT_TYPE_CSM_PARAM:
case RESULT_TYPE_CGC_PARAM:
case RESULT_TYPE_CONV422_PARAM:
case RESULT_TYPE_YUVCONV_PARAM:
case RESULT_TYPE_GAIN_PARAM:
case RESULT_TYPE_CP_PARAM:
case RESULT_TYPE_IE_PARAM:
case RESULT_TYPE_MOTION_PARAM:
case RESULT_TYPE_CAC_PARAM:
handleIsp3aReslut(result);
break;
case RESULT_TYPE_TNR_PARAM:
case RESULT_TYPE_YNR_PARAM:
case RESULT_TYPE_UVNR_PARAM:
case RESULT_TYPE_SHARPEN_PARAM:
case RESULT_TYPE_EDGEFLT_PARAM:
case RESULT_TYPE_FEC_PARAM:
case RESULT_TYPE_ORB_PARAM:
#if defined(ISP_HW_V20)
handlePpReslut(result);
#endif
break;
case RESULT_TYPE_FOCUS_PARAM:
{
SmartPtr<RkAiqFocusParamsProxy> focus = result.dynamic_cast_ptr<RkAiqFocusParamsProxy>();
ret = setFocusParams(focus);
if (ret)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setFocusParams error %d", ret);
break;
}
case RESULT_TYPE_IRIS_PARAM:
{
SmartPtr<RkAiqIrisParamsProxy> iris = result.dynamic_cast_ptr<RkAiqIrisParamsProxy>();
ret = setIrisParams(iris, _cur_calib_infos.aec.IrisType);
if (ret)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setIrisParams error %d", ret);
ret = getIrisParams(iris, _cur_calib_infos.aec.IrisType);
if (ret)
LOGE_ANALYZER("getIrisParams error %d", ret);
break;
}
case RESULT_TYPE_CPSL_PARAM:
{
SmartPtr<RkAiqCpslParamsProxy> cpsl = result.dynamic_cast_ptr<RkAiqCpslParamsProxy>();
ret = setCpslParams(cpsl);
if (ret)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setCpslParams error %d", ret);
break;
}
case RESULT_TYPE_FLASH_PARAM:
{
#ifdef FLASH_CTL_DEBUG
SmartPtr<rk_aiq_flash_setting_t> flash = result.dynamic_cast_ptr<rk_aiq_flash_setting_t>();
ret = setFlParams(flash);
if (ret)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setFlParams error %d", ret);
#endif
break;
}
case RESULT_TYPE_AFD_PARAM:
{
SmartPtr<RkAiqIspAfdParamsProxy> afd = result.dynamic_cast_ptr<RkAiqIspAfdParamsProxy>();
if (mCifScaleStream.ptr()) {
bool enable = afd->data()->result.enable;
int ratio = afd->data()->result.ratio;
setCifSclStartFlag(ratio, enable);
}
break;
}
default:
LOGE("unknown param type(0x%x)!", result->getType());
break;
}
return ret;
LOGD("%s exit", __FUNCTION__);
}
XCamReturn CamHwIsp20::notify_sof(SmartPtr<VideoBuffer>& buf)
{
SmartPtr<SofEventBuffer> evtbuf = buf.dynamic_cast_ptr<SofEventBuffer>();
SmartPtr<SofEventData> evtdata = evtbuf->get_data();
BaseSensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<BaseSensorHw>();
LensHw* mLensSubdev = mLensDev.get_cast_ptr<LensHw>();
mSensorSubdev->handle_sof(evtdata->_timestamp, evtdata->_frameid);
#ifndef USE_RAWSTREAM_LIB
if (!mNoReadBack)
mRawProcUnit->notify_sof(evtdata->_timestamp, evtdata->_frameid);
#endif
if (mLensSubdev)
mLensSubdev->handle_sof(evtdata->_timestamp, evtdata->_frameid);
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CamHwIsp20::handleIsp3aReslut(SmartPtr<cam3aResult> &result)
{
ENTER_CAMHW_FUNCTION();
XCamReturn ret = XCAM_RETURN_NO_ERROR;
if (_is_exit) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "set 3a config bypass since ia engine has stop");
return XCAM_RETURN_BYPASS;
}
if (_state == CAM_HW_STATE_PREPARED || _state == CAM_HW_STATE_STOPPED ||
_state == CAM_HW_STATE_PAUSED) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "hdr-debug: %s: first set ispparams id[%d]\n",
__func__, result->getId());
if (!mIspParamsDev->is_activated()) {
ret = mIspParamsDev->start();
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "prepare isp params dev err: %d\n", ret);
}
ret = hdr_mipi_prepare_mode(_hdr_mode);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
}
}
#ifndef DISABLE_PARAMS_ASSEMBLER
mParamsAssembler->addReadyCondition(result->getType());
#endif
}
#ifndef DISABLE_PARAMS_ASSEMBLER
mParamsAssembler->queue(result);
// set all ready params to drv
while (_state == CAM_HW_STATE_STARTED &&
mParamsAssembler->ready()) {
SmartLock locker(_stop_cond_mutex);
if (_isp_stream_status != ISP_STREAM_STATUS_STREAM_OFF) {
ret = setIspConfig();
if (ret != XCAM_RETURN_NO_ERROR)
break;
} else {
break;
}
}
#else
SmartLock locker(_stop_cond_mutex);
if (_isp_stream_status != ISP_STREAM_STATUS_STREAM_OFF) {
ret = setIspConfig();
if (ret != XCAM_RETURN_NO_ERROR) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "setIspConfig failed !");
}
}
#endif
EXIT_CAMHW_FUNCTION();
return ret;
}
void
CamHwIsp20::analyzePpInitEns(SmartPtr<cam3aResult> &result)
{
if (result->getType() == RESULT_TYPE_TNR_PARAM) {
// TODO: tnr init_ens should be always on ?
RkAiqIspTnrParamsProxy* tnr = nullptr;
tnr = result.get_cast_ptr<RkAiqIspTnrParamsProxy>();
if (tnr) {
rk_aiq_isp_tnr_t& tnr_param = tnr->data()->result;
if(tnr_param.tnr_en) {
if (tnr_param.mode > 0)
mPpModuleInitEns |= ISPP_MODULE_TNR_3TO1;
else
mPpModuleInitEns |= ISPP_MODULE_TNR;
} else {
mPpModuleInitEns &= ~ISPP_MODULE_TNR_3TO1;
}
}
} else if (result->getType() == RESULT_TYPE_FEC_PARAM) {
RkAiqIspFecParamsProxy* fec = nullptr;
fec = result.get_cast_ptr<RkAiqIspFecParamsProxy>();
if (fec) {
rk_aiq_isp_fec_t& fec_param = fec->data()->result;
if(fec_param.sw_fec_en) {
if (fec_param.usage == ISPP_MODULE_FEC_ST) {
mPpModuleInitEns |= ISPP_MODULE_FEC_ST;
} else if (fec_param.usage == ISPP_MODULE_FEC) {
mPpModuleInitEns |= ISPP_MODULE_FEC;
}
} else {
mPpModuleInitEns &= ~ISPP_MODULE_FEC_ST;
}
}
} else if (result->getType() == RESULT_TYPE_EDGEFLT_PARAM ||
result->getType() == RESULT_TYPE_YNR_PARAM ||
result->getType() == RESULT_TYPE_UVNR_PARAM ||
result->getType() == RESULT_TYPE_SHARPEN_PARAM) {
// TODO: nr,sharp init_ens always on ?
mPpModuleInitEns |= ISPP_MODULE_SHP | ISPP_MODULE_NR;
} else if (result->getType() == RESULT_TYPE_ORB_PARAM) {
RkAiqIspOrbParamsProxy* orb = nullptr;
orb = result.get_cast_ptr<RkAiqIspOrbParamsProxy>();
if (orb) {
rk_aiq_isp_orb_t& orb_param = orb->data()->result;
if(orb_param.orb_en)
mPpModuleInitEns |= ISPP_MODULE_ORB;
else
mPpModuleInitEns &= ~ISPP_MODULE_ORB;
}
}
}
#if defined(ISP_HW_V20)
XCamReturn
CamHwIsp20::handlePpReslut(SmartPtr<cam3aResult> &result)
{
ENTER_CAMHW_FUNCTION();
XCamReturn ret = XCAM_RETURN_NO_ERROR;
if (_is_exit) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "set pp config bypass since ia engine has stop");
return XCAM_RETURN_BYPASS;
}
if (_state == CAM_HW_STATE_PREPARED || _state == CAM_HW_STATE_STOPPED ||
_state == CAM_HW_STATE_PAUSED) {
LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKISPP_CMD_SET_INIT_MODULE");
analyzePpInitEns(result);
if (_ispp_sd->io_control(RKISPP_CMD_SET_INIT_MODULE, &mPpModuleInitEns))
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "RKISPP_CMD_SET_INIT_MODULE ioctl failed");
}
setPpConfig(result);
EXIT_CAMHW_FUNCTION();
return ret;
}
#endif
bool CamHwIsp20::getParamsForEffMap(uint32_t frameId)
{
if (_effecting_ispparam_map.count(frameId) <= 0) {
if (mEffectIspParamsPool->has_free_items()) {
_effecting_ispparam_map[frameId] = mEffectIspParamsPool->get_item();
return true;
} else {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "no free eff ispparam");
return false;
}
}
return true;
}
XCamReturn
CamHwIsp20::setIspConfig(cam3aResultList* result_list)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
SmartPtr<V4l2Buffer> v4l2buf;
uint32_t frameId = -1;
{
SmartLock locker(_isp_params_cfg_mutex);
while (_effecting_ispparam_map.size() > 4)
_effecting_ispparam_map.erase(_effecting_ispparam_map.begin());
}
if (mIspParamsDev.ptr()) {
ret = mIspParamsDev->get_buffer(v4l2buf);
if (ret) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "Can not get isp params buffer, queued cnts:%d \n",
mIspParamsDev->get_queued_bufcnt());
return XCAM_RETURN_ERROR_PARAM;
}
} else
return XCAM_RETURN_BYPASS;
#ifndef DISABLE_PARAMS_ASSEMBLER
cam3aResultList ready_results;
ret = mParamsAssembler->deQueOne(ready_results, frameId);
if (ret != XCAM_RETURN_NO_ERROR) {
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "deque isp ready parameter failed\n");
mIspParamsDev->return_buffer_to_pool(v4l2buf);
return XCAM_RETURN_ERROR_PARAM;
}
#else
cam3aResultList& ready_results = *result_list;
frameId = (*ready_results.begin())->getId();
#endif
LOGD_CAMHW("----------%s, cam%d start config id(%d)'s isp params", __FUNCTION__, mCamPhyId, frameId);
// add isp dgain results to ready results
SensorHw* mSensorSubdev = mSensorDev.get_cast_ptr<SensorHw>();
if (mSensorSubdev) {
SmartPtr<RkAiqSensorExpParamsProxy> expParam;
if (mSensorSubdev->getEffectiveExpParams(expParam, frameId) < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "frame_id(%d), get exposure failed!!!\n", frameId);
} else {
expParam->setType(RESULT_TYPE_EXPOSURE_PARAM);
ready_results.push_back(expParam);
}
}
if (v4l2buf.ptr()) {
#if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
struct isp32_isp_params_cfg* isp_params =
(struct isp32_isp_params_cfg*)v4l2buf->get_buf().m.userptr;
#elif defined(ISP_HW_V30)
struct isp3x_isp_params_cfg* isp_params =
(struct isp3x_isp_params_cfg*)v4l2buf->get_buf().m.userptr;
#elif defined(ISP_HW_V21)
struct isp21_isp_params_cfg* isp_params =
(struct isp21_isp_params_cfg*)v4l2buf->get_buf().m.userptr;
#else
struct isp20_isp_params_cfg* isp_params =
(struct isp20_isp_params_cfg*)v4l2buf->get_buf().m.userptr;
#endif
int buf_index = v4l2buf->get_buf().index;
bool isMultiIsp = mIsMultiIspMode;
bool extened_pixel = mMultiIspExtendedPixel;
isp_params->module_en_update = 0;
isp_params->module_cfg_update = 0;
isp_params->module_ens = 0;
if (merge_isp_results(ready_results, isp_params, mIsMultiIspMode) != XCAM_RETURN_NO_ERROR)
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "ISP parameter translation error\n");
if (isp_params->module_cfg_update == 0 &&
isp_params->module_en_update == 0) {
mIspParamsDev->return_buffer_to_pool(v4l2buf);
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "no new ISP parameters to drv");
return ret;
}
isp_params->module_cfg_update |= ISP32_MODULE_FORCE;
// TODO: isp driver has bug now, lsc cfg_up should be set along with
// en_up
if (isp_params->module_cfg_update & ISP2X_MODULE_LSC)
isp_params->module_en_update |= ISP2X_MODULE_LSC;
isp_params->frame_id = frameId;
#if defined(ISP_HW_V30)
if(mIsMultiIspMode == false) {
dynamic_cast<Isp3xParams*>(this)->fixedAwbOveflowToIsp3xParams(isp_params, mIsMultiIspMode);
}
#endif
#if defined(RKAIQ_HAVE_MULTIISP) && defined(ISP_HW_V30)
struct isp3x_isp_params_cfg ori_params;
if (mIsMultiIspMode) {
ori_params = *isp_params;
mParamsSplitter->SplitIspParams(&ori_params, isp_params);
dynamic_cast<Isp3xParams*>(this)->fixedAwbOveflowToIsp3xParams((void*)isp_params, mIsMultiIspMode);
}
#endif
#if defined(RKAIQ_HAVE_MULTIISP) && defined(ISP_HW_V32)
struct isp32_isp_params_cfg ori_params;
if (mIsMultiIspMode) {
ori_params = *isp_params;
mParamsSplitter->SplitIspParams(&ori_params, isp_params);
}
#endif
#if defined(RKAIQ_ENABLE_SPSTREAM)
if (mAfParams) {
RkAiqIspAfParamsProxy* afParams =
mAfParams.get_cast_ptr<RkAiqIspAfParamsProxy>();
if (mSpStreamUnit.ptr()) {
mSpStreamUnit->update_af_meas_params(&afParams->data()->result);
}
}
#endif
#if defined(RKAIQ_HAVE_MULTIISP) && (defined(ISP_HW_V30) || defined(ISP_HW_V32))
if (mIsMultiIspMode)
updateEffParams(isp_params, &ori_params);
else
updateEffParams(isp_params, NULL);
#else
updateEffParams(isp_params, NULL);
#endif
bool is_wait_params_done = false;
if (mTbInfo.prd_type != RK_AIQ_PRD_TYPE_NORMAL) {
// skip the params
if (processTb(isp_params)) {
mIspParamsDev->return_buffer_to_pool(v4l2buf);
return XCAM_RETURN_NO_ERROR;
}
if (mTbInfo.is_pre_aiq && frameId == 0)
is_wait_params_done = true;
}
if (mIspParamsDev->queue_buffer(v4l2buf) != 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM,
"RKISP1: failed to ioctl VIDIOC_QBUF for index %d, %d %s.\n", buf_index,
errno, strerror(errno));
mIspParamsDev->return_buffer_to_pool(v4l2buf);
return XCAM_RETURN_ERROR_IOCTL;
}
#ifdef DISABLE_PARAMS_POLL_THREAD
int timeout = is_wait_params_done ? 100 : 1;
int buf_counts = mIspParamsDev->get_buffer_count ();
int try_time = 3;
while (mIspParamsDev->get_queued_bufcnt() > 2 || is_wait_params_done) {
if (mIspParamsDev->poll_event (timeout, -1) <= 0) {
LOGW_CAMHW_SUBM(ISP20HW_SUBM, "poll params error, queue cnts: %d !",
mIspParamsDev->get_queued_bufcnt());
if (mIspParamsDev->get_queued_bufcnt() == buf_counts && try_time > 0) {
timeout = 30;
try_time--;
continue;
} else
break;
}
SmartPtr<V4l2Buffer> buf;
ret = mIspParamsDev->dequeue_buffer (buf);
if (ret != XCAM_RETURN_NO_ERROR) {
XCAM_LOG_WARNING ("dequeue buffer failed");
//return ret;
} else {
if (is_wait_params_done) {
is_wait_params_done = false;
SmartPtr<VideoBuffer> video_buf = new V4l2BufferProxy (buf, mIspParamsDev);
video_buf->_buf_type = ISP_POLL_PARAMS;
LOGK_CAMHW("<TB> poll param id:%d, call err_cb", frameId);
CamHwBase::poll_buffer_ready(video_buf);
}
mIspParamsDev->return_buffer_to_pool(buf);
}
}
#endif
_isp_module_ens |= isp_params->module_ens & isp_params->module_en_update;
LOGD_CAMHW_SUBM(
ISP20HW_SUBM,
"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,
_isp_module_ens,
isp_params->module_ens,
isp_params->module_en_update,
isp_params->module_cfg_update);
LOGD_CAMHW_SUBM(
ISP20HW_SUBM,
"device(%s) queue buffer index %d, queue cnt %d, check exit status again[exit: %d]",
XCAM_STR(mIspParamsDev->get_device_name()), buf_index,
mIspParamsDev->get_queued_bufcnt(), _is_exit);
if (_is_exit) return XCAM_RETURN_BYPASS;
} else
return XCAM_RETURN_BYPASS;
EXIT_CAMHW_FUNCTION();
return ret;
}
#if defined(ISP_HW_V20)
XCamReturn
CamHwIsp20::setPpConfig(SmartPtr<cam3aResult> &result)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_CAMHW_FUNCTION();
if (result->getType() == RESULT_TYPE_TNR_PARAM) {
ret = mTnrStreamProcUnit->config_params(result->getId(), result);
} else if (result->getType() == RESULT_TYPE_FEC_PARAM)
ret = mFecParamStream->config_params(result->getId(), result);
else if (result->getType() == RESULT_TYPE_EDGEFLT_PARAM ||
result->getType() == RESULT_TYPE_YNR_PARAM ||
result->getType() == RESULT_TYPE_UVNR_PARAM ||
result->getType() == RESULT_TYPE_SHARPEN_PARAM ||
result->getType() == RESULT_TYPE_ORB_PARAM) {
ret = mNrStreamProcUnit->config_params(result->getId(), result);
}
EXIT_CAMHW_FUNCTION();
return ret;
}
#endif
SmartPtr<cam3aResult>
CamHwIsp20::get_3a_module_result (cam3aResultList &results, int32_t type)
{
cam3aResultList::iterator i_res = results.begin();
SmartPtr<cam3aResult> res;
auto it = std::find_if(
results.begin(), results.end(),
[&](const SmartPtr<cam3aResult> &r) {
return type == r->getType();
});
if (it != results.end()) {
res = *it;
}
return res;
}
XCamReturn CamHwIsp20::get_stream_format(rkaiq_stream_type_t type, struct v4l2_format &format)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
switch (type)
{
case RKISP20_STREAM_MIPITX_S:
case RKISP20_STREAM_MIPITX_M:
case RKISP20_STREAM_MIPITX_L:
{
memset(&format, 0, sizeof(format));
#ifndef USE_RAWSTREAM_LIB
ret = mRawCapUnit->get_tx_device(0)->get_format(format);
#endif
break;
}
case RKISP20_STREAM_SP:
case RKISP20_STREAM_NR:
{
struct v4l2_subdev_format isp_fmt;
isp_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
isp_fmt.pad = 2;
ret = mIspCoreDev->getFormat(isp_fmt);
if (ret == XCAM_RETURN_NO_ERROR) {
BaseSensorHw* sensorHw;
sensorHw = mSensorDev.get_cast_ptr<BaseSensorHw>();
format.fmt.pix.width = isp_fmt.format.width;
format.fmt.pix.height = isp_fmt.format.height;
format.fmt.pix.pixelformat = get_v4l2_pixelformat(isp_fmt.format.code);
}
break;
}
default:
ret = XCAM_RETURN_ERROR_PARAM;
break;
}
return ret;
}
XCamReturn CamHwIsp20::get_sp_resolution(int &width, int &height, int &aligned_w, int &aligned_h)
{
#if defined(RKAIQ_ENABLE_SPSTREAM)
return mSpStreamUnit->get_sp_resolution(width, height, aligned_w, aligned_h);
#else
return XCAM_RETURN_NO_ERROR;
#endif
}
#if RKAIQ_HAVE_PDAF
bool CamHwIsp20::get_pdaf_support()
{
bool pdaf_support = false;
if (mPdafStreamUnit.ptr())
pdaf_support = mPdafInfo.pdaf_support;
return pdaf_support;
}
#endif
void CamHwIsp20::notify_isp_stream_status(bool on)
{
if (on) {
LOGK_CAMHW_SUBM(ISP20HW_SUBM, "camId:%d, %s on", mCamPhyId, __func__);
XCamReturn ret = hdr_mipi_start_mode(_hdr_mode);
if (ret < 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "hdr mipi start err: %d\n", ret);
}
_isp_stream_status = ISP_STREAM_STATUS_STREAM_ON;
if (mHwResLintener) {
SmartPtr<Isp20Evt> ispEvt =
new Isp20Evt(this, mSensorDev.dynamic_cast_ptr<SensorHw>());
SmartPtr<V4l2Device> dev(NULL);
SmartPtr<Isp20EvtBuffer> ispEvtbuf =
new Isp20EvtBuffer(ispEvt, dev);
ispEvtbuf->_buf_type = VICAP_STREAM_ON_EVT;
SmartPtr<VideoBuffer> vbuf = ispEvtbuf.dynamic_cast_ptr<VideoBuffer>();
// FIXME: [Baron] 2022-06-29, all rx started, tx start
if (!_linked_to_1608) {
mHwResLintener->hwResCb(vbuf);
} else {
waitLastSensorDone();
mHwResLintener->hwResCb(vbuf);
}
}
} else {
LOGK_CAMHW_SUBM(ISP20HW_SUBM, "camId:%d, %s off", mCamPhyId, __func__);
_isp_stream_status = ISP_STREAM_STATUS_STREAM_OFF;
// if CIFISP_V4L2_EVENT_STREAM_STOP event is listened, isp driver
// will wait isp params streaming off
{
SmartLock locker(_stop_cond_mutex);
#ifndef DISABLE_PARAMS_POLL_THREAD
if (mIspParamStream.ptr())
mIspParamStream->stop();
#else
if (mIspParamsDev.ptr())
mIspParamsDev->stop();
#endif
}
hdr_mipi_stop();
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "camId:%d, %s off done", mCamPhyId, __func__);
}
}
XCamReturn CamHwIsp20::reset_hardware()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
#ifndef USE_RAWSTREAM_LIB
if (mRawCapUnit.ptr()) {
ret = mRawCapUnit->reset_hardware();
}
#endif
return ret;
}
XCamReturn
CamHwIsp20::waitLastSensorDone()
{
SmartLock lock (_sync_1608_mutex);
while (!_sync_1608_done) {
_sync_done_cond.timedwait(_sync_1608_mutex, 100000ULL);
}
return XCamReturn();
}
XCamReturn
CamHwIsp20::pixFmt2Bpp(uint32_t pixFmt, int8_t& bpp)
{
switch (pixFmt) {
case V4L2_PIX_FMT_SBGGR8:
case V4L2_PIX_FMT_SGBRG8:
case V4L2_PIX_FMT_SGRBG8:
case V4L2_PIX_FMT_SRGGB8:
bpp = 8;
break;
case V4L2_PIX_FMT_SBGGR10:
case V4L2_PIX_FMT_SGBRG10:
case V4L2_PIX_FMT_SGRBG10:
case V4L2_PIX_FMT_SRGGB10:
bpp = 10;
break;
case V4L2_PIX_FMT_SBGGR12:
case V4L2_PIX_FMT_SGBRG12:
case V4L2_PIX_FMT_SGRBG12:
case V4L2_PIX_FMT_SRGGB12:
bpp = 12;
break;
case V4L2_PIX_FMT_SBGGR14:
case V4L2_PIX_FMT_SGBRG14:
case V4L2_PIX_FMT_SGRBG14:
case V4L2_PIX_FMT_SRGGB14:
bpp = 14;
break;
case V4L2_PIX_FMT_SBGGR16:
case V4L2_PIX_FMT_SGBRG16:
case V4L2_PIX_FMT_SGRBG16:
case V4L2_PIX_FMT_SRGGB16:
bpp = 16;
break;
default:
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "unknown format");
return XCAM_RETURN_ERROR_PARAM;
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CamHwIsp20::rawReproc_genIspParams (uint32_t sequence, rk_aiq_frame_info_t *offline_finfo, int mode)
{
XCamReturn ret;
if (mode) {
if (offline_finfo) {
SensorHw* mSensor = mSensorDev.get_cast_ptr<SensorHw>();
ret = mSensor->set_offline_effecting_exp_map(sequence + 1, offline_finfo);
}
struct v4l2_event event;
event.u.frame_sync.frame_sequence = sequence;
mIspSofStream->stop();
SmartPtr<VideoBuffer> buf =
mIspSofStream->new_video_buffer(event, NULL);
CamHwBase::poll_buffer_ready(buf);
} else {
// wait until params of frame index 'sequence' have been done
int8_t wait_times = 100;
while ((sequence > _curIspParamsSeq) && (wait_times-- > 0)) {
usleep(10 * 1000);
}
if (wait_times == 0) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "wait params %d(cur:%d) done over 1 seconds !", sequence, _curIspParamsSeq);
} else {
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "wait params %d(cur:%d) success !", sequence, _curIspParamsSeq);
}
}
return XCAM_RETURN_NO_ERROR;
}
const char*
CamHwIsp20::rawReproc_preInit(const char* isp_driver, const char* offline_sns_ent_name)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ENTER_XCORE_FUNCTION();
int isp_driver_index = -1;
if (!isp_driver) {
return NULL;
} else {
#ifdef ISP_HW_V30
char* isp_driver_name = const_cast<char*>(isp_driver);
char *rkisp = strstr(isp_driver_name, "rkisp");
if (rkisp) {
int isp_mode = atoi(rkisp + strlen("rkisp"));
char* vir = strstr(isp_driver_name, "vir");
if (vir) {
int vir_idx = atoi(vir + strlen("vir"));
isp_driver_index = isp_mode * 4 + vir_idx;
}
}
#else
if (strcmp(isp_driver, "rkisp0") == 0 ||
strcmp(isp_driver, "rkisp") == 0)
isp_driver_index = 0;
else if (strcmp(isp_driver, "rkisp1") == 0)
isp_driver_index = 1;
else if (strcmp(isp_driver, "rkisp2") == 0)
isp_driver_index = 2;
else if (strcmp(isp_driver, "rkisp3") == 0)
isp_driver_index = 3;
else
isp_driver_index = -1;
#endif
}
std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t> >::iterator iter;
std::unordered_map<std::string, SmartPtr<rk_aiq_static_info_t> >::iterator iter_info;
for (iter = CamHwIsp20::mSensorHwInfos.begin(); \
iter != CamHwIsp20::mSensorHwInfos.end(); iter++) {
rk_sensor_full_info_t *s_full_info_f = iter->second.ptr();
if (s_full_info_f->isp_info) {
if (s_full_info_f->isp_info->model_idx != isp_driver_index) {
continue;
}
rk_sensor_full_info_t *s_full_info = new rk_sensor_full_info_t;
*s_full_info = *s_full_info_f;
iter_info = CamHwIsp20::mCamHwInfos.find(iter->first);
if (iter_info == CamHwIsp20::mCamHwInfos.end()) {
continue;
}
rk_aiq_static_info_t *cam_hw_info_f = iter_info->second.ptr();
rk_aiq_static_info_t *cam_hw_info = new rk_aiq_static_info_t;
*cam_hw_info = *cam_hw_info_f;
char sensor_name_real[64];
if (!strstr(s_full_info->sensor_name.c_str(), offline_sns_ent_name)) {
int module_index = 0;
std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t> >::iterator sns_it;
for (sns_it = CamHwIsp20::mSensorHwInfos.begin(); \
sns_it != CamHwIsp20::mSensorHwInfos.end(); sns_it++) {
rk_sensor_full_info_t *sns_full = sns_it->second.ptr();
if (strstr(sns_full->sensor_name.c_str(), "_s_")) {
int sns_index = atoi(sns_full->sensor_name.c_str() + 2);
if (module_index <= sns_index) {
module_index = sns_index + 1;
}
}
}
std::string tmp_sensor_name = s_full_info_f->sensor_name;
s_full_info->phy_module_orient = 's';
memset(sensor_name_real, 0, sizeof(sensor_name_real));
sprintf(sensor_name_real, "%s%d%s%s%s", "m0", module_index, "_s_",
offline_sns_ent_name,
" 1-111a");
std::string sns_fake_name = sensor_name_real;
s_full_info->sensor_name = sns_fake_name;
CamHwIsp20::mFakeCameraName[s_full_info->sensor_name] = tmp_sensor_name;
CamHwIsp20::mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
CamHwIsp20::mCamHwInfos[s_full_info->sensor_name] = cam_hw_info;
CamHwIsp20::mSensorHwInfos.erase(tmp_sensor_name);
CamHwIsp20::mCamHwInfos.erase(tmp_sensor_name);
iter_info++;
return s_full_info->sensor_name.c_str();
} else {
std::string tmp_sensor_name = s_full_info_f->sensor_name;
s_full_info->phy_module_orient = 's';
memset(sensor_name_real, 0, sizeof(sensor_name_real));
sprintf(sensor_name_real, "%s%s%s%s", s_full_info->module_index_str.c_str(), "_s_",
s_full_info->module_real_sensor_name.c_str(),
" 1-111a");
std::string sns_fake_name = sensor_name_real;
s_full_info->sensor_name = sns_fake_name;
CamHwIsp20::mFakeCameraName[s_full_info->sensor_name] = tmp_sensor_name;
CamHwIsp20::mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
CamHwIsp20::mCamHwInfos[s_full_info->sensor_name] = cam_hw_info;
CamHwIsp20::mSensorHwInfos.erase(tmp_sensor_name);
CamHwIsp20::mCamHwInfos.erase(tmp_sensor_name);
iter_info++;
return s_full_info->sensor_name.c_str();
}
}
}
LOGI_CAMHW_SUBM(ISP20HW_SUBM, "offline preInit faile\n");
return NULL;
EXIT_XCORE_FUNCTION();
}
XCamReturn
CamHwIsp20::rawReproc_deInit(const char* fakeSensor)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
std::string fake_sns_name = std::string(fakeSensor);
std::string real_sns_name = "";
std::unordered_map<std::string, std::string>::iterator it_sns_name;
it_sns_name = CamHwIsp20::mFakeCameraName.find(fake_sns_name);
if (it_sns_name == CamHwIsp20::mFakeCameraName.end()) {
return XCAM_RETURN_BYPASS;
}
real_sns_name = it_sns_name->second;
std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t> >::iterator it;
std::unordered_map<std::string, SmartPtr<rk_aiq_static_info_t> >::iterator it_info;
it = CamHwIsp20::mSensorHwInfos.find(fake_sns_name);
it_info = CamHwIsp20::mCamHwInfos.find(fake_sns_name);
if (it != CamHwIsp20::mSensorHwInfos.end()) {
rk_sensor_full_info_t *s_full_info_f = it->second.ptr();
rk_sensor_full_info_t *s_full_info = new rk_sensor_full_info_t;
*s_full_info = *s_full_info_f;
s_full_info->sensor_name = real_sns_name;
CamHwIsp20::mSensorHwInfos[s_full_info->sensor_name] = s_full_info;
CamHwIsp20::mSensorHwInfos.erase(it);
}
if (it_info != CamHwIsp20::mCamHwInfos.end()) {
rk_aiq_static_info_t *cam_hw_info_f = it_info->second.ptr();
rk_aiq_static_info_t *cam_hw_info = new rk_aiq_static_info_t;
*cam_hw_info = *cam_hw_info_f;
CamHwIsp20::mCamHwInfos[real_sns_name] = cam_hw_info;
CamHwIsp20::mCamHwInfos.erase(it_info);
}
CamHwIsp20::mFakeCameraName.erase(it_sns_name);
return ret;
}
XCamReturn
CamHwIsp20::rawReProc_prepare (uint32_t sequence, rk_aiq_frame_info_t *offline_finfo)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
SensorHw* mSensor = mSensorDev.get_cast_ptr<SensorHw>();
ret = mSensor->set_offline_effecting_exp_map(sequence, &offline_finfo[0]);
ret = mSensor->set_offline_effecting_exp_map(sequence + 1, &offline_finfo[1]);
return ret;
}
XCamReturn
CamHwIsp20::setCifSclStartFlag(int ratio, bool mode)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
if (mode == mCifScaleStream->getIsActive())
return ret;
auto it = mSensorHwInfos.find(sns_name);
if ( it == mSensorHwInfos.end()) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_name);
return XCAM_RETURN_ERROR_SENSOR;
}
rk_sensor_full_info_t *s_info = it->second.ptr();
ret = mCifScaleStream->restart(s_info, ratio, this, mode);
return ret;
}
} //namspace RkCam
Reference in New Issue View Git Blame Copy Permalink