| /* |
| * drivers/amlogic/media/enhancement/amvecm/dnlp_cal.c |
| * |
| * Copyright (C) 2017 Amlogic, Inc. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| * |
| */ |
| |
| #include <linux/string.h> |
| #include <linux/spinlock.h> |
| #include <linux/module.h> |
| #include <linux/delay.h> |
| #include <linux/slab.h> |
| #include <linux/amlogic/media/utils/amstream.h> |
| #include <linux/amlogic/media/vfm/vframe.h> |
| #include <linux/amlogic/media/amvecm/ve.h> |
| #include "dnlp_cal.h" |
| #include "amve.h" |
| #include "arch/vpp_regs.h" |
| #include <linux/amlogic/media/amvecm/ve.h> |
| #include "dnlp_algorithm/dnlp_alg.h" |
| #include <linux/amlogic/media/amvecm/amvecm.h> |
| |
| bool ve_en; |
| unsigned int ve_dnlp_rt; |
| ulong ve_dnlp_lpf[64], ve_dnlp_reg[16]; |
| ulong ve_dnlp_reg_v2[32]; |
| ulong ve_dnlp_reg_def[16] = { |
| 0x0b070400, 0x1915120e, 0x2723201c, 0x35312e2a, |
| 0x47423d38, 0x5b56514c, 0x6f6a6560, 0x837e7974, |
| 0x97928d88, 0xaba6a19c, 0xbfbab5b0, 0xcfccc9c4, |
| 0xdad7d5d2, 0xe6e3e0dd, 0xf2efece9, 0xfdfaf7f4 |
| }; |
| |
| static bool hist_sel = 1; /*1->vpp , 0->vdin*/ |
| module_param(hist_sel, bool, 0664); |
| MODULE_PARM_DESC(hist_sel, "hist_sel"); |
| |
| static unsigned int dnlp_dbg_print; /*1->vpp , 0->vdin*/ |
| module_param(dnlp_dbg_print, uint, 0664); |
| MODULE_PARM_DESC(dnlp_dbg_print, "dnlp_dbg_print"); |
| |
| bool dnlp_insmod_ok; /*0:fail, 1:ok*/ |
| module_param(dnlp_insmod_ok, bool, 0664); |
| MODULE_PARM_DESC(dnlp_insmod_ok, "dnlp_insmod_ok"); |
| |
| struct dnlp_alg_s *dnlp_alg_function; |
| EXPORT_SYMBOL(dnlp_alg_function); |
| |
| static struct dnlp_alg_input_param_s *dnlp_alg_input; |
| static struct dnlp_alg_output_param_s *dnlp_alg_output; |
| static struct dnlp_dbg_ro_param_s *dnlp_dbg_ro_param; |
| static struct dnlp_dbg_rw_param_s *dnlp_dbg_rw_param; |
| static struct dnlp_dbg_print_s *dnlp_dbg_printk; |
| |
| int *dnlp_scurv_low_copy; |
| int *dnlp_scurv_mid1_copy; |
| int *dnlp_scurv_mid2_copy; |
| int *dnlp_scurv_hgh1_copy; |
| int *dnlp_scurv_hgh2_copy; |
| int *gain_var_lut49_copy; |
| int *wext_gain_copy; |
| int *adp_thrd_copy; |
| int *reg_blk_boost_12_copy; |
| int *reg_adp_ofset_20_copy; |
| int *reg_mono_protect_copy; |
| int *reg_trend_wht_expand_lut8_copy; |
| |
| int *ro_luma_avg4_copy; |
| int *ro_var_d8_copy; |
| int *ro_scurv_gain_copy; |
| int *ro_blk_wht_ext0_copy; |
| int *ro_blk_wht_ext1_copy; |
| int *ro_dnlp_brightness_copy; |
| int *GmScurve_copy; |
| int *clash_curve_copy; |
| int *clsh_scvbld_copy; |
| int *blkwht_ebld_copy; |
| |
| int *dnlp_printk_copy; |
| |
| unsigned char *ve_dnlp_tgt_copy; |
| |
| unsigned int *pre_1_gamma_copy; |
| unsigned int *pre_0_gamma_copy; |
| unsigned int *nTstCnt_copy; |
| unsigned int *ve_dnlp_luma_sum_copy; |
| int *RBASE_copy; |
| bool *menu_chg_en_copy; |
| |
| /* only for debug */ |
| struct dnlp_alg_param_s dnlp_alg_param; |
| struct param_for_dnlp_s *dnlp_alg_node_copy; |
| struct ve_dnlp_curve_param_s dnlp_curve_param_load; |
| struct dnlp_parse_cmd_s dnlp_parse_cmd[] = { |
| {"alg_enable", &(dnlp_alg_param.dnlp_alg_enable)}, |
| {"respond", &(dnlp_alg_param.dnlp_respond)}, |
| {"sel", &(dnlp_alg_param.dnlp_sel)}, |
| {"respond_flag", &(dnlp_alg_param.dnlp_respond_flag)}, |
| {"smhist_ck", &(dnlp_alg_param.dnlp_smhist_ck)}, |
| {"mvreflsh", &(dnlp_alg_param.dnlp_mvreflsh)}, |
| {"pavg_btsft", &(dnlp_alg_param.dnlp_pavg_btsft)}, |
| {"dbg_i2r", &(dnlp_alg_param.dnlp_dbg_i2r)}, |
| {"cuvbld_min", &(dnlp_alg_param.dnlp_cuvbld_min)}, |
| {"cuvbld_max", &(dnlp_alg_param.dnlp_cuvbld_max)}, |
| {"schg_sft", &(dnlp_alg_param.dnlp_schg_sft)}, |
| {"bbd_ratio_low", &(dnlp_alg_param.dnlp_bbd_ratio_low)}, |
| {"bbd_ratio_hig", &(dnlp_alg_param.dnlp_bbd_ratio_hig)}, |
| {"limit_rng", &(dnlp_alg_param.dnlp_limit_rng)}, |
| {"range_det", &(dnlp_alg_param.dnlp_range_det)}, |
| {"blk_cctr", &(dnlp_alg_param.dnlp_blk_cctr)}, |
| {"brgt_ctrl", &(dnlp_alg_param.dnlp_brgt_ctrl)}, |
| {"brgt_range", &(dnlp_alg_param.dnlp_brgt_range)}, |
| {"brght_add", &(dnlp_alg_param.dnlp_brght_add)}, |
| {"brght_max", &(dnlp_alg_param.dnlp_brght_max)}, |
| {"dbg_adjavg", &(dnlp_alg_param.dnlp_dbg_adjavg)}, |
| {"auto_rng", &(dnlp_alg_param.dnlp_auto_rng)}, |
| {"lowrange", &(dnlp_alg_param.dnlp_lowrange)}, |
| {"hghrange", &(dnlp_alg_param.dnlp_hghrange)}, |
| {"satur_rat", &(dnlp_alg_param.dnlp_satur_rat)}, |
| {"satur_max", &(dnlp_alg_param.dnlp_satur_max)}, |
| {"set_saturtn", &(dnlp_alg_param.dnlp_set_saturtn)}, |
| {"sbgnbnd", &(dnlp_alg_param.dnlp_sbgnbnd)}, |
| {"sendbnd", &(dnlp_alg_param.dnlp_sendbnd)}, |
| {"clashBgn", &(dnlp_alg_param.dnlp_clashBgn)}, |
| {"clashEnd", &(dnlp_alg_param.dnlp_clashEnd)}, |
| {"var_th", &(dnlp_alg_param.dnlp_var_th)}, |
| {"clahe_gain_neg", &(dnlp_alg_param.dnlp_clahe_gain_neg)}, |
| {"clahe_gain_pos", &(dnlp_alg_param.dnlp_clahe_gain_pos)}, |
| {"clahe_gain_delta", &(dnlp_alg_param.dnlp_clahe_gain_delta)}, |
| {"mtdbld_rate", &(dnlp_alg_param.dnlp_mtdbld_rate)}, |
| {"adpmtd_lbnd", &(dnlp_alg_param.dnlp_adpmtd_lbnd)}, |
| {"adpmtd_hbnd", &(dnlp_alg_param.dnlp_adpmtd_hbnd)}, |
| {"blkext_ofst", &(dnlp_alg_param.dnlp_blkext_ofst)}, |
| {"whtext_ofst", &(dnlp_alg_param.dnlp_whtext_ofst)}, |
| {"blkext_rate", &(dnlp_alg_param.dnlp_blkext_rate)}, |
| {"whtext_rate", &(dnlp_alg_param.dnlp_whtext_rate)}, |
| {"bwext_div4x_min", &(dnlp_alg_param.dnlp_bwext_div4x_min)}, |
| {"iRgnBgn", &(dnlp_alg_param.dnlp_iRgnBgn)}, |
| {"iRgnEnd", &(dnlp_alg_param.dnlp_iRgnEnd)}, |
| {"dbg_map", &(dnlp_alg_param.dnlp_dbg_map)}, |
| {"final_gain", &(dnlp_alg_param.dnlp_final_gain)}, |
| {"cliprate_v3", &(dnlp_alg_param.dnlp_cliprate_v3)}, |
| {"cliprate_min", &(dnlp_alg_param.dnlp_cliprate_min)}, |
| {"adpcrat_lbnd", &(dnlp_alg_param.dnlp_adpcrat_lbnd)}, |
| {"adpcrat_hbnd", &(dnlp_alg_param.dnlp_adpcrat_hbnd)}, |
| {"scurv_low_th", &(dnlp_alg_param.dnlp_scurv_low_th)}, |
| {"scurv_mid1_th", &(dnlp_alg_param.dnlp_scurv_mid1_th)}, |
| {"scurv_mid2_th", &(dnlp_alg_param.dnlp_scurv_mid2_th)}, |
| {"scurv_hgh1_th", &(dnlp_alg_param.dnlp_scurv_hgh1_th)}, |
| {"scurv_hgh2_th", &(dnlp_alg_param.dnlp_scurv_hgh2_th)}, |
| {"mtdrate_adp_en", &(dnlp_alg_param.dnlp_mtdrate_adp_en)}, |
| {"clahe_method", &(dnlp_alg_param.dnlp_clahe_method)}, |
| {"ble_en", &(dnlp_alg_param.dnlp_ble_en)}, |
| {"norm", &(dnlp_alg_param.dnlp_norm)}, |
| {"scn_chg_th", &(dnlp_alg_param.dnlp_scn_chg_th)}, |
| {"step_th", &(dnlp_alg_param.dnlp_step_th)}, |
| {"iir_step_mux", &(dnlp_alg_param.dnlp_iir_step_mux)}, |
| {"single_bin_bw", &(dnlp_alg_param.dnlp_single_bin_bw)}, |
| {"single_bin_method", &(dnlp_alg_param.dnlp_single_bin_method)}, |
| {"reg_max_slop_1st", &(dnlp_alg_param.dnlp_reg_max_slop_1st)}, |
| {"reg_max_slop_mid", &(dnlp_alg_param.dnlp_reg_max_slop_mid)}, |
| {"reg_max_slop_fin", &(dnlp_alg_param.dnlp_reg_max_slop_fin)}, |
| {"reg_min_slop_1st", &(dnlp_alg_param.dnlp_reg_min_slop_1st)}, |
| {"reg_min_slop_mid", &(dnlp_alg_param.dnlp_reg_min_slop_mid)}, |
| {"reg_min_slop_fin", &(dnlp_alg_param.dnlp_reg_min_slop_fin)}, |
| {"reg_trend_wht_expand_mode", |
| &(dnlp_alg_param.dnlp_reg_trend_wht_expand_mode)}, |
| {"reg_trend_blk_expand_mode", |
| &(dnlp_alg_param.dnlp_reg_trend_blk_expand_mode)}, |
| {"ve_hist_cur_gain", &(dnlp_alg_param.dnlp_ve_hist_cur_gain)}, |
| {"ve_hist_cur_gain_precise", |
| &(dnlp_alg_param.dnlp_ve_hist_cur_gain_precise)}, |
| {"reg_mono_binrang_st", &(dnlp_alg_param.dnlp_reg_mono_binrang_st)}, |
| {"reg_mono_binrang_ed", &(dnlp_alg_param.dnlp_reg_mono_binrang_ed)}, |
| {"", NULL} |
| }; |
| |
| void dnlp_alg_param_copy(void) |
| { |
| dnlp_scurv_low_copy = dnlp_dbg_rw_param->dnlp_scurv_low; |
| dnlp_scurv_mid1_copy = dnlp_dbg_rw_param->dnlp_scurv_mid1; |
| dnlp_scurv_mid2_copy = dnlp_dbg_rw_param->dnlp_scurv_mid2; |
| dnlp_scurv_hgh1_copy = dnlp_dbg_rw_param->dnlp_scurv_hgh1; |
| dnlp_scurv_hgh2_copy = dnlp_dbg_rw_param->dnlp_scurv_hgh2; |
| gain_var_lut49_copy = dnlp_dbg_rw_param->gain_var_lut49; |
| wext_gain_copy = dnlp_dbg_rw_param->wext_gain; |
| adp_thrd_copy = dnlp_dbg_rw_param->adp_thrd; |
| reg_blk_boost_12_copy = dnlp_dbg_rw_param->reg_blk_boost_12; |
| reg_adp_ofset_20_copy = dnlp_dbg_rw_param->reg_adp_ofset_20; |
| reg_mono_protect_copy = dnlp_dbg_rw_param->reg_mono_protect; |
| reg_trend_wht_expand_lut8_copy = |
| dnlp_dbg_rw_param->reg_trend_wht_expand_lut8; |
| |
| ro_luma_avg4_copy = dnlp_dbg_ro_param->ro_luma_avg4; |
| ro_var_d8_copy = dnlp_dbg_ro_param->ro_var_d8; |
| ro_scurv_gain_copy = dnlp_dbg_ro_param->ro_scurv_gain; |
| ro_blk_wht_ext0_copy = dnlp_dbg_ro_param->ro_blk_wht_ext0; |
| ro_blk_wht_ext1_copy = dnlp_dbg_ro_param->ro_blk_wht_ext1; |
| ro_dnlp_brightness_copy = dnlp_dbg_ro_param->ro_dnlp_brightness; |
| GmScurve_copy = dnlp_dbg_ro_param->GmScurve; |
| clash_curve_copy = dnlp_dbg_ro_param->clash_curve; |
| clsh_scvbld_copy = dnlp_dbg_ro_param->clsh_scvbld; |
| blkwht_ebld_copy = dnlp_dbg_ro_param->blkwht_ebld; |
| |
| ve_dnlp_tgt_copy = dnlp_alg_output->ve_dnlp_tgt; |
| |
| pre_1_gamma_copy = dnlp_alg_input->pre_1_gamma; |
| pre_0_gamma_copy = dnlp_alg_input->pre_0_gamma; |
| nTstCnt_copy = dnlp_alg_input->nTstCnt; |
| ve_dnlp_luma_sum_copy = dnlp_alg_input->ve_dnlp_luma_sum; |
| RBASE_copy = dnlp_alg_input->RBASE; |
| menu_chg_en_copy = dnlp_alg_input->menu_chg_en; |
| |
| dnlp_printk_copy = dnlp_dbg_printk->dnlp_printk; |
| } |
| |
| void dnlp_dbg_node_copy(void) |
| { |
| memcpy(dnlp_alg_node_copy, &dnlp_alg_param, |
| sizeof(struct dnlp_alg_param_s)); |
| } |
| |
| void dnlp_alg_param_init(void) |
| { |
| if (dnlp_alg_function == NULL) |
| return; |
| dnlp_alg_param.dnlp_alg_enable = 0; |
| dnlp_alg_param.dnlp_respond = 0; |
| dnlp_alg_param.dnlp_sel = 2; |
| dnlp_alg_param.dnlp_respond_flag = 0; |
| dnlp_alg_param.dnlp_smhist_ck = 0; |
| dnlp_alg_param.dnlp_mvreflsh = 6; |
| dnlp_alg_param.dnlp_pavg_btsft = 5; |
| dnlp_alg_param.dnlp_dbg_i2r = 255; |
| dnlp_alg_param.dnlp_cuvbld_min = 3; |
| dnlp_alg_param.dnlp_cuvbld_max = 17; |
| dnlp_alg_param.dnlp_schg_sft = 1; |
| dnlp_alg_param.dnlp_bbd_ratio_low = 16; |
| dnlp_alg_param.dnlp_bbd_ratio_hig = 128; |
| dnlp_alg_param.dnlp_limit_rng = 1; |
| dnlp_alg_param.dnlp_range_det = 0; |
| dnlp_alg_param.dnlp_blk_cctr = 8; |
| dnlp_alg_param.dnlp_brgt_ctrl = 48; |
| dnlp_alg_param.dnlp_brgt_range = 16; |
| dnlp_alg_param.dnlp_brght_add = 32; |
| dnlp_alg_param.dnlp_brght_max = 0; |
| dnlp_alg_param.dnlp_dbg_adjavg = 0; |
| dnlp_alg_param.dnlp_auto_rng = 0; |
| dnlp_alg_param.dnlp_lowrange = 18; |
| dnlp_alg_param.dnlp_hghrange = 18; |
| dnlp_alg_param.dnlp_satur_rat = 30; |
| dnlp_alg_param.dnlp_satur_max = 40; |
| dnlp_alg_param.dnlp_set_saturtn = 0; |
| dnlp_alg_param.dnlp_sbgnbnd = 4; |
| dnlp_alg_param.dnlp_sendbnd = 4; |
| dnlp_alg_param.dnlp_clashBgn = 4; |
| dnlp_alg_param.dnlp_clashEnd = 59; |
| dnlp_alg_param.dnlp_var_th = 16; |
| dnlp_alg_param.dnlp_clahe_gain_neg = 120; |
| dnlp_alg_param.dnlp_clahe_gain_pos = 24; |
| dnlp_alg_param.dnlp_clahe_gain_delta = 32; |
| dnlp_alg_param.dnlp_mtdbld_rate = 40; |
| dnlp_alg_param.dnlp_adpmtd_lbnd = 19; |
| dnlp_alg_param.dnlp_adpmtd_hbnd = 20; |
| dnlp_alg_param.dnlp_blkext_ofst = 2; |
| dnlp_alg_param.dnlp_whtext_ofst = 1; |
| dnlp_alg_param.dnlp_blkext_rate = 32; |
| dnlp_alg_param.dnlp_whtext_rate = 16; |
| dnlp_alg_param.dnlp_bwext_div4x_min = 16; |
| dnlp_alg_param.dnlp_iRgnBgn = 0; |
| dnlp_alg_param.dnlp_iRgnEnd = 64; |
| dnlp_alg_param.dnlp_dbg_map = 0; |
| dnlp_alg_param.dnlp_final_gain = 8; |
| dnlp_alg_param.dnlp_cliprate_v3 = 36; |
| dnlp_alg_param.dnlp_cliprate_min = 19; |
| dnlp_alg_param.dnlp_adpcrat_lbnd = 10; |
| dnlp_alg_param.dnlp_adpcrat_hbnd = 20; |
| dnlp_alg_param.dnlp_scurv_low_th = 32; |
| dnlp_alg_param.dnlp_scurv_mid1_th = 48; |
| dnlp_alg_param.dnlp_scurv_mid2_th = 112; |
| dnlp_alg_param.dnlp_scurv_hgh1_th = 176; |
| dnlp_alg_param.dnlp_scurv_hgh2_th = 240; |
| dnlp_alg_param.dnlp_mtdrate_adp_en = 1; |
| dnlp_alg_param.dnlp_clahe_method = 1; |
| dnlp_alg_param.dnlp_ble_en = 1; |
| dnlp_alg_param.dnlp_norm = 10; |
| dnlp_alg_param.dnlp_scn_chg_th = 48; |
| dnlp_alg_param.dnlp_step_th = 1; |
| dnlp_alg_param.dnlp_iir_step_mux = 1; |
| dnlp_alg_param.dnlp_single_bin_bw = 2; |
| dnlp_alg_param.dnlp_single_bin_method = 1; |
| dnlp_alg_param.dnlp_reg_max_slop_1st = 614; |
| dnlp_alg_param.dnlp_reg_max_slop_mid = 400; |
| dnlp_alg_param.dnlp_reg_max_slop_fin = 614; |
| dnlp_alg_param.dnlp_reg_min_slop_1st = 77; |
| dnlp_alg_param.dnlp_reg_min_slop_mid = 144; |
| dnlp_alg_param.dnlp_reg_min_slop_fin = 77; |
| dnlp_alg_param.dnlp_reg_trend_wht_expand_mode = 2; |
| dnlp_alg_param.dnlp_reg_trend_blk_expand_mode = 2; |
| dnlp_alg_param.dnlp_ve_hist_cur_gain = 8; |
| dnlp_alg_param.dnlp_ve_hist_cur_gain_precise = 8; |
| dnlp_alg_param.dnlp_reg_mono_binrang_st = 7; |
| dnlp_alg_param.dnlp_reg_mono_binrang_ed = 26; |
| |
| if (dnlp_alg_function != NULL) { |
| dnlp_alg_function->dnlp_para_set(&dnlp_alg_output, |
| &dnlp_alg_input, &dnlp_dbg_rw_param, &dnlp_dbg_ro_param, |
| &dnlp_alg_node_copy, &dnlp_dbg_printk); |
| |
| dnlp_alg_param_copy(); |
| dnlp_dbg_node_copy(); |
| |
| dnlp_insmod_ok = 1; |
| pr_info("%s: is ok\n", __func__); |
| } else |
| pr_info("%s: dnlp_alg_function is NULL\n", |
| __func__); |
| } |
| |
| static void ve_dnlp_add_cm(unsigned int value) |
| { |
| unsigned int reg_value; |
| |
| VSYNC_WR_MPEG_REG(VPP_CHROMA_ADDR_PORT, 0x207); |
| reg_value = VSYNC_RD_MPEG_REG(VPP_CHROMA_DATA_PORT); |
| reg_value = (reg_value & 0xf000ffff) | (value << 16); |
| VSYNC_WR_MPEG_REG(VPP_CHROMA_ADDR_PORT, 0x207); |
| VSYNC_WR_MPEG_REG(VPP_CHROMA_DATA_PORT, reg_value); |
| } |
| |
| /*in: vf (hist), h_sel |
| *out: hstSum,pre_0_gamma, *osamebin_num |
| *return: hstSum |
| */ |
| static int load_histogram(int *osamebin_num, struct vframe_s *vf, |
| int h_sel, unsigned int nTstCnt) |
| { |
| struct vframe_prop_s *p = &vf->prop; |
| int nT0; /* counter number of bins same to last frame */ |
| int hstSum, nT1, i, j; /* sum of pixels in histogram */ |
| |
| nT0 = 0; hstSum = 0; |
| for (i = 0; i < 64; i++) { |
| /* histogram stored for one frame delay */ |
| pre_1_gamma_copy[i] = pre_0_gamma_copy[i]; |
| if (h_sel) |
| pre_0_gamma_copy[i] = |
| (unsigned int)p->hist.vpp_gamma[i]; |
| else |
| pre_0_gamma_copy[i] = (unsigned int)p->hist.gamma[i]; |
| |
| /* counter the same histogram */ |
| if (pre_1_gamma_copy[i] == pre_0_gamma_copy[i]) |
| nT0++; |
| else if (pre_1_gamma_copy[i] > pre_0_gamma_copy[i]) |
| nT1 = (pre_1_gamma_copy[i] - pre_0_gamma_copy[i]); |
| else |
| nT1 = (pre_0_gamma_copy[i] - pre_1_gamma_copy[i]); |
| |
| hstSum += pre_0_gamma_copy[i]; |
| } |
| |
| if (dnlp_dbg_print & 0x1) |
| pr_info("\nRflsh%03d: %02d same bins hstSum(%d)\n", |
| nTstCnt, nT0, hstSum); |
| |
| /* output, same hist bin nums of this frame */ |
| *osamebin_num = nT0; |
| |
| if (dnlp_dbg_print & 0x1) { |
| pr_info("\n ==nTstCnt= %d====\n\n", nTstCnt); |
| pr_info("\n#### load_histogram()-1: [\n"); |
| for (j = 0; j < 4; j++) { |
| i = j*16; |
| pr_info("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,\n", |
| pre_0_gamma_copy[i], |
| pre_0_gamma_copy[i+1], |
| pre_0_gamma_copy[i+2], |
| pre_0_gamma_copy[i+3], |
| pre_0_gamma_copy[i+4], |
| pre_0_gamma_copy[i+5], |
| pre_0_gamma_copy[i+6], |
| pre_0_gamma_copy[i+7], |
| pre_0_gamma_copy[i+8], |
| pre_0_gamma_copy[i+9], |
| pre_0_gamma_copy[i+10], |
| pre_0_gamma_copy[i+11], |
| pre_0_gamma_copy[i+12], |
| pre_0_gamma_copy[i+13], |
| pre_0_gamma_copy[i+14], |
| pre_0_gamma_copy[i+15]); |
| } |
| pr_info(" ]\n"); |
| pr_info("### ===== hstSum = %d ======\n", hstSum); |
| pr_info("### ve_dnlp_luma_sum(raw) = %d\n", |
| *ve_dnlp_luma_sum_copy); |
| } |
| |
| return hstSum; |
| } |
| |
| /* dnlp saturation compensations */ |
| /* input: ve_dnlp_tgt[]; */ |
| /* output: ve_dnlp_add_cm(nTmp + 512), and delta saturation; */ |
| int dnlp_sat_compensation(void) |
| { |
| int nT0, nT1, nTmp0, nTmp, i; |
| unsigned int pre_stur = 0; |
| |
| nT0 = 0; nT1 = 0; |
| for (i = 1; i < 64; i++) { |
| if (ve_dnlp_tgt_copy[i] > 4*i) { |
| nT0 += (ve_dnlp_tgt_copy[i] - 4*i) * (65 - i); |
| nT1 += (65 - i); |
| } |
| } |
| nTmp0 = nT0 * dnlp_alg_param.dnlp_satur_rat + (nT1 >> 1); |
| nTmp0 = nTmp0 / (nT1 + 1); |
| nTmp0 = ((nTmp0 + 4) >> 3); |
| |
| nTmp = (dnlp_alg_param.dnlp_satur_max << 3); |
| if (nTmp0 < nTmp) |
| nTmp = nTmp0; |
| |
| if (((dnlp_dbg_print)&0x2)) |
| pr_info("#sat_comp: pre(%3d) => %5d / %3d => %3d cur(%3d)\n", |
| pre_stur, nT0, nT1, nTmp0, nTmp); |
| |
| if (dnlp_alg_param.dnlp_set_saturtn == 0) { |
| if (nTmp != pre_stur) { |
| ve_dnlp_add_cm(nTmp + 512); |
| pre_stur = nTmp; |
| } |
| } else { |
| if (pre_stur != dnlp_alg_param.dnlp_set_saturtn) { |
| if (dnlp_alg_param.dnlp_set_saturtn < 512) |
| ve_dnlp_add_cm(dnlp_alg_param.dnlp_set_saturtn + |
| 512); |
| else |
| ve_dnlp_add_cm(dnlp_alg_param.dnlp_set_saturtn); |
| pre_stur = dnlp_alg_param.dnlp_set_saturtn; |
| } |
| } |
| |
| return nTmp; |
| } |
| |
| int ve_dnlp_calculate_tgtx(struct vframe_s *vf) |
| { |
| struct vframe_prop_s *p = &vf->prop; |
| |
| /*---- some intermediate variables ----*/ |
| unsigned int raw_hst_sum; |
| int smbin_num; |
| |
| if ((dnlp_alg_function == NULL) || |
| (dnlp_insmod_ok == 0)) |
| return 0; |
| |
| /* calc iir-coef params */ |
| if (dnlp_alg_param.dnlp_mvreflsh < 1) |
| dnlp_alg_param.dnlp_mvreflsh = 1; |
| *RBASE_copy = (1 << dnlp_alg_param.dnlp_mvreflsh); |
| |
| /* parameters refresh */ |
| dnlp_alg_function->dnlp3_param_refrsh(); |
| |
| if (hist_sel) |
| *ve_dnlp_luma_sum_copy = p->hist.vpp_luma_sum; |
| else |
| *ve_dnlp_luma_sum_copy = p->hist.luma_sum; |
| |
| /* counter the calling function */ |
| (*nTstCnt_copy)++; |
| if (*nTstCnt_copy > 16384) |
| *nTstCnt_copy = 0; |
| |
| /*--------------------------------------------------------*/ |
| |
| /*STEP A: load histogram and |
| *do histogram pre-processing and detections |
| */ |
| /*step 0.00 load the histogram*/ |
| raw_hst_sum = load_histogram(&smbin_num, vf, hist_sel, *nTstCnt_copy); |
| |
| /*step 0.01 all the same histogram as last frame, freeze DNLP */ |
| if (smbin_num == 64 && |
| dnlp_alg_param.dnlp_smhist_ck && |
| (!dnlp_alg_param.dnlp_respond_flag)) { |
| if (dnlp_dbg_print & 0x2) |
| pr_info("WARNING: invalid hist @ step 0.10\n"); |
| return 1; |
| } |
| |
| dnlp_alg_function->dnlp_algorithm_main(raw_hst_sum); |
| dnlp_sat_compensation(); |
| |
| return 1; |
| } |
| |
| /* lpf[0] is always 0 & no need calculation */ |
| void ve_dnlp_calculate_lpf(void) |
| { |
| ulong i = 0; |
| for (i = 0; i < 64; i++) |
| ve_dnlp_lpf[i] = ve_dnlp_lpf[i] - |
| (ve_dnlp_lpf[i] >> ve_dnlp_rt) + ve_dnlp_tgt_copy[i]; |
| } |
| |
| void ve_dnlp_calculate_reg(void) |
| { |
| ulong i = 0, j = 0, cur = 0, data = 0, |
| offset = ve_dnlp_rt ? (1 << (ve_dnlp_rt - 1)) : 0; |
| if (is_meson_tl1_cpu()) { |
| for (i = 0; i < 32; i++) { |
| ve_dnlp_reg_v2[i] = 0; |
| cur = i << 1; |
| for (j = 0; j < 2; j++) { |
| data = ve_dnlp_lpf[cur + j] << 2; |
| if (data > 1023) |
| data = 1023; |
| ve_dnlp_reg_v2[i] |= data << (j << 4); |
| } |
| } |
| } else { |
| for (i = 0; i < 16; i++) { |
| ve_dnlp_reg[i] = 0; |
| cur = i << 2; |
| for (j = 0; j < 4; j++) { |
| data = (ve_dnlp_lpf[cur + j] + offset) >> |
| ve_dnlp_rt; |
| if (data > 255) |
| data = 255; |
| ve_dnlp_reg[i] |= data << (j << 3); |
| } |
| } |
| } |
| } |
| |
| void ve_set_v3_dnlp(struct ve_dnlp_curve_param_s *p) |
| { |
| ulong i = 0; |
| /* get command parameters */ |
| /* general settings */ |
| if (dnlp_insmod_ok == 0) |
| return; |
| /*load static curve*/ |
| memcpy(dnlp_scurv_low_copy, p->ve_dnlp_scurv_low, |
| sizeof(int) * DNLP_SCURV_LEN); |
| memcpy(dnlp_scurv_mid1_copy, p->ve_dnlp_scurv_mid1, |
| sizeof(int) * DNLP_SCURV_LEN); |
| memcpy(dnlp_scurv_mid2_copy, p->ve_dnlp_scurv_mid2, |
| sizeof(int) * DNLP_SCURV_LEN); |
| memcpy(dnlp_scurv_hgh1_copy, p->ve_dnlp_scurv_hgh1, |
| sizeof(int) * DNLP_SCURV_LEN); |
| memcpy(dnlp_scurv_hgh2_copy, p->ve_dnlp_scurv_hgh2, |
| sizeof(int) * DNLP_SCURV_LEN); |
| /*load gain var*/ |
| memcpy(gain_var_lut49_copy, p->ve_gain_var_lut49, |
| sizeof(int) * GAIN_VAR_LUT_LEN); |
| /*load wext gain*/ |
| memcpy(wext_gain_copy, p->ve_wext_gain, |
| sizeof(int) * WEXT_GAIN_LEN); |
| /*load new c curve lut for vlsi-kite.li*/ |
| memcpy(adp_thrd_copy, p->ve_adp_thrd, |
| sizeof(int) * ADP_THRD_LEN); |
| memcpy(reg_blk_boost_12_copy, p->ve_reg_blk_boost_12, |
| sizeof(int) * REG_BLK_BOOST_LEN); |
| memcpy(reg_adp_ofset_20_copy, p->ve_reg_adp_ofset_20, |
| sizeof(int) * REG_ADP_OFSET_LEN); |
| memcpy(reg_mono_protect_copy, p->ve_reg_mono_protect, |
| sizeof(int) * REG_MONO_PROT_LEN); |
| memcpy(reg_trend_wht_expand_lut8_copy, p->ve_reg_trend_wht_expand_lut8, |
| sizeof(int) * TREND_WHT_EXP_LUT_LEN); |
| |
| if ((ve_en != p->param[ve_dnlp_enable]) || |
| (dnlp_sel != p->param[ve_dnlp_sel]) || |
| (dnlp_alg_param.dnlp_lowrange != |
| p->param[ve_dnlp_lowrange]) || |
| (dnlp_alg_param.dnlp_hghrange != |
| p->param[ve_dnlp_hghrange]) || |
| (dnlp_alg_param.dnlp_auto_rng != |
| p->param[ve_dnlp_auto_rng]) || |
| (dnlp_alg_param.dnlp_bbd_ratio_low != |
| p->param[ve_dnlp_bbd_ratio_low]) || |
| (dnlp_alg_param.dnlp_bbd_ratio_hig != |
| p->param[ve_dnlp_bbd_ratio_hig]) || |
| (dnlp_alg_param.dnlp_mvreflsh != |
| p->param[ve_dnlp_mvreflsh]) || |
| (dnlp_alg_param.dnlp_smhist_ck != |
| p->param[ve_dnlp_smhist_ck]) || |
| (dnlp_alg_param.dnlp_final_gain != |
| p->param[ve_dnlp_final_gain]) || |
| (dnlp_alg_param.dnlp_clahe_gain_neg != |
| p->param[ve_dnlp_clahe_gain_neg]) || |
| (dnlp_alg_param.dnlp_clahe_gain_pos != |
| p->param[ve_dnlp_clahe_gain_pos]) || |
| (dnlp_alg_param.dnlp_mtdbld_rate != |
| p->param[ve_dnlp_mtdbld_rate]) || |
| (dnlp_alg_param.dnlp_adpmtd_lbnd != |
| p->param[ve_dnlp_adpmtd_lbnd]) || |
| (dnlp_alg_param.dnlp_adpmtd_hbnd != |
| p->param[ve_dnlp_adpmtd_hbnd]) || |
| (dnlp_alg_param.dnlp_sbgnbnd != |
| p->param[ve_dnlp_sbgnbnd]) || |
| (dnlp_alg_param.dnlp_sendbnd != |
| p->param[ve_dnlp_sendbnd]) || |
| (dnlp_alg_param.dnlp_cliprate_v3 != |
| p->param[ve_dnlp_cliprate_v3]) || |
| (dnlp_alg_param.dnlp_cliprate_min != |
| p->param[ve_dnlp_cliprate_min]) || |
| (dnlp_alg_param.dnlp_adpcrat_lbnd != |
| p->param[ve_dnlp_adpcrat_lbnd]) || |
| (dnlp_alg_param.dnlp_adpcrat_hbnd != |
| p->param[ve_dnlp_adpcrat_hbnd]) || |
| (dnlp_alg_param.dnlp_clashBgn != |
| p->param[ve_dnlp_clashBgn]) || |
| (dnlp_alg_param.dnlp_clashEnd != |
| p->param[ve_dnlp_clashEnd]) || |
| (dnlp_alg_param.dnlp_blkext_rate != |
| p->param[ve_dnlp_blkext_rate]) || |
| (dnlp_alg_param.dnlp_whtext_rate != |
| p->param[ve_dnlp_whtext_rate]) || |
| (dnlp_alg_param.dnlp_blkext_ofst != |
| p->param[ve_dnlp_blkext_ofst]) || |
| (dnlp_alg_param.dnlp_whtext_ofst != |
| p->param[ve_dnlp_whtext_ofst]) || |
| (dnlp_alg_param.dnlp_bwext_div4x_min != |
| p->param[ve_dnlp_bwext_div4x_min]) || |
| (dnlp_alg_param.dnlp_blk_cctr != |
| p->param[ve_dnlp_blk_cctr]) || |
| (dnlp_alg_param.dnlp_brgt_ctrl != |
| p->param[ve_dnlp_brgt_ctrl]) || |
| (dnlp_alg_param.dnlp_brgt_range != |
| p->param[ve_dnlp_brgt_range]) || |
| (dnlp_alg_param.dnlp_brght_add != |
| p->param[ve_dnlp_brght_add]) || |
| (dnlp_alg_param.dnlp_brght_max != |
| p->param[ve_dnlp_brght_max]) || |
| (dnlp_alg_param.dnlp_satur_rat != |
| p->param[ve_dnlp_satur_rat]) || |
| (dnlp_alg_param.dnlp_satur_max != |
| p->param[ve_dnlp_satur_max]) || |
| (dnlp_alg_param.dnlp_scurv_low_th != |
| p->param[ve_dnlp_scurv_low_th]) || |
| (dnlp_alg_param.dnlp_scurv_mid1_th != |
| p->param[ve_dnlp_scurv_mid1_th]) || |
| (dnlp_alg_param.dnlp_scurv_mid2_th != |
| p->param[ve_dnlp_scurv_mid2_th]) || |
| (dnlp_alg_param.dnlp_scurv_hgh1_th != |
| p->param[ve_dnlp_scurv_hgh1_th]) || |
| (dnlp_alg_param.dnlp_scurv_hgh2_th != |
| p->param[ve_dnlp_scurv_hgh2_th]) || |
| (dnlp_alg_param.dnlp_mtdrate_adp_en != |
| p->param[ve_dnlp_mtdrate_adp_en]) || |
| (dnlp_alg_param.dnlp_clahe_method != |
| p->param[ve_dnlp_clahe_method]) || |
| (dnlp_alg_param.dnlp_ble_en != |
| p->param[ve_dnlp_ble_en]) || |
| (dnlp_alg_param.dnlp_norm != |
| p->param[ve_dnlp_norm]) || |
| (dnlp_alg_param.dnlp_scn_chg_th != |
| p->param[ve_dnlp_scn_chg_th]) || |
| (dnlp_alg_param.dnlp_iir_step_mux != |
| p->param[ve_dnlp_iir_step_mux]) || |
| (dnlp_alg_param.dnlp_single_bin_bw != |
| p->param[ve_dnlp_single_bin_bw]) || |
| (dnlp_alg_param.dnlp_single_bin_method != |
| p->param[ve_dnlp_single_bin_method]) || |
| (dnlp_alg_param.dnlp_reg_max_slop_1st != |
| p->param[ve_dnlp_reg_max_slop_1st]) || |
| (dnlp_alg_param.dnlp_reg_max_slop_mid != |
| p->param[ve_dnlp_reg_max_slop_mid]) || |
| (dnlp_alg_param.dnlp_reg_max_slop_fin != |
| p->param[ve_dnlp_reg_max_slop_fin]) || |
| (dnlp_alg_param.dnlp_reg_min_slop_1st != |
| p->param[ve_dnlp_reg_min_slop_1st]) || |
| (dnlp_alg_param.dnlp_reg_min_slop_mid != |
| p->param[ve_dnlp_reg_min_slop_mid]) || |
| (dnlp_alg_param.dnlp_reg_min_slop_fin != |
| p->param[ve_dnlp_reg_min_slop_fin]) || |
| (dnlp_alg_param.dnlp_reg_trend_wht_expand_mode != |
| p->param[ve_dnlp_reg_trend_wht_expand_mode]) || |
| (dnlp_alg_param.dnlp_reg_trend_blk_expand_mode != |
| p->param[ve_dnlp_reg_trend_blk_expand_mode]) || |
| (dnlp_alg_param.dnlp_ve_hist_cur_gain != |
| p->param[ve_dnlp_ve_hist_cur_gain]) || |
| (dnlp_alg_param.dnlp_ve_hist_cur_gain_precise != |
| p->param[ve_dnlp_ve_hist_cur_gain_precise]) || |
| (dnlp_alg_param.dnlp_reg_mono_binrang_st != |
| p->param[ve_dnlp_reg_mono_binrang_st]) || |
| (dnlp_alg_param.dnlp_reg_mono_binrang_ed != |
| p->param[ve_dnlp_reg_mono_binrang_ed])) { |
| if (dnlp_insmod_ok) |
| *menu_chg_en_copy = 1; |
| } else |
| return; |
| |
| ve_en = p->param[ve_dnlp_enable]; |
| dnlp_sel = p->param[ve_dnlp_sel]; |
| |
| /* hist auto range parms */ |
| dnlp_alg_param.dnlp_lowrange = p->param[ve_dnlp_lowrange]; |
| dnlp_alg_param.dnlp_hghrange = p->param[ve_dnlp_hghrange]; |
| dnlp_alg_param.dnlp_auto_rng = p->param[ve_dnlp_auto_rng]; |
| |
| /* histogram refine parms (remove bb affects) */ |
| dnlp_alg_param.dnlp_bbd_ratio_low = p->param[ve_dnlp_bbd_ratio_low]; |
| dnlp_alg_param.dnlp_bbd_ratio_hig = p->param[ve_dnlp_bbd_ratio_hig]; |
| |
| /* calc iir-coef params */ |
| dnlp_alg_param.dnlp_mvreflsh = p->param[ve_dnlp_mvreflsh]; |
| dnlp_alg_param.dnlp_smhist_ck = p->param[ve_dnlp_smhist_ck]; |
| |
| /* gains to delta of curves (for strength of the DNLP) */ |
| dnlp_alg_param.dnlp_final_gain = p->param[ve_dnlp_final_gain]; |
| dnlp_alg_param.dnlp_clahe_gain_neg = p->param[ve_dnlp_clahe_gain_neg]; |
| dnlp_alg_param.dnlp_clahe_gain_pos = p->param[ve_dnlp_clahe_gain_pos]; |
| |
| /* coef of blending between gma_scurv and clahe curves */ |
| dnlp_alg_param.dnlp_mtdbld_rate = p->param[ve_dnlp_mtdbld_rate]; |
| dnlp_alg_param.dnlp_adpmtd_lbnd = p->param[ve_dnlp_adpmtd_lbnd]; |
| dnlp_alg_param.dnlp_adpmtd_hbnd = p->param[ve_dnlp_adpmtd_hbnd]; |
| |
| /* for gma_scurvs processing range */ |
| dnlp_alg_param.dnlp_sbgnbnd = p->param[ve_dnlp_sbgnbnd]; |
| dnlp_alg_param.dnlp_sendbnd = p->param[ve_dnlp_sendbnd]; |
| |
| /* curve- clahe */ |
| dnlp_alg_param.dnlp_cliprate_v3 = p->param[ve_dnlp_cliprate_v3]; |
| dnlp_alg_param.dnlp_cliprate_min = p->param[ve_dnlp_cliprate_min]; |
| dnlp_alg_param.dnlp_adpcrat_lbnd = p->param[ve_dnlp_adpcrat_lbnd]; |
| dnlp_alg_param.dnlp_adpcrat_hbnd = p->param[ve_dnlp_adpcrat_hbnd]; |
| |
| /* for clahe_curvs processing range */ |
| dnlp_alg_param.dnlp_clashBgn = p->param[ve_dnlp_clashBgn]; |
| dnlp_alg_param.dnlp_clashEnd = p->param[ve_dnlp_clashEnd]; |
| |
| /* black white extension control params */ |
| dnlp_alg_param.dnlp_blkext_rate = p->param[ve_dnlp_blkext_rate]; |
| dnlp_alg_param.dnlp_whtext_rate = p->param[ve_dnlp_whtext_rate]; |
| dnlp_alg_param.dnlp_blkext_ofst = p->param[ve_dnlp_blkext_ofst]; |
| dnlp_alg_param.dnlp_whtext_ofst = p->param[ve_dnlp_whtext_ofst]; |
| dnlp_alg_param.dnlp_bwext_div4x_min = p->param[ve_dnlp_bwext_div4x_min]; |
| |
| /* brightness_plus */ |
| dnlp_alg_param.dnlp_blk_cctr = p->param[ve_dnlp_blk_cctr]; |
| dnlp_alg_param.dnlp_brgt_ctrl = p->param[ve_dnlp_brgt_ctrl]; |
| dnlp_alg_param.dnlp_brgt_range = p->param[ve_dnlp_brgt_range]; |
| dnlp_alg_param.dnlp_brght_add = p->param[ve_dnlp_brght_add]; |
| dnlp_alg_param.dnlp_brght_max = p->param[ve_dnlp_brght_max]; |
| |
| /* adaptive saturation compensations */ |
| dnlp_alg_param.dnlp_satur_rat = p->param[ve_dnlp_satur_rat]; |
| dnlp_alg_param.dnlp_satur_max = p->param[ve_dnlp_satur_max]; |
| dnlp_alg_param.dnlp_scurv_low_th = p->param[ve_dnlp_scurv_low_th]; |
| dnlp_alg_param.dnlp_scurv_mid1_th = p->param[ve_dnlp_scurv_mid1_th]; |
| dnlp_alg_param.dnlp_scurv_mid2_th = p->param[ve_dnlp_scurv_mid2_th]; |
| dnlp_alg_param.dnlp_scurv_hgh1_th = p->param[ve_dnlp_scurv_hgh1_th]; |
| dnlp_alg_param.dnlp_scurv_hgh2_th = p->param[ve_dnlp_scurv_hgh2_th]; |
| dnlp_alg_param.dnlp_mtdrate_adp_en = |
| p->param[ve_dnlp_mtdrate_adp_en]; |
| /* TODO: ve_dnlp_set_saturtn = p->dnlp_set_saturtn; */ |
| /*new c curve param add for vlsi-kiteli*/ |
| dnlp_alg_param.dnlp_mtdrate_adp_en = |
| p->param[ve_dnlp_mtdrate_adp_en]; |
| |
| dnlp_alg_param.dnlp_clahe_method = |
| p->param[ve_dnlp_clahe_method]; |
| dnlp_alg_param.dnlp_ble_en = |
| p->param[ve_dnlp_ble_en]; |
| dnlp_alg_param.dnlp_norm = |
| p->param[ve_dnlp_norm]; |
| dnlp_alg_param.dnlp_scn_chg_th = |
| p->param[ve_dnlp_scn_chg_th]; |
| dnlp_alg_param.dnlp_iir_step_mux = |
| p->param[ve_dnlp_iir_step_mux]; |
| dnlp_alg_param.dnlp_single_bin_bw = |
| p->param[ve_dnlp_single_bin_bw]; |
| dnlp_alg_param.dnlp_single_bin_method = |
| p->param[ve_dnlp_single_bin_method]; |
| dnlp_alg_param.dnlp_reg_max_slop_1st = |
| p->param[ve_dnlp_reg_max_slop_1st]; |
| dnlp_alg_param.dnlp_reg_max_slop_mid = |
| p->param[ve_dnlp_reg_max_slop_mid]; |
| dnlp_alg_param.dnlp_reg_max_slop_fin = |
| p->param[ve_dnlp_reg_max_slop_fin]; |
| dnlp_alg_param.dnlp_reg_min_slop_1st = |
| p->param[ve_dnlp_reg_min_slop_1st]; |
| dnlp_alg_param.dnlp_reg_min_slop_mid = |
| p->param[ve_dnlp_reg_min_slop_mid]; |
| dnlp_alg_param.dnlp_reg_min_slop_fin = |
| p->param[ve_dnlp_reg_min_slop_fin]; |
| dnlp_alg_param.dnlp_reg_trend_wht_expand_mode = |
| p->param[ve_dnlp_reg_trend_wht_expand_mode]; |
| dnlp_alg_param.dnlp_reg_trend_blk_expand_mode = |
| p->param[ve_dnlp_reg_trend_blk_expand_mode]; |
| dnlp_alg_param.dnlp_ve_hist_cur_gain = |
| p->param[ve_dnlp_ve_hist_cur_gain]; |
| dnlp_alg_param.dnlp_ve_hist_cur_gain_precise = |
| p->param[ve_dnlp_ve_hist_cur_gain_precise]; |
| dnlp_alg_param.dnlp_reg_mono_binrang_st = |
| p->param[ve_dnlp_reg_mono_binrang_st]; |
| dnlp_alg_param.dnlp_reg_mono_binrang_ed = |
| p->param[ve_dnlp_reg_mono_binrang_ed]; |
| |
| if (dnlp_insmod_ok == 0) |
| return; |
| |
| dnlp_dbg_node_copy(); |
| |
| if (ve_en) { |
| /* clear historic luma sum */ |
| *ve_dnlp_luma_sum_copy = 0; |
| /* init tgt & lpf */ |
| for (i = 0; i < 64; i++) { |
| ve_dnlp_tgt_copy[i] = i << 2; |
| ve_dnlp_lpf[i] = (ulong)(ve_dnlp_tgt_copy[i] |
| << ve_dnlp_rt); |
| } |
| /* calculate dnlp reg data */ |
| ve_dnlp_calculate_reg(); |
| /* load dnlp reg data */ |
| ve_dnlp_load_reg(); |
| /* enable dnlp */ |
| ve_enable_dnlp(); |
| } else { |
| /* disable dnlp */ |
| ve_disable_dnlp(); |
| } |
| |
| } |
| |