/* ****************************************************************************** * * iq.c * * Hawkview ISP - iq.c module * * Copyright (c) 2016 by Allwinnertech Co., Ltd. http://www.allwinnertech.com * * Version Author Date Description * * 3.0 Yang Feng 2016/03/22 VIDEO INPUT * ***************************************************************************** */ #include #include #include #include #include #include #include "device/isp_dev.h" #include "../isp_dev/tools.h" #include "isp_ini_parse.h" #include "isp_tuning_priv.h" #include "../include/isp_tuning.h" enum isp_sense_config { ISP_SCENE_CONFIG_0 = 0, ISP_SCENE_CONFIG_1, ISP_SCENE_CONFIG_2, ISP_SCENE_CONFIG_3, ISP_SCENE_CONFIG_4, ISP_SCENE_CONFIG_5, ISP_SCENE_CONFIG_6, ISP_SCENE_CONFIG_7, ISP_SCENE_CONFIG_8, ISP_SCENE_CONFIG_MAX, }; struct isp_tuning { struct hw_isp_device *isp; struct isp_lib_context *ctx; struct isp_param_config params; unsigned int frame_count; unsigned int pix_max; pthread_mutex_t mutex; }; int isp_params_parse(struct hw_isp_device *isp, struct isp_param_config *params, int sync_mode) { struct isp_lib_context *ctx = isp_dev_get_ctx(isp); if (ctx == NULL) return -1; return parser_ini_info(params, ctx->sensor_info.name, ctx->sensor_info.sensor_width, ctx->sensor_info.sensor_height, ctx->sensor_info.fps_fixed, ctx->sensor_info.wdr_mode, 0, sync_mode, ctx->isp_id); } int isp_sensor_otp_init(struct hw_isp_device *isp) { struct isp_lib_context *ctx = isp_dev_get_ctx(isp); int ret = 0; int i = 0; if (ctx == NULL) return -1; // shading ctx->pmsc_table = malloc(ISP_MSC_TBL_LENGTH*sizeof(unsigned short)); memset(ctx->pmsc_table, 0, ISP_MSC_TBL_LENGTH*sizeof(unsigned short)); if (!ctx->pmsc_table) { ISP_ERR("msc_table alloc failed, no memory!"); return -1; } ctx->otp_enable = 1; ret = ioctl(isp->sensor.fd, VIDIOC_VIN_GET_SENSOR_OTP_INFO, ctx->pmsc_table); ctx->pwb_table = (void *)((HW_U64)(ctx->pmsc_table) + 16*16*3*sizeof(unsigned short)); if(ret < 0) { ALOGE("VIDIOC_VIN_GET_SENSOR_OTP_INFO return error"); ctx->otp_enable = -1; } ctx->otp_enable = -1; return 0; } int isp_sensor_otp_exit(struct hw_isp_device *isp) { struct isp_lib_context *ctx = isp_dev_get_ctx(isp); if (ctx == NULL) return -1; // shading free(ctx->pmsc_table); return 0; } int isp_config_sensor_info(struct hw_isp_device *isp) { struct sensor_config cfg; struct isp_lib_context *ctx = isp_dev_get_ctx(isp); int i = 0, j = 0; memset(&cfg, 0, sizeof(cfg)); if (ctx == NULL) return -1; ctx->sensor_info.name = isp_dev_get_sensor_name(isp); if (!ctx->sensor_info.name) return -1; isp_sensor_get_configs(isp, &cfg); FUNCTION_LOG; ctx->sensor_info.sensor_width = cfg.width; ctx->sensor_info.sensor_height = cfg.height; ctx->sensor_info.fps_fixed = cfg.fps_fixed; ctx->sensor_info.wdr_mode = cfg.wdr_mode; // BT601_FULL_RANGE ctx->sensor_info.color_space = 0; switch (cfg.mbus_code) { case V4L2_MBUS_FMT_SBGGR8_1X8: case V4L2_MBUS_FMT_SBGGR10_1X10: case V4L2_MBUS_FMT_SBGGR12_1X12: ctx->sensor_info.input_seq = ISP_BGGR; break; case V4L2_MBUS_FMT_SGBRG8_1X8: case V4L2_MBUS_FMT_SGBRG10_1X10: case V4L2_MBUS_FMT_SGBRG12_1X12: ctx->sensor_info.input_seq = ISP_GBRG; break; case V4L2_MBUS_FMT_SGRBG8_1X8: case V4L2_MBUS_FMT_SGRBG10_1X10: case V4L2_MBUS_FMT_SGRBG12_1X12: ctx->sensor_info.input_seq = ISP_GRBG; break; case V4L2_MBUS_FMT_SRGGB8_1X8: case V4L2_MBUS_FMT_SRGGB10_1X10: case V4L2_MBUS_FMT_SRGGB12_1X12: ctx->sensor_info.input_seq = ISP_RGGB; break; default: ctx->sensor_info.input_seq = ISP_BGGR; break; } if (cfg.hts && cfg.vts && cfg.pclk) { ctx->sensor_info.hts = cfg.hts; ctx->sensor_info.vts = cfg.vts; ctx->sensor_info.pclk = cfg.pclk; ctx->sensor_info.bin_factor = cfg.bin_factor; ctx->sensor_info.gain_min = cfg.gain_min; ctx->sensor_info.gain_max = cfg.gain_max; ctx->sensor_info.hoffset = cfg.hoffset; ctx->sensor_info.voffset = cfg.voffset; } else { ctx->sensor_info.hts = cfg.width; ctx->sensor_info.vts = cfg.height; ctx->sensor_info.pclk = cfg.width * cfg.height * 30; ctx->sensor_info.bin_factor = 1; ctx->sensor_info.gain_min = 16; ctx->sensor_info.gain_max = 255; ctx->sensor_info.hoffset = 0; ctx->sensor_info.voffset = 0; } if(ctx->sensor_info.sensor_width > 4000 && ctx->sensor_info.sensor_height > 3000) { ctx->stat.pic_size.width = min(3264, cfg.width); } else { ctx->stat.pic_size.width = cfg.width; } ctx->stat.pic_size.height = cfg.height; if(ctx->sensor_info.sensor_width > 4000 && ctx->sensor_info.sensor_height > 3000) { ctx->stats_ctx.pic_w = min(3264, cfg.width); } else { ctx->stats_ctx.pic_w = cfg.width; } ctx->stats_ctx.pic_h = cfg.height; // update otp infomation if(ctx->otp_enable == -1){ ALOGW("otp disabled, msc use 1024"); for(i = 0; i < 16*16*3; i++) { ((unsigned short*)(ctx->pmsc_table))[i] = 1024; } } return 0; } int isp_tuning_update(struct hw_isp_device *isp) { struct isp_tuning *tuning; tuning = isp_dev_get_tuning(isp); if (tuning == NULL) return -1; if (tuning->ctx == NULL) return -1; pthread_mutex_lock(&tuning->mutex); tuning->ctx->isp_ini_cfg = tuning->params; pthread_mutex_unlock(&tuning->mutex); isp_ctx_config_update(tuning->ctx); return 0; } int isp_tuning_reset(struct hw_isp_device *isp, struct isp_param_config *param) { struct isp_tuning *tuning; tuning = isp_dev_get_tuning(isp); if (tuning == NULL) return -1; if (tuning->ctx == NULL) return -1; pthread_mutex_lock(&tuning->mutex); tuning->params = *param; pthread_mutex_unlock(&tuning->mutex); isp_ctx_config_reset(tuning->ctx); return 0; } struct isp_tuning * isp_tuning_init(struct hw_isp_device *isp, const struct isp_param_config *params) { struct isp_tuning *tuning; tuning = malloc(sizeof(struct isp_tuning)); if (tuning == NULL) return NULL; memset(tuning, 0, sizeof(*tuning)); tuning->isp = isp; tuning->frame_count = 0; tuning->ctx = isp_dev_get_ctx(isp); if (tuning->ctx == NULL) { ISP_ERR("ISP context is not init!\n"); free(tuning); return NULL; } FUNCTION_LOG; tuning->params = *params; isp_ctx_config_init(tuning->ctx); isp_dev_banding_tuning(isp, tuning); FUNCTION_LOG; pthread_mutex_init(&tuning->mutex, NULL); return tuning; } void isp_tuning_exit(struct hw_isp_device *isp) { struct isp_tuning *tuning; tuning = isp_dev_get_tuning(isp); if (tuning == NULL) return; pthread_mutex_destroy(&tuning->mutex); isp_ctx_config_exit(tuning->ctx); isp_dev_unbanding_tuning(isp); free(tuning); } HW_S32 isp_tuning_get_cfg(struct hw_isp_device *isp, HW_U8 group_id, HW_U32 cfg_ids, void *cfg_data) { HW_S32 ret = AW_ERR_VI_INVALID_PARA; unsigned char *data_ptr = NULL; struct isp_tuning *tuning = NULL; if (!isp || !cfg_data) return AW_ERR_VI_INVALID_PARA; /* call isp api */ tuning = isp_dev_get_tuning(isp); if (tuning == NULL) return AW_ERR_VI_INVALID_NULL_PTR; /* fill cfg data */ ret = 0; data_ptr = (unsigned char *)cfg_data; switch (group_id) { case HW_ISP_CFG_TEST: /* isp_test_param */ if (cfg_ids & HW_ISP_CFG_TEST_PUB) /* isp_test_pub */ { struct isp_test_pub_cfg *isp_test_pub = (struct isp_test_pub_cfg *)data_ptr; isp_test_pub->test_mode = tuning->params.isp_test_settings.isp_test_mode; isp_test_pub->gain = tuning->params.isp_test_settings.isp_gain; isp_test_pub->exp_line = tuning->params.isp_test_settings.isp_exp_line; isp_test_pub->color_temp = tuning->params.isp_test_settings.isp_color_temp; isp_test_pub->log_param = tuning->params.isp_test_settings.isp_log_param; /* offset */ data_ptr += sizeof(struct isp_test_pub_cfg); ret += sizeof(struct isp_test_pub_cfg); } if (cfg_ids & HW_ISP_CFG_TEST_EXPTIME) /* isp_test_exptime */ { struct isp_test_item_cfg *isp_test_exptime = (struct isp_test_item_cfg *)data_ptr; isp_test_exptime->enable = tuning->params.isp_test_settings.isp_test_exptime; isp_test_exptime->start = tuning->params.isp_test_settings.exp_line_start; isp_test_exptime->step = tuning->params.isp_test_settings.exp_line_step; isp_test_exptime->end = tuning->params.isp_test_settings.exp_line_end; isp_test_exptime->change_interval = tuning->params.isp_test_settings.exp_change_interval; /* offset */ data_ptr += sizeof(struct isp_test_item_cfg); ret += sizeof(struct isp_test_item_cfg); } if (cfg_ids & HW_ISP_CFG_TEST_GAIN) /* isp_test_gain */ { struct isp_test_item_cfg *isp_test_gain = (struct isp_test_item_cfg *)data_ptr; isp_test_gain->enable = tuning->params.isp_test_settings.isp_test_gain; isp_test_gain->start = tuning->params.isp_test_settings.gain_start; isp_test_gain->step = tuning->params.isp_test_settings.gain_step; isp_test_gain->end = tuning->params.isp_test_settings.gain_end; isp_test_gain->change_interval = tuning->params.isp_test_settings.gain_change_interval; /* offset */ data_ptr += sizeof(struct isp_test_item_cfg); ret += sizeof(struct isp_test_item_cfg); } if (cfg_ids & HW_ISP_CFG_TEST_FOCUS) /* isp_test_focus */ { struct isp_test_item_cfg *isp_test_focus = (struct isp_test_item_cfg *)data_ptr; isp_test_focus->enable = tuning->params.isp_test_settings.isp_test_focus; isp_test_focus->start = tuning->params.isp_test_settings.focus_start; isp_test_focus->step = tuning->params.isp_test_settings.focus_step; isp_test_focus->end = tuning->params.isp_test_settings.focus_end; isp_test_focus->change_interval = tuning->params.isp_test_settings.focus_change_interval; /* offset */ data_ptr += sizeof(struct isp_test_item_cfg); ret += sizeof(struct isp_test_item_cfg); } if (cfg_ids & HW_ISP_CFG_TEST_FORCED) /* isp_test_forced */ { struct isp_test_forced_cfg *isp_test_forced = (struct isp_test_forced_cfg *)data_ptr; isp_test_forced->ae_enable = tuning->params.isp_test_settings.ae_forced; isp_test_forced->lum = tuning->params.isp_test_settings.lum_forced; /* offset */ data_ptr += sizeof(struct isp_test_forced_cfg); ret += sizeof(struct isp_test_forced_cfg); } if (cfg_ids & HW_ISP_CFG_TEST_ENABLE) /* isp_test_enable */ { memcpy(data_ptr, &(tuning->params.isp_test_settings.manual_en), sizeof(struct isp_test_enable_cfg)); /* offset */ data_ptr += sizeof(struct isp_test_enable_cfg); ret += sizeof(struct isp_test_enable_cfg); } break; case HW_ISP_CFG_3A: /* isp_3a_param */ if (cfg_ids & HW_ISP_CFG_AE_PUB) /* isp_ae_pub */ { struct isp_ae_pub_cfg *isp_ae_pub = (struct isp_ae_pub_cfg *)data_ptr; isp_ae_pub->define_table = tuning->params.isp_3a_settings.define_ae_table; isp_ae_pub->max_lv = tuning->params.isp_3a_settings.ae_max_lv; isp_ae_pub->hist_mode_en = tuning->params.isp_3a_settings.ae_hist_mod_en; isp_ae_pub->hist_sel = tuning->params.isp_3a_settings.ae_hist_sel; isp_ae_pub->stat_sel = tuning->params.isp_3a_settings.ae_stat_sel; isp_ae_pub->compensation_step = tuning->params.isp_3a_settings.exp_comp_step; isp_ae_pub->touch_dist_index = tuning->params.isp_3a_settings.ae_touch_dist_ind; isp_ae_pub->iso2gain_ratio = tuning->params.isp_3a_settings.ae_iso2gain_ratio; memcpy(&isp_ae_pub->fno_table[0], &tuning->params.isp_3a_settings.ae_fno_step[0], sizeof(isp_ae_pub->fno_table)); isp_ae_pub->ki = tuning->params.isp_3a_settings.ae_ki; isp_ae_pub->conv_data_index = tuning->params.isp_3a_settings.ae_ConvDataIndex; isp_ae_pub->blowout_pre_en = tuning->params.isp_3a_settings.ae_blowout_pre_en; isp_ae_pub->blowout_attr = tuning->params.isp_3a_settings.ae_blowout_attr; memcpy(&isp_ae_pub->wdr_cfg[0], &tuning->params.isp_3a_settings.wdr_cfg[0], sizeof(isp_ae_pub->wdr_cfg)); /* offset */ data_ptr += sizeof(struct isp_ae_pub_cfg); ret += sizeof(struct isp_ae_pub_cfg); } if (cfg_ids & HW_ISP_CFG_AE_PREVIEW_TBL) /* isp_ae_preview_tbl */ { struct isp_ae_table_cfg *isp_ae_preview_tbl = (struct isp_ae_table_cfg *)data_ptr; isp_ae_preview_tbl->length = tuning->params.isp_3a_settings.ae_table_preview_length; memcpy(&(isp_ae_preview_tbl->value[0]), tuning->params.isp_3a_settings.ae_table_preview, sizeof(isp_ae_preview_tbl->value)); /* offset */ data_ptr += sizeof(struct isp_ae_table_cfg); ret += sizeof(struct isp_ae_table_cfg); } if (cfg_ids & HW_ISP_CFG_AE_CAPTURE_TBL) /* isp_ae_capture_tbl */ { struct isp_ae_table_cfg *isp_ae_capture_tbl = (struct isp_ae_table_cfg *)data_ptr; isp_ae_capture_tbl->length = tuning->params.isp_3a_settings.ae_table_capture_length; memcpy(&(isp_ae_capture_tbl->value[0]), tuning->params.isp_3a_settings.ae_table_capture, sizeof(isp_ae_capture_tbl->value)); /* offset */ data_ptr += sizeof(struct isp_ae_table_cfg); ret += sizeof(struct isp_ae_table_cfg); } if (cfg_ids & HW_ISP_CFG_AE_VIDEO_TBL) /* isp_ae_video_tbl */ { struct isp_ae_table_cfg *isp_ae_video_tbl = (struct isp_ae_table_cfg *)data_ptr; isp_ae_video_tbl->length = tuning->params.isp_3a_settings.ae_table_video_length; memcpy(&(isp_ae_video_tbl->value[0]), tuning->params.isp_3a_settings.ae_table_video, sizeof(isp_ae_video_tbl->value)); /* offset */ data_ptr += sizeof(struct isp_ae_table_cfg); ret += sizeof(struct isp_ae_table_cfg); } if (cfg_ids & HW_ISP_CFG_AE_WIN_WEIGHT) /* isp_ae_win_weight */ { memcpy(data_ptr, tuning->params.isp_3a_settings.ae_win_weight, sizeof(struct isp_ae_weight_cfg)); /* offset */ data_ptr += sizeof(struct isp_ae_weight_cfg); ret += sizeof(struct isp_ae_weight_cfg); } if (cfg_ids & HW_ISP_CFG_AE_DELAY) /* isp_ae_delay */ { struct isp_ae_delay_cfg *isp_ae_delay = (struct isp_ae_delay_cfg *)data_ptr; isp_ae_delay->ae_frame = tuning->params.isp_3a_settings.ae_delay_frame; isp_ae_delay->exp_frame = tuning->params.isp_3a_settings.exp_delay_frame; isp_ae_delay->gain_frame = tuning->params.isp_3a_settings.gain_delay_frame; /* offset */ data_ptr += sizeof(struct isp_ae_delay_cfg); ret += sizeof(struct isp_ae_delay_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_PUB) /* isp_awb_pub */ { struct isp_awb_pub_cfg *isp_awb_pub = (struct isp_awb_pub_cfg *)data_ptr; isp_awb_pub->interval = tuning->params.isp_3a_settings.awb_interval; isp_awb_pub->speed = tuning->params.isp_3a_settings.awb_speed; isp_awb_pub->stat_sel = tuning->params.isp_3a_settings.awb_stat_sel; /* offset */ data_ptr += sizeof(struct isp_awb_pub_cfg); ret += sizeof(struct isp_awb_pub_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_TEMP_RANGE) /* isp_awb_temp_range */ { struct isp_awb_temp_range_cfg *isp_awb_temp_range = (struct isp_awb_temp_range_cfg *)data_ptr; isp_awb_temp_range->low = tuning->params.isp_3a_settings.awb_color_temper_low; isp_awb_temp_range->high = tuning->params.isp_3a_settings.awb_color_temper_high; isp_awb_temp_range->base = tuning->params.isp_3a_settings.awb_base_temper; /* offset */ data_ptr += sizeof(struct isp_awb_temp_range_cfg); ret += sizeof(struct isp_awb_temp_range_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_DIST) /* isp_awb_dist */ { struct isp_awb_dist_cfg *isp_awb_dist = (struct isp_awb_dist_cfg *)data_ptr; isp_awb_dist->green_zone = tuning->params.isp_3a_settings.awb_green_zone_dist; isp_awb_dist->blue_sky = tuning->params.isp_3a_settings.awb_blue_sky_dist; /* offset */ data_ptr += sizeof(struct isp_awb_dist_cfg); ret += sizeof(struct isp_awb_dist_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_LIGHT_INFO) /* isp_awb_light_info */ { struct isp_awb_temp_info_cfg *isp_awb_light_info = (struct isp_awb_temp_info_cfg *)data_ptr; isp_awb_light_info->number = tuning->params.isp_3a_settings.awb_light_num; memcpy(isp_awb_light_info->value, tuning->params.isp_3a_settings.awb_light_info, sizeof(tuning->params.isp_3a_settings.awb_light_info)); /* offset */ data_ptr += sizeof(struct isp_awb_temp_info_cfg); ret += sizeof(struct isp_awb_temp_info_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_EXT_LIGHT_INFO) /* isp_awb_ext_light_info */ { struct isp_awb_temp_info_cfg *isp_awb_ext_light_info = (struct isp_awb_temp_info_cfg *)data_ptr; isp_awb_ext_light_info->number = tuning->params.isp_3a_settings.awb_ext_light_num; memcpy(isp_awb_ext_light_info->value, tuning->params.isp_3a_settings.awb_ext_light_info, sizeof(tuning->params.isp_3a_settings.awb_ext_light_info)); /* offset */ data_ptr += sizeof(struct isp_awb_temp_info_cfg); ret += sizeof(struct isp_awb_temp_info_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_SKIN_INFO) /* isp_awb_skin_info */ { struct isp_awb_temp_info_cfg *isp_awb_skin_info = (struct isp_awb_temp_info_cfg *)data_ptr; isp_awb_skin_info->number = tuning->params.isp_3a_settings.awb_skin_color_num; memcpy(isp_awb_skin_info->value, tuning->params.isp_3a_settings.awb_skin_color_info, sizeof(tuning->params.isp_3a_settings.awb_skin_color_info)); // !!!be careful, 160 -> 320 /* offset */ data_ptr += sizeof(struct isp_awb_temp_info_cfg); ret += sizeof(struct isp_awb_temp_info_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_SPECIAL_INFO) /* isp_awb_special_info */ { struct isp_awb_temp_info_cfg *isp_awb_special_info = (struct isp_awb_temp_info_cfg *)data_ptr; isp_awb_special_info->number = tuning->params.isp_3a_settings.awb_special_color_num; memcpy(isp_awb_special_info->value, tuning->params.isp_3a_settings.awb_special_color_info, sizeof(tuning->params.isp_3a_settings.awb_special_color_info)); /* offset */ data_ptr += sizeof(struct isp_awb_temp_info_cfg); ret += sizeof(struct isp_awb_temp_info_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_PRESET_GAIN) /* isp_awb_preset_gain */ { memcpy(data_ptr, tuning->params.isp_3a_settings.awb_preset_gain, sizeof(struct isp_awb_preset_gain_cfg)); /* offset */ data_ptr += sizeof(struct isp_awb_preset_gain_cfg); ret += sizeof(struct isp_awb_preset_gain_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_FAVOR) /* isp_awb_favor */ { struct isp_awb_favor_cfg *isp_awb_favor = (struct isp_awb_favor_cfg *)data_ptr; isp_awb_favor->rgain = tuning->params.isp_3a_settings.awb_rgain_favor; isp_awb_favor->bgain = tuning->params.isp_3a_settings.awb_bgain_favor; /* offset */ data_ptr += sizeof(struct isp_awb_favor_cfg); ret += sizeof(struct isp_awb_favor_cfg); } if (cfg_ids & HW_ISP_CFG_AF_VCM_CODE) /* isp_af_vcm_code */ { struct isp_af_vcm_code_cfg *isp_af_vcm_code = (struct isp_af_vcm_code_cfg *)data_ptr; isp_af_vcm_code->min = tuning->params.isp_3a_settings.vcm_min_code; isp_af_vcm_code->max = tuning->params.isp_3a_settings.vcm_max_code; /* offset */ data_ptr += sizeof(struct isp_af_vcm_code_cfg); ret += sizeof(struct isp_af_vcm_code_cfg); } if (cfg_ids & HW_ISP_CFG_AF_OTP) /* isp_af_otp */ { struct isp_af_otp_cfg *isp_af_otp = (struct isp_af_otp_cfg *)data_ptr; isp_af_otp->use_otp = tuning->params.isp_3a_settings.af_use_otp; /* offset */ data_ptr += sizeof(struct isp_af_otp_cfg); ret += sizeof(struct isp_af_otp_cfg); } if (cfg_ids & HW_ISP_CFG_AF_SPEED) /* isp_af_speed */ { struct isp_af_speed_cfg *isp_af_speed = (struct isp_af_speed_cfg *)data_ptr; isp_af_speed->interval_time = tuning->params.isp_3a_settings.af_interval_time; isp_af_speed->index = tuning->params.isp_3a_settings.af_speed_ind; /* offset */ data_ptr += sizeof(struct isp_af_speed_cfg); ret += sizeof(struct isp_af_speed_cfg); } if (cfg_ids & HW_ISP_CFG_AF_FINE_SEARCH) /* isp_af_fine_search */ { struct isp_af_fine_search_cfg *isp_af_fine_search = (struct isp_af_fine_search_cfg *)data_ptr; isp_af_fine_search->auto_en = tuning->params.isp_3a_settings.af_auto_fine_en; isp_af_fine_search->single_en = tuning->params.isp_3a_settings.af_single_fine_en; isp_af_fine_search->step = tuning->params.isp_3a_settings.af_fine_step; /* offset */ data_ptr += sizeof(struct isp_af_fine_search_cfg); ret += sizeof(struct isp_af_fine_search_cfg); } if (cfg_ids & HW_ISP_CFG_AF_REFOCUS) /* isp_af_refocus */ { struct isp_af_refocus_cfg *isp_af_refocus = (struct isp_af_refocus_cfg *)data_ptr; isp_af_refocus->move_cnt = tuning->params.isp_3a_settings.af_move_cnt; isp_af_refocus->still_cnt = tuning->params.isp_3a_settings.af_still_cnt; isp_af_refocus->move_monitor_cnt = tuning->params.isp_3a_settings.af_move_monitor_cnt; isp_af_refocus->still_monitor_cnt = tuning->params.isp_3a_settings.af_still_monitor_cnt; /* offset */ data_ptr += sizeof(struct isp_af_refocus_cfg); ret += sizeof(struct isp_af_refocus_cfg); } if (cfg_ids & HW_ISP_CFG_AF_TOLERANCE) /* isp_af_tolerance */ { struct isp_af_tolerance_cfg *isp_af_tolerance = (struct isp_af_tolerance_cfg *)data_ptr; isp_af_tolerance->near_distance = tuning->params.isp_3a_settings.af_near_tolerance; isp_af_tolerance->far_distance = tuning->params.isp_3a_settings.af_far_tolerance; isp_af_tolerance->offset = tuning->params.isp_3a_settings.af_tolerance_off; isp_af_tolerance->table_length = tuning->params.isp_3a_settings.af_tolerance_tbl_len; memcpy(isp_af_tolerance->std_code_table, tuning->params.isp_3a_settings.af_std_code_tbl, sizeof(isp_af_tolerance->std_code_table)); memcpy(isp_af_tolerance->value, tuning->params.isp_3a_settings.af_tolerance_value_tbl, sizeof(isp_af_tolerance->value)); /* offset */ data_ptr += sizeof(struct isp_af_tolerance_cfg); ret += sizeof(struct isp_af_tolerance_cfg); } if (cfg_ids & HW_ISP_CFG_AF_SCENE) /* isp_af_scene */ { struct isp_af_scene_cfg *isp_af_scene = (struct isp_af_scene_cfg *)data_ptr; isp_af_scene->stable_min = tuning->params.isp_3a_settings.af_stable_min; isp_af_scene->stable_max = tuning->params.isp_3a_settings.af_stable_max; isp_af_scene->low_light_lv = tuning->params.isp_3a_settings.af_low_light_lv; isp_af_scene->peak_thres = tuning->params.isp_3a_settings.af_peak_th; isp_af_scene->direction_thres = tuning->params.isp_3a_settings.af_dir_th; isp_af_scene->change_ratio = tuning->params.isp_3a_settings.af_change_ratio; isp_af_scene->move_minus = tuning->params.isp_3a_settings.af_move_minus; isp_af_scene->still_minus = tuning->params.isp_3a_settings.af_still_minus; isp_af_scene->scene_motion_thres = tuning->params.isp_3a_settings.af_scene_motion_th; /* offset */ data_ptr += sizeof(struct isp_af_scene_cfg); ret += sizeof(struct isp_af_scene_cfg); } break; case HW_ISP_CFG_TUNING: /* isp_tunning_param */ if (cfg_ids & HW_ISP_CFG_TUNING_FLASH) /* isp_tuning_flash */ { struct isp_tuning_flash_cfg *isp_tuning_flash = (struct isp_tuning_flash_cfg *)data_ptr; isp_tuning_flash->gain = tuning->params.isp_tunning_settings.flash_gain; isp_tuning_flash->delay_frame = tuning->params.isp_tunning_settings.flash_delay_frame; /* offset */ data_ptr += sizeof(struct isp_tuning_flash_cfg); ret += sizeof(struct isp_tuning_flash_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_FLICKER) /* isp_tuning_flicker */ { struct isp_tuning_flicker_cfg *isp_tuning_flicker = (struct isp_tuning_flicker_cfg *)data_ptr; isp_tuning_flicker->type = tuning->params.isp_tunning_settings.flicker_type; isp_tuning_flicker->ratio = tuning->params.isp_tunning_settings.flicker_ratio; /* offset */ data_ptr += sizeof(struct isp_tuning_flicker_cfg); ret += sizeof(struct isp_tuning_flicker_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_VISUAL_ANGLE) /* isp_visual_angle */ { struct isp_tuning_visual_angle_cfg *isp_visual_angle = (struct isp_tuning_visual_angle_cfg *)data_ptr; isp_visual_angle->horizontal = tuning->params.isp_tunning_settings.hor_visual_angle; isp_visual_angle->vertical = tuning->params.isp_tunning_settings.ver_visual_angle; isp_visual_angle->focus_length = tuning->params.isp_tunning_settings.focus_length; /* offset */ data_ptr += sizeof(struct isp_tuning_visual_angle_cfg); ret += sizeof(struct isp_tuning_visual_angle_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_GTM) /* isp_tuning_gtm */ { struct isp_tuning_gtm_cfg *isp_tuning_gtm = (struct isp_tuning_gtm_cfg *)data_ptr; isp_tuning_gtm->type = tuning->params.isp_tunning_settings.gtm_type; isp_tuning_gtm->gamma_type = tuning->params.isp_tunning_settings.gamma_type; isp_tuning_gtm->auto_alpha_en = tuning->params.isp_tunning_settings.auto_alpha_en; /* offset */ data_ptr += sizeof(struct isp_tuning_gtm_cfg); ret += sizeof(struct isp_tuning_gtm_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CFA) /* isp_tuning_cfa */ { struct isp_tuning_cfa_cfg *isp_tuning_cfa = (struct isp_tuning_cfa_cfg *)data_ptr; isp_tuning_cfa->dir_thres = tuning->params.isp_tunning_settings.cfa_dir_th; isp_tuning_cfa->interp_mode = tuning->params.isp_tunning_settings.cfa_interp_mode; isp_tuning_cfa->zig_zag = tuning->params.isp_tunning_settings.cfa_zig_zag; /* offset */ data_ptr += sizeof(struct isp_tuning_cfa_cfg); ret += sizeof(struct isp_tuning_cfa_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CTC) /* isp_tuning_ctc */ { struct isp_tuning_ctc_cfg *isp_tuning_ctc = (struct isp_tuning_ctc_cfg *)data_ptr; isp_tuning_ctc->min_thres = tuning->params.isp_tunning_settings.ctc_th_min; isp_tuning_ctc->max_thres = tuning->params.isp_tunning_settings.ctc_th_max; isp_tuning_ctc->slope_thres = tuning->params.isp_tunning_settings.ctc_th_slope; isp_tuning_ctc->dir_wt = tuning->params.isp_tunning_settings.ctc_dir_wt; isp_tuning_ctc->dir_thres = tuning->params.isp_tunning_settings.ctc_dir_th; /* offset */ data_ptr += sizeof(struct isp_tuning_ctc_cfg); ret += sizeof(struct isp_tuning_ctc_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_DIGITAL_GAIN) /* isp_digital_gain */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.bayer_gain, sizeof(struct isp_tuning_blc_gain_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_blc_gain_cfg); ret += sizeof(struct isp_tuning_blc_gain_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CCM_LOW) /* isp_ccm_low */ { struct isp_tuning_ccm_cfg *isp_ccm_low = (struct isp_tuning_ccm_cfg *)data_ptr; isp_ccm_low->temperature = tuning->params.isp_tunning_settings.cm_trig_cfg[0]; memcpy(&isp_ccm_low->value, &(tuning->params.isp_tunning_settings.color_matrix_ini[0]), sizeof(struct isp_rgb2rgb_gain_offset)); /* offset */ data_ptr += sizeof(struct isp_tuning_ccm_cfg); ret += sizeof(struct isp_tuning_ccm_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CCM_MID) /* isp_ccm_mid */ { struct isp_tuning_ccm_cfg *isp_ccm_mid = (struct isp_tuning_ccm_cfg *)data_ptr; isp_ccm_mid->temperature = tuning->params.isp_tunning_settings.cm_trig_cfg[1]; memcpy(&isp_ccm_mid->value, &(tuning->params.isp_tunning_settings.color_matrix_ini[1]), sizeof(struct isp_rgb2rgb_gain_offset)); /* offset */ data_ptr += sizeof(struct isp_tuning_ccm_cfg); ret += sizeof(struct isp_tuning_ccm_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CCM_HIGH) /* isp_ccm_high */ { struct isp_tuning_ccm_cfg *isp_ccm_high = (struct isp_tuning_ccm_cfg *)data_ptr; isp_ccm_high->temperature = tuning->params.isp_tunning_settings.cm_trig_cfg[2]; memcpy(&isp_ccm_high->value, &(tuning->params.isp_tunning_settings.color_matrix_ini[2]), sizeof(struct isp_rgb2rgb_gain_offset)); /* offset */ data_ptr += sizeof(struct isp_tuning_ccm_cfg); ret += sizeof(struct isp_tuning_ccm_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_PLTM) /* isp_tuning_pltm */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.pltm_cfg, sizeof(struct isp_tuning_pltm_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_pltm_cfg); ret += sizeof(struct isp_tuning_pltm_cfg); } #if (ISP_VERSION >= 521) if (cfg_ids & HW_ISP_CFG_TUNING_GCA) /* isp_tuning_gca */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.gca_cfg, sizeof(struct isp_tuning_gca_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_gca_cfg); ret += sizeof(struct isp_tuning_gca_cfg); } #endif break; case HW_ISP_CFG_TUNING_TABLES: /* isp tuning tables */ if (cfg_ids & HW_ISP_CFG_TUNING_LSC) /* isp_tuning_lsc */ { struct isp_tuning_lsc_table_cfg *isp_tuning_lsc = (struct isp_tuning_lsc_table_cfg *)data_ptr; #if (ISP_VERSION >= 521) isp_tuning_lsc->lsc_mode = tuning->params.isp_tunning_settings.lsc_mode; #endif isp_tuning_lsc->ff_mod = tuning->params.isp_tunning_settings.ff_mod; isp_tuning_lsc->center_x = tuning->params.isp_tunning_settings.lsc_center_x; isp_tuning_lsc->center_y = tuning->params.isp_tunning_settings.lsc_center_y; isp_tuning_lsc->rolloff_ratio = tuning->params.isp_tunning_settings.rolloff_ratio; memcpy(&(isp_tuning_lsc->value[0][0]), &(tuning->params.isp_tunning_settings.lsc_tbl[0][0]), sizeof(isp_tuning_lsc->value)); memcpy(isp_tuning_lsc->color_temp_triggers, tuning->params.isp_tunning_settings.lsc_trig_cfg, sizeof(isp_tuning_lsc->color_temp_triggers)); /* offset */ data_ptr += sizeof(struct isp_tuning_lsc_table_cfg); ret += sizeof(struct isp_tuning_lsc_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_GAMMA) /* isp_tuning_gamma */ { struct isp_tuning_gamma_table_cfg *isp_tuning_gamma = (struct isp_tuning_gamma_table_cfg *)data_ptr; isp_tuning_gamma->number = tuning->params.isp_tunning_settings.gamma_num; memcpy(&(isp_tuning_gamma->value[0][0]), &(tuning->params.isp_tunning_settings.gamma_tbl_ini[0][0]), sizeof(isp_tuning_gamma->value)); memcpy(isp_tuning_gamma->lv_triggers, tuning->params.isp_tunning_settings.gamma_trig_cfg, sizeof(isp_tuning_gamma->lv_triggers)); /* offset */ data_ptr += sizeof(struct isp_tuning_gamma_table_cfg); ret += sizeof(struct isp_tuning_gamma_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_LINEARITY) /* isp_tuning_linearity */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.linear_tbl, sizeof(struct isp_tuning_linearity_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_linearity_table_cfg); ret += sizeof(struct isp_tuning_linearity_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_DISTORTION) /* isp_tuning_distortion */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.disc_tbl, sizeof(struct isp_tuning_distortion_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_distortion_table_cfg); ret += sizeof(struct isp_tuning_distortion_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_BDNF) /* isp_tuning_bdnf */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.isp_bdnf_th, sizeof(struct isp_tuning_bdnf_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_bdnf_table_cfg); ret += sizeof(struct isp_tuning_bdnf_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_TDNF) /* isp_tuning_tdnf */ { struct isp_tuning_tdnf_table_cfg *isp_tuning_tdnf = (struct isp_tuning_tdnf_table_cfg *)data_ptr; memcpy(isp_tuning_tdnf->thres, tuning->params.isp_tunning_settings.isp_tdnf_th, sizeof(isp_tuning_tdnf->thres)); memcpy(isp_tuning_tdnf->ref_noise, tuning->params.isp_tunning_settings.isp_tdnf_ref_noise, sizeof(isp_tuning_tdnf->ref_noise)); memcpy(isp_tuning_tdnf->k_val, tuning->params.isp_tunning_settings.isp_tdnf_k, sizeof(isp_tuning_tdnf->k_val)); memcpy(isp_tuning_tdnf->diff, tuning->params.isp_tunning_settings.isp_tdnf_diff, sizeof(isp_tuning_tdnf->diff)); #if (ISP_VERSION >= 520) memcpy(isp_tuning_tdnf->d3d_k3d, tuning->params.isp_tunning_settings.isp_d3d_k3d_incre_curve, sizeof(isp_tuning_tdnf->d3d_k3d)); #endif /* offset */ data_ptr += sizeof(struct isp_tuning_tdnf_table_cfg); ret += sizeof(struct isp_tuning_tdnf_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CONTRAST) /* isp_tuning_contrast */ { struct isp_tuning_contrast_table_cfg *isp_tuning_contrast = (struct isp_tuning_contrast_table_cfg *)data_ptr; memcpy(isp_tuning_contrast->val, tuning->params.isp_tunning_settings.isp_contrast_val, sizeof(isp_tuning_contrast->val)); memcpy(isp_tuning_contrast->lum, tuning->params.isp_tunning_settings.isp_contrast_lum, sizeof(isp_tuning_contrast->lum)); memcpy(isp_tuning_contrast->pe, tuning->params.isp_tunning_settings.isp_contrat_pe, sizeof(isp_tuning_contrast->pe)); /* offset */ data_ptr += sizeof(struct isp_tuning_contrast_table_cfg); ret += sizeof(struct isp_tuning_contrast_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_SHARP) /* isp_tuning_sharp */ { struct isp_tuning_sharp_table_cfg *isp_tuning_sharp = (struct isp_tuning_sharp_table_cfg *)data_ptr; memcpy(isp_tuning_sharp->value, tuning->params.isp_tunning_settings.isp_sharp_val, sizeof(isp_tuning_sharp->value)); memcpy(isp_tuning_sharp->lum, tuning->params.isp_tunning_settings.isp_sharp_lum, sizeof(isp_tuning_sharp->lum)); #if (ISP_VERSION >= 520) memcpy(isp_tuning_sharp->edge_lum, tuning->params.isp_tunning_settings.isp_sharp_edge_lum, sizeof(isp_tuning_sharp->edge_lum)); memcpy(isp_tuning_sharp->hfrq_lum, tuning->params.isp_tunning_settings.isp_sharp_hfrq_lum, sizeof(isp_tuning_sharp->hfrq_lum)); memcpy(isp_tuning_sharp->hsv, tuning->params.isp_tunning_settings.isp_sharp_hsv, sizeof(isp_tuning_sharp->hsv)); memcpy(isp_tuning_sharp->smap, tuning->params.isp_tunning_settings.isp_sharp_s_map, sizeof(isp_tuning_sharp->smap)); #endif /* offset */ data_ptr += sizeof(struct isp_tuning_sharp_table_cfg); ret += sizeof(struct isp_tuning_sharp_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CEM) /* isp_tuning_cem */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.isp_cem_table, sizeof(struct isp_tuning_cem_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_cem_table_cfg); ret += sizeof(struct isp_tuning_cem_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CEM_1) /* isp_tuning_cem_1 */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.isp_cem_table1, sizeof(struct isp_tuning_cem_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_cem_table_cfg); ret += sizeof(struct isp_tuning_cem_table_cfg); } #if (ISP_VERSION != 522) if (cfg_ids & HW_ISP_CFG_TUNING_PLTM_TBL) /* isp_tuning_pltm_table */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.isp_pltm_table, sizeof(struct isp_tuning_pltm_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_pltm_table_cfg); ret += sizeof(struct isp_tuning_pltm_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_WDR) /* isp_tuning_wdr */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.isp_wdr_table, sizeof(struct isp_tuning_wdr_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_wdr_table_cfg); ret += sizeof(struct isp_tuning_wdr_table_cfg); } #endif #if (ISP_VERSION >= 521) if (cfg_ids & HW_ISP_CFG_TUNING_LCA_TBL) /* isp_tuning_lca */ { memcpy(data_ptr, tuning->params.isp_tunning_settings.lca_pf_satu_lut, sizeof(struct isp_tuning_lca_pf_satu_lut)); /* lca_pf_satu_lut offset */ data_ptr += sizeof(struct isp_tuning_lca_pf_satu_lut); ret += sizeof(struct isp_tuning_lca_pf_satu_lut); memcpy(data_ptr, tuning->params.isp_tunning_settings.lca_gf_satu_lut, sizeof(struct isp_tuning_lca_gf_satu_lut)); /* lca_gf_satu_lut offset */ data_ptr += sizeof(struct isp_tuning_lca_gf_satu_lut); ret += sizeof(struct isp_tuning_lca_gf_satu_lut); } if (cfg_ids & HW_ISP_CFG_TUNING_MSC) /* isp_tuning_msc */ { struct isp_tuning_msc_table_cfg *isp_tuning_msc = (struct isp_tuning_msc_table_cfg *)data_ptr; isp_tuning_msc->mff_mod = tuning->params.isp_tunning_settings.mff_mod; isp_tuning_msc->msc_mode = tuning->params.isp_tunning_settings.msc_mode; memcpy(isp_tuning_msc->msc_blw_lut, tuning->params.isp_tunning_settings.msc_blw_lut, sizeof(isp_tuning_msc->msc_blw_lut)); memcpy(isp_tuning_msc->msc_blh_lut, tuning->params.isp_tunning_settings.msc_blh_lut, sizeof(isp_tuning_msc->msc_blh_lut)); memcpy(isp_tuning_msc->msc_blw_dlt_lut, tuning->params.isp_tunning_settings.msc_blw_dlt_lut, sizeof(isp_tuning_msc->msc_blw_dlt_lut)); memcpy(isp_tuning_msc->msc_blh_dlt_lut, tuning->params.isp_tunning_settings.msc_blh_dlt_lut, sizeof(isp_tuning_msc->msc_blh_dlt_lut)); memcpy(&(isp_tuning_msc->value[0][0]), &(tuning->params.isp_tunning_settings.msc_tbl[0][0]), sizeof(isp_tuning_msc->value)); memcpy(isp_tuning_msc->color_temp_triggers, tuning->params.isp_tunning_settings.msc_trig_cfg, sizeof(isp_tuning_msc->color_temp_triggers)); /* offset */ data_ptr += sizeof(struct isp_tuning_msc_table_cfg); ret += sizeof(struct isp_tuning_msc_table_cfg); } #endif break; case HW_ISP_CFG_DYNAMIC: /* isp_dynamic_param */ if (cfg_ids & HW_ISP_CFG_DYNAMIC_LUM_POINT) /* isp_dynamic_lum_mapping_point */ { memcpy(data_ptr, tuning->params.isp_iso_settings.isp_lum_mapping_point, sizeof(struct isp_dynamic_single_cfg)); /* offset */ data_ptr += sizeof(struct isp_dynamic_single_cfg); ret += sizeof(struct isp_dynamic_single_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_GAIN_POINT) /* isp_dynamic_gain_mapping_point */ { memcpy(data_ptr, tuning->params.isp_iso_settings.isp_gain_mapping_point, sizeof(struct isp_dynamic_single_cfg)); /* offset */ data_ptr += sizeof(struct isp_dynamic_single_cfg); ret += sizeof(struct isp_dynamic_single_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_SHARP) /* isp_dynamic_sharp */ { struct isp_dynamic_sharp_cfg *isp_dynamic_sharp = (struct isp_dynamic_sharp_cfg *)data_ptr; int i = 0; isp_dynamic_sharp->trigger = tuning->params.isp_iso_settings.triger.sharp_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) { memcpy(isp_dynamic_sharp->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].sharp_cfg, sizeof(isp_dynamic_sharp->tuning_cfg[i].value)); } /* offset */ data_ptr += sizeof(struct isp_dynamic_sharp_cfg); ret += sizeof(struct isp_dynamic_sharp_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_CONTRAST) /* isp_dynamic_contrast */ { struct isp_dynamic_contrast_cfg *isp_dynamic_contrast = (struct isp_dynamic_contrast_cfg *)data_ptr; int i = 0; isp_dynamic_contrast->trigger = tuning->params.isp_iso_settings.triger.contrast_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) { memcpy(isp_dynamic_contrast->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].contrast_cfg, sizeof(isp_dynamic_contrast->tuning_cfg[i].value)); } /* offset */ data_ptr += sizeof(struct isp_dynamic_contrast_cfg); ret += sizeof(struct isp_dynamic_contrast_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_DENOISE) /* isp_dynamic_denoise */ { struct isp_dynamic_denoise_cfg *isp_dynamic_denoise = (struct isp_dynamic_denoise_cfg *)data_ptr; int i = 0; isp_dynamic_denoise->trigger = tuning->params.isp_iso_settings.triger.denoise_triger; isp_dynamic_denoise->color_trigger = tuning->params.isp_iso_settings.triger.color_denoise_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) { memcpy(isp_dynamic_denoise->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].denoise_cfg, sizeof(isp_dynamic_denoise->tuning_cfg[i].value)); isp_dynamic_denoise->tuning_cfg[i].color_denoise = tuning->params.isp_iso_settings.isp_dynamic_cfg[i].color_denoise; isp_dynamic_denoise->tuning_cfg[i].ratio = 1; } /* offset */ data_ptr += sizeof(struct isp_dynamic_denoise_cfg); ret += sizeof(struct isp_dynamic_denoise_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_SENSOR_OFFSET) /* isp_dynamic_sensor_offset */ { struct isp_dynamic_sensor_offset_cfg *isp_dynamic_sensor_offset = (struct isp_dynamic_sensor_offset_cfg *)data_ptr; int i = 0; isp_dynamic_sensor_offset->trigger = tuning->params.isp_iso_settings.triger.sensor_offset_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(isp_dynamic_sensor_offset->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].sensor_offset, sizeof(isp_dynamic_sensor_offset->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_sensor_offset_cfg); ret += sizeof(struct isp_dynamic_sensor_offset_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_BLACK_LV) /* isp_dynamic_black_level */ { struct isp_dynamic_black_level_cfg *isp_dynamic_black_level = (struct isp_dynamic_black_level_cfg *)data_ptr; int i = 0; isp_dynamic_black_level->trigger = tuning->params.isp_iso_settings.triger.black_level_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(isp_dynamic_black_level->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].black_level, sizeof(isp_dynamic_black_level->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_black_level_cfg); ret += sizeof(struct isp_dynamic_black_level_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_DPC) /* isp_dynamic_dpcl */ { struct isp_dynamic_dpc_cfg *isp_dynamic_dpc = (struct isp_dynamic_dpc_cfg *)data_ptr; int i = 0; isp_dynamic_dpc->trigger = tuning->params.isp_iso_settings.triger.dpc_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(isp_dynamic_dpc->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].dpc_cfg, sizeof(isp_dynamic_dpc->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_dpc_cfg); ret += sizeof(struct isp_dynamic_dpc_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_PLTM) /* isp_dynamic_pltm */ { struct isp_dynamic_pltm_cfg *isp_dynamic_pltm = (struct isp_dynamic_pltm_cfg *)data_ptr; int i = 0; isp_dynamic_pltm->trigger = tuning->params.isp_iso_settings.triger.pltm_dynamic_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(isp_dynamic_pltm->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].pltm_dynamic_cfg, sizeof(isp_dynamic_pltm->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_pltm_cfg); ret += sizeof(struct isp_dynamic_pltm_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_DEFOG) /* isp_dynamic_defog */ { struct isp_dynamic_defog_cfg *isp_dynamic_defog = (struct isp_dynamic_defog_cfg *)data_ptr; int i = 0; isp_dynamic_defog->trigger = tuning->params.isp_iso_settings.triger.defog_value_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) isp_dynamic_defog->tuning_cfg[i].value = tuning->params.isp_iso_settings.isp_dynamic_cfg[i].defog_value; /* offset */ data_ptr += sizeof(struct isp_dynamic_defog_cfg); ret += sizeof(struct isp_dynamic_defog_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_HISTOGRAM) /* isp_dynamic_histogram */ { struct isp_dynamic_histogram_cfg *isp_dynamic_histogram = (struct isp_dynamic_histogram_cfg *)data_ptr; int i = 0; isp_dynamic_histogram->brightness_trigger = tuning->params.isp_iso_settings.triger.brightness_triger; isp_dynamic_histogram->contrast_trigger = tuning->params.isp_iso_settings.triger.gcontrast_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) { isp_dynamic_histogram->tuning_cfg[i].brightness = tuning->params.isp_iso_settings.isp_dynamic_cfg[i].brightness; isp_dynamic_histogram->tuning_cfg[i].contrast = tuning->params.isp_iso_settings.isp_dynamic_cfg[i].contrast; } /* offset */ data_ptr += sizeof(struct isp_dynamic_histogram_cfg); ret += sizeof(struct isp_dynamic_histogram_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_SATURATION) /* isp_dynamic_saturation */ { struct isp_dynamic_saturation_cfg *isp_dynamic_saturation = (struct isp_dynamic_saturation_cfg *)data_ptr; int i = 0; isp_dynamic_saturation->trigger = tuning->params.isp_iso_settings.triger.saturation_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) { isp_dynamic_saturation->tuning_cfg[i].cb = tuning->params.isp_iso_settings.isp_dynamic_cfg[i].saturation_cb; isp_dynamic_saturation->tuning_cfg[i].cr = tuning->params.isp_iso_settings.isp_dynamic_cfg[i].saturation_cr; memcpy(isp_dynamic_saturation->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].saturation_cfg, sizeof(isp_dynamic_saturation->tuning_cfg[i].value)); } /* offset */ data_ptr += sizeof(struct isp_dynamic_saturation_cfg); ret += sizeof(struct isp_dynamic_saturation_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_CEM) /* isp_dynamic_cem */ { struct isp_dynamic_cem_cfg *isp_dynamic_cem = (struct isp_dynamic_cem_cfg *)data_ptr; int i = 0; isp_dynamic_cem->trigger = tuning->params.isp_iso_settings.triger.cem_ratio_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) isp_dynamic_cem->tuning_cfg[i].value = tuning->params.isp_iso_settings.isp_dynamic_cfg[i].cem_ratio; /* offset */ data_ptr += sizeof(struct isp_dynamic_cem_cfg); ret += sizeof(struct isp_dynamic_cem_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_TDF) /* isp_dynamic_tdf */ { struct isp_dynamic_tdf_cfg *isp_dynamic_tdf = (struct isp_dynamic_tdf_cfg *)data_ptr; int i = 0; isp_dynamic_tdf->trigger = tuning->params.isp_iso_settings.triger.tdf_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(isp_dynamic_tdf->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].tdf_cfg, sizeof(isp_dynamic_tdf->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_tdf_cfg); ret += sizeof(struct isp_dynamic_tdf_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_AE) /* isp_dynamic_ae */ { struct isp_dynamic_ae_cfg *isp_dynamic_ae = (struct isp_dynamic_ae_cfg *)data_ptr; int i = 0; isp_dynamic_ae->trigger = tuning->params.isp_iso_settings.triger.ae_cfg_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(isp_dynamic_ae->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].ae_cfg, sizeof(isp_dynamic_ae->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_ae_cfg); ret += sizeof(struct isp_dynamic_ae_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_GTM) /* isp_dynamic_gtm */ { struct isp_dynamic_gtm_cfg *isp_dynamic_gtm = (struct isp_dynamic_gtm_cfg *)data_ptr; int i = 0; isp_dynamic_gtm->trigger = tuning->params.isp_iso_settings.triger.gtm_cfg_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(isp_dynamic_gtm->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].gtm_cfg, sizeof(isp_dynamic_gtm->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_gtm_cfg); ret += sizeof(struct isp_dynamic_gtm_cfg); } #if (ISP_VERSION >= 521) if (cfg_ids & HW_ISP_CFG_DYNAMIC_LCA) /* isp_dynamic_lca */ { struct isp_dynamic_lca_cfg *isp_dynamic_lca = (struct isp_dynamic_lca_cfg *)data_ptr; int i = 0; isp_dynamic_lca->trigger = tuning->params.isp_iso_settings.triger.lca_cfg_triger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(isp_dynamic_lca->tuning_cfg[i].value, tuning->params.isp_iso_settings.isp_dynamic_cfg[i].lca_cfg, sizeof(isp_dynamic_lca->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_lca_cfg); ret += sizeof(struct isp_dynamic_lca_cfg); } #endif break; default: ret = AW_ERR_VI_INVALID_PARA; break; } data_ptr = NULL; return ret; } HW_S32 isp_tuning_set_cfg(struct hw_isp_device *isp, HW_U8 group_id, HW_U32 cfg_ids, void *cfg_data) { int ret = AW_ERR_VI_INVALID_PARA; unsigned char *data_ptr = NULL; struct isp_tuning *tuning = NULL; if (!isp || !cfg_data) return AW_ERR_VI_INVALID_PARA; /* call isp api */ tuning = isp_dev_get_tuning(isp); if (!tuning) return AW_ERR_VI_INVALID_NULL_PTR; if (!tuning->ctx) return AW_ERR_VI_INVALID_NULL_PTR; /* fill cfg data */ ret = 0; data_ptr = (unsigned char *)cfg_data; switch (group_id) { case HW_ISP_CFG_TEST: /* isp_test_param */ if (cfg_ids & HW_ISP_CFG_TEST_PUB) /* isp_test_pub */ { struct isp_test_pub_cfg *isp_test_pub = (struct isp_test_pub_cfg *)data_ptr; tuning->params.isp_test_settings.isp_test_mode = isp_test_pub->test_mode; tuning->params.isp_test_settings.isp_gain = isp_test_pub->gain; tuning->params.isp_test_settings.isp_exp_line = isp_test_pub->exp_line; tuning->params.isp_test_settings.isp_color_temp = isp_test_pub->color_temp; tuning->params.isp_test_settings.isp_log_param = isp_test_pub->log_param; /* offset */ data_ptr += sizeof(struct isp_test_pub_cfg); ret += sizeof(struct isp_test_pub_cfg); } if (cfg_ids & HW_ISP_CFG_TEST_EXPTIME) /* isp_test_exptime */ { struct isp_test_item_cfg *isp_test_exptime = (struct isp_test_item_cfg *)data_ptr; tuning->params.isp_test_settings.isp_test_exptime = isp_test_exptime->enable; tuning->params.isp_test_settings.exp_line_start = isp_test_exptime->start; tuning->params.isp_test_settings.exp_line_step = isp_test_exptime->step; tuning->params.isp_test_settings.exp_line_end = isp_test_exptime->end; tuning->params.isp_test_settings.exp_change_interval = isp_test_exptime->change_interval; /* offset */ data_ptr += sizeof(struct isp_test_item_cfg); ret += sizeof(struct isp_test_item_cfg); } if (cfg_ids & HW_ISP_CFG_TEST_GAIN) /* isp_test_gain */ { struct isp_test_item_cfg *isp_test_gain = (struct isp_test_item_cfg *)data_ptr; tuning->params.isp_test_settings.isp_test_gain = isp_test_gain->enable; tuning->params.isp_test_settings.gain_start = isp_test_gain->start; tuning->params.isp_test_settings.gain_step = isp_test_gain->step; tuning->params.isp_test_settings.gain_end = isp_test_gain->end; tuning->params.isp_test_settings.gain_change_interval = isp_test_gain->change_interval; /* offset */ data_ptr += sizeof(struct isp_test_item_cfg); ret += sizeof(struct isp_test_item_cfg); } if (cfg_ids & HW_ISP_CFG_TEST_FOCUS) /* isp_test_focus */ { struct isp_test_item_cfg *isp_test_focus = (struct isp_test_item_cfg *)data_ptr; tuning->params.isp_test_settings.isp_test_focus = isp_test_focus->enable; tuning->params.isp_test_settings.focus_start = isp_test_focus->start; tuning->params.isp_test_settings.focus_step = isp_test_focus->step; tuning->params.isp_test_settings.focus_end = isp_test_focus->end; tuning->params.isp_test_settings.focus_change_interval = isp_test_focus->change_interval; /* offset */ data_ptr += sizeof(struct isp_test_item_cfg); ret += sizeof(struct isp_test_item_cfg); } if (cfg_ids & HW_ISP_CFG_TEST_FORCED) /* isp_test_forced */ { struct isp_test_forced_cfg *isp_test_forced = (struct isp_test_forced_cfg *)data_ptr; tuning->params.isp_test_settings.ae_forced = isp_test_forced->ae_enable; tuning->params.isp_test_settings.lum_forced = isp_test_forced->lum; /* offset */ data_ptr += sizeof(struct isp_test_forced_cfg); ret += sizeof(struct isp_test_forced_cfg); } if (cfg_ids & HW_ISP_CFG_TEST_ENABLE) /* isp_test_enable */ { memcpy(&(tuning->params.isp_test_settings.manual_en), data_ptr, sizeof(struct isp_test_enable_cfg)); /* offset */ data_ptr += sizeof(struct isp_test_enable_cfg); ret += sizeof(struct isp_test_enable_cfg); } break; case HW_ISP_CFG_3A: /* isp_3a_param */ if (cfg_ids & HW_ISP_CFG_AE_PUB) /* isp_ae_pub */ { struct isp_ae_pub_cfg *isp_ae_pub = (struct isp_ae_pub_cfg *)data_ptr; tuning->params.isp_3a_settings.define_ae_table = isp_ae_pub->define_table; tuning->params.isp_3a_settings.ae_max_lv = isp_ae_pub->max_lv; tuning->params.isp_3a_settings.ae_hist_mod_en = isp_ae_pub->hist_mode_en; tuning->params.isp_3a_settings.ae_hist_sel = isp_ae_pub->hist_sel; tuning->params.isp_3a_settings.ae_stat_sel = isp_ae_pub->stat_sel; tuning->params.isp_3a_settings.exp_comp_step = isp_ae_pub->compensation_step; tuning->params.isp_3a_settings.ae_touch_dist_ind = isp_ae_pub->touch_dist_index; tuning->params.isp_3a_settings.ae_iso2gain_ratio = isp_ae_pub->iso2gain_ratio; memcpy(&tuning->params.isp_3a_settings.ae_fno_step[0], &isp_ae_pub->fno_table[0], sizeof(isp_ae_pub->fno_table)); tuning->params.isp_3a_settings.ae_ki = isp_ae_pub->ki; tuning->params.isp_3a_settings.ae_ConvDataIndex = isp_ae_pub->conv_data_index; tuning->params.isp_3a_settings.ae_blowout_pre_en = isp_ae_pub->blowout_pre_en; tuning->params.isp_3a_settings.ae_blowout_attr = isp_ae_pub->blowout_attr; memcpy(&tuning->params.isp_3a_settings.wdr_cfg[0], &isp_ae_pub->wdr_cfg[0], sizeof(isp_ae_pub->wdr_cfg)); /* offset */ data_ptr += sizeof(struct isp_ae_pub_cfg); ret += sizeof(struct isp_ae_pub_cfg); } if (cfg_ids & HW_ISP_CFG_AE_PREVIEW_TBL) /* isp_ae_preview_tbl */ { struct isp_ae_table_cfg *isp_ae_preview_tbl = (struct isp_ae_table_cfg *)data_ptr; tuning->params.isp_3a_settings.ae_table_preview_length = isp_ae_preview_tbl->length; memcpy(tuning->params.isp_3a_settings.ae_table_preview, &(isp_ae_preview_tbl->value[0]), sizeof(isp_ae_preview_tbl->value)); /* offset */ data_ptr += sizeof(struct isp_ae_table_cfg); ret += sizeof(struct isp_ae_table_cfg); } if (cfg_ids & HW_ISP_CFG_AE_CAPTURE_TBL) /* isp_ae_capture_tbl */ { struct isp_ae_table_cfg *isp_ae_capture_tbl = (struct isp_ae_table_cfg *)data_ptr; tuning->params.isp_3a_settings.ae_table_capture_length = isp_ae_capture_tbl->length; memcpy(tuning->params.isp_3a_settings.ae_table_capture, &(isp_ae_capture_tbl->value[0]), sizeof(isp_ae_capture_tbl->value)); /* offset */ data_ptr += sizeof(struct isp_ae_table_cfg); ret += sizeof(struct isp_ae_table_cfg); } if (cfg_ids & HW_ISP_CFG_AE_VIDEO_TBL) /* isp_ae_video_tbl */ { struct isp_ae_table_cfg *isp_ae_video_tbl = (struct isp_ae_table_cfg *)data_ptr; tuning->params.isp_3a_settings.ae_table_video_length = isp_ae_video_tbl->length; memcpy(tuning->params.isp_3a_settings.ae_table_video, &(isp_ae_video_tbl->value[0]), sizeof(isp_ae_video_tbl->value)); /* offset */ data_ptr += sizeof(struct isp_ae_table_cfg); ret += sizeof(struct isp_ae_table_cfg); } if (cfg_ids & HW_ISP_CFG_AE_WIN_WEIGHT) /* isp_ae_win_weight */ { memcpy(tuning->params.isp_3a_settings.ae_win_weight, data_ptr, sizeof(struct isp_ae_weight_cfg)); /* offset */ data_ptr += sizeof(struct isp_ae_weight_cfg); ret += sizeof(struct isp_ae_weight_cfg); } if (cfg_ids & HW_ISP_CFG_AE_DELAY) /* isp_ae_delay */ { struct isp_ae_delay_cfg *isp_ae_delay = (struct isp_ae_delay_cfg *)data_ptr; tuning->params.isp_3a_settings.ae_delay_frame = isp_ae_delay->ae_frame; tuning->params.isp_3a_settings.exp_delay_frame = isp_ae_delay->exp_frame; tuning->params.isp_3a_settings.gain_delay_frame = isp_ae_delay->gain_frame; /* offset */ data_ptr += sizeof(struct isp_ae_delay_cfg); ret += sizeof(struct isp_ae_delay_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_PUB) /* isp_awb_pub */ { struct isp_awb_pub_cfg *isp_awb_pub = (struct isp_awb_pub_cfg *)data_ptr; tuning->params.isp_3a_settings.awb_interval = isp_awb_pub->interval; tuning->params.isp_3a_settings.awb_speed = isp_awb_pub->speed; tuning->params.isp_3a_settings.awb_stat_sel = isp_awb_pub->stat_sel; /* offset */ data_ptr += sizeof(struct isp_awb_pub_cfg); ret += sizeof(struct isp_awb_pub_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_TEMP_RANGE) /* isp_awb_temp_range */ { struct isp_awb_temp_range_cfg *isp_awb_temp_range = (struct isp_awb_temp_range_cfg *)data_ptr; tuning->params.isp_3a_settings.awb_color_temper_low = isp_awb_temp_range->low; tuning->params.isp_3a_settings.awb_color_temper_high = isp_awb_temp_range->high; tuning->params.isp_3a_settings.awb_base_temper = isp_awb_temp_range->base; /* offset */ data_ptr += sizeof(struct isp_awb_temp_range_cfg); ret += sizeof(struct isp_awb_temp_range_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_DIST) /* isp_awb_dist */ { struct isp_awb_dist_cfg *isp_awb_dist = (struct isp_awb_dist_cfg *)data_ptr; tuning->params.isp_3a_settings.awb_green_zone_dist = isp_awb_dist->green_zone; tuning->params.isp_3a_settings.awb_blue_sky_dist = isp_awb_dist->blue_sky; /* offset */ data_ptr += sizeof(struct isp_awb_dist_cfg); ret += sizeof(struct isp_awb_dist_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_LIGHT_INFO) /* isp_awb_light_info */ { struct isp_awb_temp_info_cfg *isp_awb_light_info = (struct isp_awb_temp_info_cfg *)data_ptr; tuning->params.isp_3a_settings.awb_light_num = isp_awb_light_info->number; memcpy(tuning->params.isp_3a_settings.awb_light_info, isp_awb_light_info->value, sizeof(tuning->params.isp_3a_settings.awb_light_info)); /* offset */ data_ptr += sizeof(struct isp_awb_temp_info_cfg); ret += sizeof(struct isp_awb_temp_info_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_EXT_LIGHT_INFO) /* isp_awb_ext_light_info */ { struct isp_awb_temp_info_cfg *isp_awb_ext_light_info = (struct isp_awb_temp_info_cfg *)data_ptr; tuning->params.isp_3a_settings.awb_ext_light_num = isp_awb_ext_light_info->number; memcpy(tuning->params.isp_3a_settings.awb_ext_light_info, isp_awb_ext_light_info->value, sizeof(tuning->params.isp_3a_settings.awb_ext_light_info)); /* offset */ data_ptr += sizeof(struct isp_awb_temp_info_cfg); ret += sizeof(struct isp_awb_temp_info_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_SKIN_INFO) /* isp_awb_skin_info */ { struct isp_awb_temp_info_cfg *isp_awb_skin_info = (struct isp_awb_temp_info_cfg *)data_ptr; tuning->params.isp_3a_settings.awb_skin_color_num = isp_awb_skin_info->number; memcpy(tuning->params.isp_3a_settings.awb_skin_color_info, isp_awb_skin_info->value, sizeof(tuning->params.isp_3a_settings.awb_skin_color_info)); /* offset */ data_ptr += sizeof(struct isp_awb_temp_info_cfg); ret += sizeof(struct isp_awb_temp_info_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_SPECIAL_INFO) /* isp_awb_special_info */ { struct isp_awb_temp_info_cfg *isp_awb_special_info = (struct isp_awb_temp_info_cfg *)data_ptr; tuning->params.isp_3a_settings.awb_special_color_num = isp_awb_special_info->number; memcpy(tuning->params.isp_3a_settings.awb_special_color_info, isp_awb_special_info->value, sizeof(tuning->params.isp_3a_settings.awb_special_color_info)); /* offset */ data_ptr += sizeof(struct isp_awb_temp_info_cfg); ret += sizeof(struct isp_awb_temp_info_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_PRESET_GAIN) /* isp_awb_preset_gain */ { memcpy(tuning->params.isp_3a_settings.awb_preset_gain, data_ptr, sizeof(struct isp_awb_preset_gain_cfg)); /* offset */ data_ptr += sizeof(struct isp_awb_preset_gain_cfg); ret += sizeof(struct isp_awb_preset_gain_cfg); } if (cfg_ids & HW_ISP_CFG_AWB_FAVOR) /* isp_awb_favor */ { struct isp_awb_favor_cfg *isp_awb_favor = (struct isp_awb_favor_cfg *)data_ptr; tuning->params.isp_3a_settings.awb_rgain_favor = isp_awb_favor->rgain; tuning->params.isp_3a_settings.awb_bgain_favor = isp_awb_favor->bgain; /* offset */ data_ptr += sizeof(struct isp_awb_favor_cfg); ret += sizeof(struct isp_awb_favor_cfg); } if (cfg_ids & HW_ISP_CFG_AF_VCM_CODE) /* isp_af_vcm_code */ { struct isp_af_vcm_code_cfg *isp_af_vcm_code = (struct isp_af_vcm_code_cfg *)data_ptr; tuning->params.isp_3a_settings.vcm_min_code = isp_af_vcm_code->min; tuning->params.isp_3a_settings.vcm_max_code = isp_af_vcm_code->max; /* offset */ data_ptr += sizeof(struct isp_af_vcm_code_cfg); ret += sizeof(struct isp_af_vcm_code_cfg); } if (cfg_ids & HW_ISP_CFG_AF_OTP) /* isp_af_otp */ { struct isp_af_otp_cfg *isp_af_otp = (struct isp_af_otp_cfg *)data_ptr; tuning->params.isp_3a_settings.af_use_otp = isp_af_otp->use_otp; /* offset */ data_ptr += sizeof(struct isp_af_otp_cfg); ret += sizeof(struct isp_af_otp_cfg); } if (cfg_ids & HW_ISP_CFG_AF_SPEED) /* isp_af_speed */ { struct isp_af_speed_cfg *isp_af_speed = (struct isp_af_speed_cfg *)data_ptr; tuning->params.isp_3a_settings.af_interval_time = isp_af_speed->interval_time; tuning->params.isp_3a_settings.af_speed_ind = isp_af_speed->index; /* offset */ data_ptr += sizeof(struct isp_af_speed_cfg); ret += sizeof(struct isp_af_speed_cfg); } if (cfg_ids & HW_ISP_CFG_AF_FINE_SEARCH) /* isp_af_fine_search */ { struct isp_af_fine_search_cfg *isp_af_fine_search = (struct isp_af_fine_search_cfg *)data_ptr; tuning->params.isp_3a_settings.af_auto_fine_en = isp_af_fine_search->auto_en; tuning->params.isp_3a_settings.af_single_fine_en = isp_af_fine_search->single_en; tuning->params.isp_3a_settings.af_fine_step = isp_af_fine_search->step; /* offset */ data_ptr += sizeof(struct isp_af_fine_search_cfg); ret += sizeof(struct isp_af_fine_search_cfg); } if (cfg_ids & HW_ISP_CFG_AF_REFOCUS) /* isp_af_refocus */ { struct isp_af_refocus_cfg *isp_af_refocus = (struct isp_af_refocus_cfg *)data_ptr; tuning->params.isp_3a_settings.af_move_cnt = isp_af_refocus->move_cnt; tuning->params.isp_3a_settings.af_still_cnt = isp_af_refocus->still_cnt; tuning->params.isp_3a_settings.af_move_monitor_cnt = isp_af_refocus->move_monitor_cnt; tuning->params.isp_3a_settings.af_still_monitor_cnt = isp_af_refocus->still_monitor_cnt; /* offset */ data_ptr += sizeof(struct isp_af_refocus_cfg); ret += sizeof(struct isp_af_refocus_cfg); } if (cfg_ids & HW_ISP_CFG_AF_TOLERANCE) /* isp_af_tolerance */ { struct isp_af_tolerance_cfg *isp_af_tolerance = (struct isp_af_tolerance_cfg *)data_ptr; tuning->params.isp_3a_settings.af_near_tolerance = isp_af_tolerance->near_distance; tuning->params.isp_3a_settings.af_far_tolerance = isp_af_tolerance->far_distance; tuning->params.isp_3a_settings.af_tolerance_off = isp_af_tolerance->offset; tuning->params.isp_3a_settings.af_tolerance_tbl_len = isp_af_tolerance->table_length; memcpy(tuning->params.isp_3a_settings.af_std_code_tbl, isp_af_tolerance->std_code_table, sizeof(isp_af_tolerance->std_code_table)); memcpy(tuning->params.isp_3a_settings.af_tolerance_value_tbl, isp_af_tolerance->value, sizeof(isp_af_tolerance->value)); /* offset */ data_ptr += sizeof(struct isp_af_tolerance_cfg); ret += sizeof(struct isp_af_tolerance_cfg); } if (cfg_ids & HW_ISP_CFG_AF_SCENE) /* isp_af_scene */ { struct isp_af_scene_cfg *isp_af_scene = (struct isp_af_scene_cfg *)data_ptr; tuning->params.isp_3a_settings.af_stable_min = isp_af_scene->stable_min; tuning->params.isp_3a_settings.af_stable_max = isp_af_scene->stable_max; tuning->params.isp_3a_settings.af_low_light_lv = isp_af_scene->low_light_lv; tuning->params.isp_3a_settings.af_peak_th = isp_af_scene->peak_thres; tuning->params.isp_3a_settings.af_dir_th = isp_af_scene->direction_thres; tuning->params.isp_3a_settings.af_change_ratio = isp_af_scene->change_ratio; tuning->params.isp_3a_settings.af_move_minus = isp_af_scene->move_minus; tuning->params.isp_3a_settings.af_still_minus = isp_af_scene->still_minus; tuning->params.isp_3a_settings.af_scene_motion_th = isp_af_scene->scene_motion_thres; /* offset */ data_ptr += sizeof(struct isp_af_scene_cfg); ret += sizeof(struct isp_af_scene_cfg); } break; case HW_ISP_CFG_TUNING: /* isp_tunning_param */ if (cfg_ids & HW_ISP_CFG_TUNING_FLASH) /* isp_flash */ { struct isp_tuning_flash_cfg *isp_tuning_flash = (struct isp_tuning_flash_cfg *)data_ptr; tuning->params.isp_tunning_settings.flash_gain = isp_tuning_flash->gain; tuning->params.isp_tunning_settings.flash_delay_frame = isp_tuning_flash->delay_frame; /* offset */ data_ptr += sizeof(struct isp_tuning_flash_cfg); ret += sizeof(struct isp_tuning_flash_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_FLICKER) /* isp_flicker */ { struct isp_tuning_flicker_cfg *isp_tuning_flicker = (struct isp_tuning_flicker_cfg *)data_ptr; tuning->params.isp_tunning_settings.flicker_type = isp_tuning_flicker->type; tuning->params.isp_tunning_settings.flicker_ratio = isp_tuning_flicker->ratio; /* offset */ data_ptr += sizeof(struct isp_tuning_flicker_cfg); ret += sizeof(struct isp_tuning_flicker_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_VISUAL_ANGLE) /* isp_visual_angle */ { struct isp_tuning_visual_angle_cfg *isp_visual_angle = (struct isp_tuning_visual_angle_cfg *)data_ptr; tuning->params.isp_tunning_settings.hor_visual_angle = isp_visual_angle->horizontal; tuning->params.isp_tunning_settings.ver_visual_angle = isp_visual_angle->vertical; tuning->params.isp_tunning_settings.focus_length = isp_visual_angle->focus_length; /* offset */ data_ptr += sizeof(struct isp_tuning_visual_angle_cfg); ret += sizeof(struct isp_tuning_visual_angle_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_GTM) /* isp_gtm */ { struct isp_tuning_gtm_cfg *isp_tuning_gtm = (struct isp_tuning_gtm_cfg *)data_ptr; tuning->params.isp_tunning_settings.gtm_type = isp_tuning_gtm->type; tuning->params.isp_tunning_settings.gamma_type = isp_tuning_gtm->gamma_type; tuning->params.isp_tunning_settings.auto_alpha_en = isp_tuning_gtm->auto_alpha_en; /* offset */ data_ptr += sizeof(struct isp_tuning_gtm_cfg); ret += sizeof(struct isp_tuning_gtm_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CFA) /* isp_tuning_cfa */ { struct isp_tuning_cfa_cfg *isp_tuning_cfa = (struct isp_tuning_cfa_cfg *)data_ptr; tuning->params.isp_tunning_settings.cfa_dir_th = isp_tuning_cfa->dir_thres; tuning->params.isp_tunning_settings.cfa_interp_mode = isp_tuning_cfa->interp_mode; tuning->params.isp_tunning_settings.cfa_zig_zag = isp_tuning_cfa->zig_zag; /* offset */ data_ptr += sizeof(struct isp_tuning_cfa_cfg); ret += sizeof(struct isp_tuning_cfa_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CTC) /* isp_tuning_ctc */ { struct isp_tuning_ctc_cfg *isp_tuning_ctc = (struct isp_tuning_ctc_cfg *)data_ptr; tuning->params.isp_tunning_settings.ctc_th_min = isp_tuning_ctc->min_thres; tuning->params.isp_tunning_settings.ctc_th_max = isp_tuning_ctc->max_thres; tuning->params.isp_tunning_settings.ctc_th_slope = isp_tuning_ctc->slope_thres; tuning->params.isp_tunning_settings.ctc_dir_wt = isp_tuning_ctc->dir_wt; tuning->params.isp_tunning_settings.ctc_dir_th = isp_tuning_ctc->dir_thres; /* offset */ data_ptr += sizeof(struct isp_tuning_ctc_cfg); ret += sizeof(struct isp_tuning_ctc_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_DIGITAL_GAIN) /* isp_tuning_digital_gain */ { memcpy(tuning->params.isp_tunning_settings.bayer_gain, data_ptr, sizeof(struct isp_tuning_blc_gain_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_blc_gain_cfg); ret += sizeof(struct isp_tuning_blc_gain_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CCM_LOW) /* isp_ccm_low */ { struct isp_tuning_ccm_cfg *isp_ccm_low = (struct isp_tuning_ccm_cfg *)data_ptr; tuning->params.isp_tunning_settings.cm_trig_cfg[0] = isp_ccm_low->temperature; memcpy(&(tuning->params.isp_tunning_settings.color_matrix_ini[0]), &isp_ccm_low->value, sizeof(struct isp_rgb2rgb_gain_offset)); /* offset */ data_ptr += sizeof(struct isp_tuning_ccm_cfg); ret += sizeof(struct isp_tuning_ccm_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CCM_MID) /* isp_ccm_mid */ { struct isp_tuning_ccm_cfg *isp_ccm_mid = (struct isp_tuning_ccm_cfg *)data_ptr; tuning->params.isp_tunning_settings.cm_trig_cfg[1] = isp_ccm_mid->temperature; memcpy(&(tuning->params.isp_tunning_settings.color_matrix_ini[1]), &isp_ccm_mid->value, sizeof(struct isp_rgb2rgb_gain_offset)); /* offset */ data_ptr += sizeof(struct isp_tuning_ccm_cfg); ret += sizeof(struct isp_tuning_ccm_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CCM_HIGH) /* isp_ccm_high */ { struct isp_tuning_ccm_cfg *isp_ccm_high = (struct isp_tuning_ccm_cfg *)data_ptr; tuning->params.isp_tunning_settings.cm_trig_cfg[2] = isp_ccm_high->temperature; memcpy(&(tuning->params.isp_tunning_settings.color_matrix_ini[2]), &isp_ccm_high->value, sizeof(struct isp_rgb2rgb_gain_offset)); /* offset */ data_ptr += sizeof(struct isp_tuning_ccm_cfg); ret += sizeof(struct isp_tuning_ccm_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_PLTM) /* isp_tuning_pltm */ { memcpy(tuning->params.isp_tunning_settings.pltm_cfg, data_ptr, sizeof(struct isp_tuning_pltm_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_pltm_cfg); ret += sizeof(struct isp_tuning_pltm_cfg); } #if (ISP_VERSION >= 521) if (cfg_ids & HW_ISP_CFG_TUNING_GCA) /* isp_tuning_gca */ { memcpy(tuning->params.isp_tunning_settings.gca_cfg, data_ptr, sizeof(struct isp_tuning_gca_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_gca_cfg); ret += sizeof(struct isp_tuning_gca_cfg); } #endif break; case HW_ISP_CFG_TUNING_TABLES: /* isp tuning tables*/ if (cfg_ids & HW_ISP_CFG_TUNING_LSC) /* isp_lsc */ { struct isp_tuning_lsc_table_cfg *isp_tuning_lsc = (struct isp_tuning_lsc_table_cfg *)data_ptr; #if (ISP_VERSION >= 521) tuning->params.isp_tunning_settings.lsc_mode = isp_tuning_lsc->lsc_mode; #endif tuning->params.isp_tunning_settings.ff_mod = isp_tuning_lsc->ff_mod; tuning->params.isp_tunning_settings.lsc_center_x = isp_tuning_lsc->center_x; tuning->params.isp_tunning_settings.lsc_center_y = isp_tuning_lsc->center_y; tuning->params.isp_tunning_settings.rolloff_ratio = isp_tuning_lsc->rolloff_ratio; memcpy(&(tuning->params.isp_tunning_settings.lsc_tbl[0][0]), &(isp_tuning_lsc->value[0][0]), sizeof(isp_tuning_lsc->value)); memcpy(tuning->params.isp_tunning_settings.lsc_trig_cfg, isp_tuning_lsc->color_temp_triggers, sizeof(isp_tuning_lsc->color_temp_triggers)); /* offset */ data_ptr += sizeof(struct isp_tuning_lsc_table_cfg); ret += sizeof(struct isp_tuning_lsc_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_GAMMA) /* isp_gamma */ { struct isp_tuning_gamma_table_cfg *isp_tuning_gamma = (struct isp_tuning_gamma_table_cfg *)data_ptr; tuning->params.isp_tunning_settings.gamma_num = isp_tuning_gamma->number; memcpy(&(tuning->params.isp_tunning_settings.gamma_tbl_ini[0][0]), &(isp_tuning_gamma->value[0][0]), sizeof(isp_tuning_gamma->value)); memcpy(tuning->params.isp_tunning_settings.gamma_trig_cfg, isp_tuning_gamma->lv_triggers, sizeof(isp_tuning_gamma->lv_triggers)); /* offset */ data_ptr += sizeof(struct isp_tuning_gamma_table_cfg); ret += sizeof(struct isp_tuning_gamma_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_LINEARITY) /* isp_linearity */ { memcpy(tuning->params.isp_tunning_settings.linear_tbl, data_ptr, sizeof(struct isp_tuning_linearity_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_linearity_table_cfg); ret += sizeof(struct isp_tuning_linearity_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_DISTORTION) /* isp_distortion */ { memcpy(tuning->params.isp_tunning_settings.disc_tbl, data_ptr, sizeof(struct isp_tuning_distortion_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_distortion_table_cfg); ret += sizeof(struct isp_tuning_distortion_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_BDNF) /* isp_tuning_bdnf */ { memcpy(tuning->params.isp_tunning_settings.isp_bdnf_th, data_ptr, sizeof(struct isp_tuning_bdnf_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_bdnf_table_cfg); ret += sizeof(struct isp_tuning_bdnf_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_TDNF) /* isp_tuning_tdnf */ { struct isp_tuning_tdnf_table_cfg *isp_tuning_tdnf = (struct isp_tuning_tdnf_table_cfg *)data_ptr; memcpy(tuning->params.isp_tunning_settings.isp_tdnf_th, isp_tuning_tdnf->thres, sizeof(isp_tuning_tdnf->thres)); memcpy(tuning->params.isp_tunning_settings.isp_tdnf_ref_noise, isp_tuning_tdnf->ref_noise, sizeof(isp_tuning_tdnf->ref_noise)); memcpy(tuning->params.isp_tunning_settings.isp_tdnf_k, isp_tuning_tdnf->k_val, sizeof(isp_tuning_tdnf->k_val)); memcpy(tuning->params.isp_tunning_settings.isp_tdnf_diff, isp_tuning_tdnf->diff, sizeof(isp_tuning_tdnf->diff)); #if (ISP_VERSION >= 520) memcpy(tuning->params.isp_tunning_settings.isp_d3d_k3d_incre_curve, isp_tuning_tdnf->d3d_k3d, sizeof(isp_tuning_tdnf->d3d_k3d)); #endif /* offset */ data_ptr += sizeof(struct isp_tuning_tdnf_table_cfg); ret += sizeof(struct isp_tuning_tdnf_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CONTRAST) /* isp_tuning_contrast */ { struct isp_tuning_contrast_table_cfg *isp_tuning_contrast = (struct isp_tuning_contrast_table_cfg *)data_ptr; memcpy(tuning->params.isp_tunning_settings.isp_contrast_val, isp_tuning_contrast->val, sizeof(isp_tuning_contrast->val)); memcpy(tuning->params.isp_tunning_settings.isp_contrast_lum, isp_tuning_contrast->lum, sizeof(isp_tuning_contrast->lum)); memcpy(tuning->params.isp_tunning_settings.isp_contrat_pe, isp_tuning_contrast->pe, sizeof(isp_tuning_contrast->pe)); /* offset */ data_ptr += sizeof(struct isp_tuning_contrast_table_cfg); ret += sizeof(struct isp_tuning_contrast_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_SHARP) /* isp_tuning_sharp */ { struct isp_tuning_sharp_table_cfg *isp_tuning_sharp = (struct isp_tuning_sharp_table_cfg *)data_ptr; memcpy(tuning->params.isp_tunning_settings.isp_sharp_val, isp_tuning_sharp->value, sizeof(isp_tuning_sharp->value)); memcpy(tuning->params.isp_tunning_settings.isp_sharp_lum, isp_tuning_sharp->lum, sizeof(isp_tuning_sharp->lum)); #if (ISP_VERSION >= 520) memcpy(tuning->params.isp_tunning_settings.isp_sharp_edge_lum, isp_tuning_sharp->edge_lum, sizeof(isp_tuning_sharp->edge_lum)); memcpy(tuning->params.isp_tunning_settings.isp_sharp_hfrq_lum, isp_tuning_sharp->hfrq_lum, sizeof(isp_tuning_sharp->hfrq_lum)); memcpy(tuning->params.isp_tunning_settings.isp_sharp_hsv, isp_tuning_sharp->hsv, sizeof(isp_tuning_sharp->hsv)); memcpy(tuning->params.isp_tunning_settings.isp_sharp_s_map, isp_tuning_sharp->smap, sizeof(isp_tuning_sharp->smap)); #endif /* offset */ data_ptr += sizeof(struct isp_tuning_sharp_table_cfg); ret += sizeof(struct isp_tuning_sharp_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CEM) /* isp_tuning_cem */ { memcpy(tuning->params.isp_tunning_settings.isp_cem_table, data_ptr, sizeof(struct isp_tuning_cem_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_cem_table_cfg); ret += sizeof(struct isp_tuning_cem_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_CEM_1) /* isp_tuning_cem_1 */ { memcpy(tuning->params.isp_tunning_settings.isp_cem_table1, data_ptr, sizeof(struct isp_tuning_cem_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_cem_table_cfg); ret += sizeof(struct isp_tuning_cem_table_cfg); } #if (ISP_VERSION != 522) if (cfg_ids & HW_ISP_CFG_TUNING_PLTM_TBL) /* isp_tuning_pltm_table */ { memcpy(tuning->params.isp_tunning_settings.isp_pltm_table, data_ptr, sizeof(struct isp_tuning_pltm_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_pltm_table_cfg); ret += sizeof(struct isp_tuning_pltm_table_cfg); } if (cfg_ids & HW_ISP_CFG_TUNING_WDR) /* isp_tuning_wdr */ { memcpy(tuning->params.isp_tunning_settings.isp_wdr_table, data_ptr, sizeof(struct isp_tuning_wdr_table_cfg)); /* offset */ data_ptr += sizeof(struct isp_tuning_wdr_table_cfg); ret += sizeof(struct isp_tuning_wdr_table_cfg); } #endif #if (ISP_VERSION >= 521) if (cfg_ids & HW_ISP_CFG_TUNING_LCA_TBL) { memcpy(tuning->params.isp_tunning_settings.lca_pf_satu_lut, data_ptr, sizeof(struct isp_tuning_lca_pf_satu_lut)); // lca_pf_satu_lut offset data_ptr += sizeof(struct isp_tuning_lca_pf_satu_lut); ret += sizeof(struct isp_tuning_lca_pf_satu_lut); memcpy(tuning->params.isp_tunning_settings.lca_gf_satu_lut, data_ptr, sizeof(struct isp_tuning_lca_gf_satu_lut)); // lca_gf_satu_lut offset data_ptr += sizeof(struct isp_tuning_lca_gf_satu_lut); ret += sizeof(struct isp_tuning_lca_gf_satu_lut); } if (cfg_ids & HW_ISP_CFG_TUNING_MSC) /* isp_tuning_msc */ { struct isp_tuning_msc_table_cfg *isp_tuning_msc = (struct isp_tuning_msc_table_cfg *)data_ptr; tuning->params.isp_tunning_settings.mff_mod = isp_tuning_msc->mff_mod; tuning->params.isp_tunning_settings.msc_mode = isp_tuning_msc->msc_mode; memcpy(tuning->params.isp_tunning_settings.msc_blw_lut, isp_tuning_msc->msc_blw_lut, sizeof(isp_tuning_msc->msc_blw_lut)); memcpy(tuning->params.isp_tunning_settings.msc_blh_lut, isp_tuning_msc->msc_blh_lut, sizeof(isp_tuning_msc->msc_blh_lut)); memcpy(tuning->params.isp_tunning_settings.msc_blw_dlt_lut, isp_tuning_msc->msc_blw_dlt_lut, sizeof(isp_tuning_msc->msc_blw_dlt_lut)); memcpy(tuning->params.isp_tunning_settings.msc_blh_dlt_lut, isp_tuning_msc->msc_blh_dlt_lut, sizeof(isp_tuning_msc->msc_blh_dlt_lut)); memcpy(&(tuning->params.isp_tunning_settings.msc_tbl[0][0]), &(isp_tuning_msc->value[0][0]), sizeof(isp_tuning_msc->value)); memcpy(tuning->params.isp_tunning_settings.msc_trig_cfg, isp_tuning_msc->color_temp_triggers, sizeof(isp_tuning_msc->color_temp_triggers)); /* offset */ data_ptr += sizeof(struct isp_tuning_msc_table_cfg); ret += sizeof(struct isp_tuning_msc_table_cfg); } #endif break; case HW_ISP_CFG_DYNAMIC: /* isp_dynamic_param */ if (cfg_ids & HW_ISP_CFG_DYNAMIC_LUM_POINT) /* isp_dynamic_lum_mapping_point */ { memcpy(tuning->params.isp_iso_settings.isp_lum_mapping_point, data_ptr, sizeof(struct isp_dynamic_single_cfg)); /* offset */ data_ptr += sizeof(struct isp_dynamic_single_cfg); ret += sizeof(struct isp_dynamic_single_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_GAIN_POINT) /* isp_dynamic_gain_mapping_point */ { memcpy(tuning->params.isp_iso_settings.isp_gain_mapping_point, data_ptr, sizeof(struct isp_dynamic_single_cfg)); /* offset */ data_ptr += sizeof(struct isp_dynamic_single_cfg); ret += sizeof(struct isp_dynamic_single_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_SHARP) /* isp_dynamic_sharp */ { struct isp_dynamic_sharp_cfg *isp_dynamic_sharp = (struct isp_dynamic_sharp_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.sharp_triger = (enum isp_triger_type)isp_dynamic_sharp->trigger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) { memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].sharp_cfg, isp_dynamic_sharp->tuning_cfg[i].value, sizeof(isp_dynamic_sharp->tuning_cfg[i].value)); } /* offset */ data_ptr += sizeof(struct isp_dynamic_sharp_cfg); ret += sizeof(struct isp_dynamic_sharp_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_CONTRAST) /* isp_dynamic_contrast */ { struct isp_dynamic_contrast_cfg *isp_dynamic_contrast = (struct isp_dynamic_contrast_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.contrast_triger = (enum isp_triger_type)isp_dynamic_contrast->trigger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) { memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].contrast_cfg, isp_dynamic_contrast->tuning_cfg[i].value, sizeof(isp_dynamic_contrast->tuning_cfg[i].value)); } /* offset */ data_ptr += sizeof(struct isp_dynamic_contrast_cfg); ret += sizeof(struct isp_dynamic_contrast_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_DENOISE) /* isp_dynamic_denoise */ { struct isp_dynamic_denoise_cfg *isp_dynamic_denoise = (struct isp_dynamic_denoise_cfg *)data_ptr; int i = 0; int j = 0; tuning->params.isp_iso_settings.triger.denoise_triger = (enum isp_triger_type)isp_dynamic_denoise->trigger; tuning->params.isp_iso_settings.triger.color_denoise_triger = (enum isp_triger_type)isp_dynamic_denoise->color_trigger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) { if(isp_dynamic_denoise->tuning_cfg[i].ratio == 0) isp_dynamic_denoise->tuning_cfg[i].ratio = 1; for(j= 0; j < ISP_DENOISE_MAX; j++) { isp_dynamic_denoise->tuning_cfg[i].value[j] = isp_dynamic_denoise->tuning_cfg[i].value[j] * isp_dynamic_denoise->tuning_cfg[i].ratio; } memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].denoise_cfg, isp_dynamic_denoise->tuning_cfg[i].value, sizeof(isp_dynamic_denoise->tuning_cfg[i].value)); tuning->params.isp_iso_settings.isp_dynamic_cfg[i].color_denoise = isp_dynamic_denoise->tuning_cfg[i].color_denoise; } /* offset */ data_ptr += sizeof(struct isp_dynamic_denoise_cfg); ret += sizeof(struct isp_dynamic_denoise_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_SENSOR_OFFSET) /* isp_dynamic_sensor_offset */ { struct isp_dynamic_sensor_offset_cfg *isp_dynamic_sensor_offset = (struct isp_dynamic_sensor_offset_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.sensor_offset_triger = (enum isp_triger_type)isp_dynamic_sensor_offset->trigger ; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].sensor_offset, isp_dynamic_sensor_offset->tuning_cfg[i].value, sizeof(isp_dynamic_sensor_offset->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_sensor_offset_cfg); ret += sizeof(struct isp_dynamic_sensor_offset_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_BLACK_LV) /* isp_dynamic_black_level */ { struct isp_dynamic_black_level_cfg *isp_dynamic_black_level = (struct isp_dynamic_black_level_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.black_level_triger = (enum isp_triger_type)isp_dynamic_black_level->trigger ; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].black_level, isp_dynamic_black_level->tuning_cfg[i].value, sizeof(isp_dynamic_black_level->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_black_level_cfg); ret += sizeof(struct isp_dynamic_black_level_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_DPC) /* isp_dynamic_dpc */ { struct isp_dynamic_dpc_cfg *isp_dynamic_dpc = (struct isp_dynamic_dpc_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.dpc_triger = (enum isp_triger_type)isp_dynamic_dpc->trigger ; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].dpc_cfg, isp_dynamic_dpc->tuning_cfg[i].value, sizeof(isp_dynamic_dpc->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_dpc_cfg); ret += sizeof(struct isp_dynamic_dpc_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_PLTM) /* isp_dynamic_pltm */ { struct isp_dynamic_pltm_cfg *isp_dynamic_pltm = (struct isp_dynamic_pltm_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.pltm_dynamic_triger = (enum isp_triger_type)isp_dynamic_pltm->trigger ; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].pltm_dynamic_cfg, isp_dynamic_pltm->tuning_cfg[i].value, sizeof(isp_dynamic_pltm->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_pltm_cfg); ret += sizeof(struct isp_dynamic_pltm_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_DEFOG) /* isp_dynamic_defog */ { struct isp_dynamic_defog_cfg *isp_dynamic_defog = (struct isp_dynamic_defog_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.defog_value_triger = (enum isp_triger_type)isp_dynamic_defog->trigger ; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) tuning->params.isp_iso_settings.isp_dynamic_cfg[i].defog_value = isp_dynamic_defog->tuning_cfg[i].value; /* offset */ data_ptr += sizeof(struct isp_dynamic_defog_cfg); ret += sizeof(struct isp_dynamic_defog_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_HISTOGRAM) /* isp_dynamic_histogram */ { struct isp_dynamic_histogram_cfg *isp_dynamic_histogram = (struct isp_dynamic_histogram_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.brightness_triger = (enum isp_triger_type)isp_dynamic_histogram->brightness_trigger; tuning->params.isp_iso_settings.triger.gcontrast_triger = (enum isp_triger_type)isp_dynamic_histogram->contrast_trigger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) { tuning->params.isp_iso_settings.isp_dynamic_cfg[i].brightness = isp_dynamic_histogram->tuning_cfg[i].brightness; tuning->params.isp_iso_settings.isp_dynamic_cfg[i].contrast = isp_dynamic_histogram->tuning_cfg[i].contrast; } /* offset */ data_ptr += sizeof(struct isp_dynamic_histogram_cfg); ret += sizeof(struct isp_dynamic_histogram_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_SATURATION) /* isp_dynamic_saturation */ { struct isp_dynamic_saturation_cfg *isp_dynamic_saturation = (struct isp_dynamic_saturation_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.saturation_triger = (enum isp_triger_type)isp_dynamic_saturation->trigger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) { tuning->params.isp_iso_settings.isp_dynamic_cfg[i].saturation_cb = isp_dynamic_saturation->tuning_cfg[i].cb; tuning->params.isp_iso_settings.isp_dynamic_cfg[i].saturation_cr = isp_dynamic_saturation->tuning_cfg[i].cr; memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].saturation_cfg, isp_dynamic_saturation->tuning_cfg[i].value, sizeof(isp_dynamic_saturation->tuning_cfg[i].value)); } /* offset */ data_ptr += sizeof(struct isp_dynamic_saturation_cfg); ret += sizeof(struct isp_dynamic_saturation_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_CEM) /* isp_dynamic_cem */ { struct isp_dynamic_cem_cfg *isp_dynamic_cem = (struct isp_dynamic_cem_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.cem_ratio_triger = (enum isp_triger_type)isp_dynamic_cem->trigger ; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) tuning->params.isp_iso_settings.isp_dynamic_cfg[i].cem_ratio = isp_dynamic_cem->tuning_cfg[i].value; /* offset */ data_ptr += sizeof(struct isp_dynamic_cem_cfg); ret += sizeof(struct isp_dynamic_cem_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_TDF) /* isp_dynamic_tdf */ { struct isp_dynamic_tdf_cfg *isp_dynamic_tdf = (struct isp_dynamic_tdf_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.tdf_triger = (enum isp_triger_type)isp_dynamic_tdf->trigger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].tdf_cfg, isp_dynamic_tdf->tuning_cfg[i].value, sizeof(isp_dynamic_tdf->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_tdf_cfg); ret += sizeof(struct isp_dynamic_tdf_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_AE) /* isp_dynamic_ae */ { struct isp_dynamic_ae_cfg *isp_dynamic_ae = (struct isp_dynamic_ae_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.ae_cfg_triger = (enum isp_triger_type)isp_dynamic_ae->trigger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].ae_cfg, isp_dynamic_ae->tuning_cfg[i].value, sizeof(isp_dynamic_ae->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_ae_cfg); ret += sizeof(struct isp_dynamic_ae_cfg); } if (cfg_ids & HW_ISP_CFG_DYNAMIC_GTM) /* isp_dynamic_gtm */ { struct isp_dynamic_gtm_cfg *isp_dynamic_gtm = (struct isp_dynamic_gtm_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.gtm_cfg_triger = (enum isp_triger_type)isp_dynamic_gtm->trigger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].gtm_cfg, isp_dynamic_gtm->tuning_cfg[i].value, sizeof(isp_dynamic_gtm->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_gtm_cfg); ret += sizeof(struct isp_dynamic_gtm_cfg); } #if (ISP_VERSION >= 521) if (cfg_ids & HW_ISP_CFG_DYNAMIC_LCA) /* isp_dynamic_lca */ { struct isp_dynamic_lca_cfg *isp_dynamic_lca = (struct isp_dynamic_lca_cfg *)data_ptr; int i = 0; tuning->params.isp_iso_settings.triger.lca_cfg_triger = (enum isp_triger_type)isp_dynamic_lca->trigger; for (i = 0; i < ISP_DYNAMIC_GROUP_COUNT; i++) memcpy(tuning->params.isp_iso_settings.isp_dynamic_cfg[i].lca_cfg, isp_dynamic_lca->tuning_cfg[i].value, sizeof(isp_dynamic_lca->tuning_cfg[i].value)); /* offset */ data_ptr += sizeof(struct isp_dynamic_lca_cfg); ret += sizeof(struct isp_dynamic_lca_cfg); } #endif break; default: ret = AW_ERR_VI_INVALID_PARA; break; } ISP_PRINT("%s: set done(%d)\n", __FUNCTION__, ret); return ret; }