shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-08 03:40:35 +09:00
Code Issues Packages Projects Releases Wiki Activity

backlight: add support for tl1 [1/1]

Browse Source 
PD#172587

Problem:
do not suppoert for tl1

Solution:
add backlight support for fl1

Verify:
verified on PTM

Change-Id: I052a7ef93ec9cb21a544e4823a4c9a339d38b5f9
Signed-off-by: Evoke Zhang <evoke.zhang@amlogic.com>
This commit is contained in:
Evoke Zhang
2018-10-25 15:21:19 +08:00
committed by Dongjin Kim
parent 305c7bab71
commit 2c323f9dfc
5 changed files with 136 additions and 686 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
drivers/amlogic/media/vout/backlight/aml_bl.c
View File

@@ -3183,12 +3183,6 @@ static int aml_bl_resume(struct platform_device *pdev)
#endif
#ifdef CONFIG_OF
static struct bl_data_s bl_data_gxtvbb = {
.chip_type = BL_CHIP_GXTVBB,
.chip_name = "gxtvbb",
.pwm_reg = pwm_reg_txl,
};
static struct bl_data_s bl_data_gxl = {
.chip_type = BL_CHIP_GXL,
.chip_name = "gxl",
@@ -3231,11 +3225,13 @@ static struct bl_data_s bl_data_g12b = {
.pwm_reg = pwm_reg_txlx,
};
static struct bl_data_s bl_data_tl1 = {
.chip_type = BL_CHIP_TL1,
.chip_name = "tl1",
.pwm_reg = pwm_reg_txlx,
};
static const struct of_device_id bl_dt_match_table[] = {
{
.compatible = "amlogic, backlight-gxtvbb",
.data = &bl_data_gxtvbb,
},
{
.compatible = "amlogic, backlight-gxl",
.data = &bl_data_gxl,
@@ -3264,6 +3260,10 @@ static const struct of_device_id bl_dt_match_table[] = {
.compatible = "amlogic, backlight-g12b",
.data = &bl_data_g12b,
},
{
.compatible = "amlogic, backlight-tl1",
.data = &bl_data_tl1,
},
{},
};
#endif

430
drivers/amlogic/media/vout/backlight/aml_ldim/ldim_drv.c
View File

@@ -59,6 +59,9 @@ const char ldim_dev_id[] = "ldim-dev";
unsigned char ldim_debug_print;
struct ldim_dev_s {
struct aml_ldim_func_s *ldim_func;
struct ldim_param_s *ldim_db_para;
struct cdev cdev;
struct device *dev;
dev_t aml_ldim_devno;
@@ -66,7 +69,6 @@ struct ldim_dev_s {
struct cdev *aml_ldim_cdevp;
};
static struct ldim_dev_s ldim_dev;
static struct ldim_param_s *ldim_db_para;
static struct LDReg_s nPRM;
static struct FW_DAT_s FDat;
static struct ldim_fw_para_s ldim_fw_para;
@@ -96,7 +98,6 @@ static struct work_struct ldim_on_vs_work;
static struct work_struct ldim_off_vs_work;
static unsigned int ldim_irq_cnt;
static unsigned int rdma_ldim_irq_cnt;
/*BL_matrix remap curve*/
static unsigned int bl_remap_curve[16] = {
@@ -128,9 +129,6 @@ static unsigned int ldim_top_en;
module_param(ldim_top_en, uint, 0664);
MODULE_PARM_DESC(ldim_top_en, "ldim_top_en");
static void ldim_on_vs_brightness(void);
static void ldim_off_vs_brightness(void);
static void ldim_on_vs_arithmetic(void);
static void ldim_dump_histgram(void);
static void ldim_get_matrix_info_max_rgb(void);
@@ -144,18 +142,6 @@ static struct ldim_config_s ldim_config = {
.hvcnt_bypass = 0,
};
static void ldim_on_update_brightness(struct work_struct *work)
{
ldim_stts_read_region(ldim_hist_row, ldim_hist_col);
ldim_on_vs_arithmetic();
ldim_on_vs_brightness();
}
static void ldim_off_update_brightness(struct work_struct *work)
{
ldim_off_vs_brightness();
}
static void ldim_db_para_print(struct LDReg_s *mLDReg)
{
int i, len;
@@ -276,58 +262,64 @@ static void ldim_db_para_print(struct LDReg_s *mLDReg)
}
static void ldim_db_load_update(struct LDReg_s *mLDReg,
struct ldim_param_s *db_pare)
struct ldim_param_s *db_para)
{
int i;
if (db_pare == NULL)
if (db_para == NULL)
return;
LDIMPR("ldim_db_load_update\n");
/* beam model */
ldim_fw_para.rgb_base = db_pare->rgb_base;
ldim_fw_para.boost_gain = db_pare->boost_gain;
ldim_fw_para.lpf_res = db_pare->lpf_res;
ldim_fw_para.fw_LD_ThSF_l = db_pare->fw_ld_th_sf;
ldim_fw_para.rgb_base = db_para->rgb_base;
ldim_fw_para.boost_gain = db_para->boost_gain;
ldim_fw_para.lpf_res = db_para->lpf_res;
ldim_fw_para.fw_LD_ThSF_l = db_para->fw_ld_th_sf;
/* beam curve */
mLDReg->reg_LD_Vgain = db_pare->ld_vgain;
mLDReg->reg_LD_Hgain = db_pare->ld_hgain;
mLDReg->reg_LD_Litgain = db_pare->ld_litgain;
mLDReg->reg_LD_Vgain = db_para->ld_vgain;
mLDReg->reg_LD_Hgain = db_para->ld_hgain;
mLDReg->reg_LD_Litgain = db_para->ld_litgain;
mLDReg->reg_LD_LUT_Vdg_LEXT = db_pare->ld_lut_vdg_lext;
mLDReg->reg_LD_LUT_Hdg_LEXT = db_pare->ld_lut_hdg_lext;
mLDReg->reg_LD_LUT_VHk_LEXT = db_pare->ld_lut_vhk_lext;
mLDReg->reg_LD_LUT_Vdg_LEXT = db_para->ld_lut_vdg_lext;
mLDReg->reg_LD_LUT_Hdg_LEXT = db_para->ld_lut_hdg_lext;
mLDReg->reg_LD_LUT_VHk_LEXT = db_para->ld_lut_vhk_lext;
for (i = 0; i < 32; i++) {
mLDReg->reg_LD_LUT_Hdg[i] = db_pare->ld_lut_hdg[i];
mLDReg->reg_LD_LUT_Vdg[i] = db_pare->ld_lut_vdg[i];
mLDReg->reg_LD_LUT_VHk[i] = db_pare->ld_lut_vhk[i];
mLDReg->reg_LD_LUT_Hdg[i] = db_para->ld_lut_hdg[i];
mLDReg->reg_LD_LUT_Vdg[i] = db_para->ld_lut_vdg[i];
mLDReg->reg_LD_LUT_VHk[i] = db_para->ld_lut_vhk[i];
}
/* beam shape minor adjustment */
for (i = 0; i < 32; i++) {
mLDReg->reg_LD_LUT_VHk_pos[i] = db_pare->ld_lut_vhk_pos[i];
mLDReg->reg_LD_LUT_VHk_neg[i] = db_pare->ld_lut_vhk_neg[i];
mLDReg->reg_LD_LUT_HHk[i] = db_pare->ld_lut_hhk[i];
mLDReg->reg_LD_LUT_VHo_pos[i] = db_pare->ld_lut_vho_pos[i];
mLDReg->reg_LD_LUT_VHo_neg[i] = db_pare->ld_lut_vho_neg[i];
mLDReg->reg_LD_LUT_VHk_pos[i] = db_para->ld_lut_vhk_pos[i];
mLDReg->reg_LD_LUT_VHk_neg[i] = db_para->ld_lut_vhk_neg[i];
mLDReg->reg_LD_LUT_HHk[i] = db_para->ld_lut_hhk[i];
mLDReg->reg_LD_LUT_VHo_pos[i] = db_para->ld_lut_vho_pos[i];
mLDReg->reg_LD_LUT_VHo_neg[i] = db_para->ld_lut_vho_neg[i];
}
/* remapping */
/*db_pare->lit_idx_th;*/
/*db_pare->comp_gain;*/
/*db_para->lit_idx_th;*/
/*db_para->comp_gain;*/
if (db_print_flag == 1)
ldim_db_para_print(mLDReg);
}
static void ldim_stts_initial_txlx(unsigned int resolution)
{
Wr_reg(LDIM_STTS_CTRL0, 7 << 2);
ldim_set_matrix_ycbcr2rgb();
ldim_stts_en(resolution, 0, 0, 1, 1, 1, 0);
}
static void ldim_stts_initial(unsigned int pic_h, unsigned int pic_v,
unsigned int BLK_Vnum, unsigned int BLK_Hnum)
{
unsigned int resolution, resolution_region, blk_height, blk_width;
unsigned int row_start, col_start;
struct aml_bl_drv_s *bl_drv = aml_bl_get_driver();
BLK_Vnum = (BLK_Vnum == 0) ? 1 : BLK_Vnum;
BLK_Hnum = (BLK_Hnum == 0) ? 1 : BLK_Hnum;
@@ -339,21 +331,12 @@ static void ldim_stts_initial(unsigned int pic_h, unsigned int pic_v,
resolution = (((pic_h - 1) & 0xffff) << 16) | ((pic_v - 1) & 0xffff);
/*Wr_reg(VDIN0_HIST_CTRL, 0x10d);*/
switch (bl_drv->data->chip_type) {
case BL_CHIP_TXLX:
Wr_reg(LDIM_STTS_CTRL0, 7 << 2);
ldim_set_matrix_ycbcr2rgb();
ldim_stts_en(resolution, 0, 0, 1, 1, 1, 0);
break;
case BL_CHIP_GXTVBB:
Wr_reg(LDIM_STTS_CTRL0, 3 << 3);/*4 mux to vpp_dout*/
ldim_set_matrix_ycbcr2rgb();
/*ldim_set_matrix_rgb2ycbcr(0);*/
ldim_stts_en(resolution, 0, 0, 1, 1, 1, 0);
break;
default:
break;
if (ldim_dev.ldim_func == NULL) {
LDIMERR("%s: invalid ldim_func\n", __func__);
return;
}
if (ldim_dev.ldim_func->stts_init)
ldim_dev.ldim_func->stts_init(resolution);
resolution_region = 0;
@@ -365,155 +348,6 @@ static void ldim_stts_initial(unsigned int pic_h, unsigned int pic_v,
row_start, col_start, BLK_Hnum);
}
static void LDIM_Initial_GXTVBB(unsigned int ldim_bl_en,
unsigned int ldim_hvcnt_bypass)
{
unsigned int i, j, k;
unsigned int data;
unsigned int *arrayTmp;
arrayTmp = kcalloc(1536, sizeof(unsigned int), GFP_KERNEL);
if (arrayTmp == NULL) {
LDIMERR("%s malloc error\n", __func__);
return;
}
data = LDIM_RD_32Bits(REG_LD_MISC_CTRL0);
data = data & (~(3<<4));
LDIM_WR_32Bits(REG_LD_MISC_CTRL0, data);
/*change here: gBLK_Hidx_LUT: s14*19 */
LDIM_WR_BASE_LUT(REG_LD_BLK_HIDX_BASE,
nPRM.reg_LD_BLK_Hidx, 16, LD_BLK_LEN_H);
/* change here: gBLK_Vidx_LUT: s14*19 */
LDIM_WR_BASE_LUT(REG_LD_BLK_VIDX_BASE,
nPRM.reg_LD_BLK_Vidx, 16, LD_BLK_LEN_V);
/* change here: gHDG_LUT: u10*32 */
LDIM_WR_BASE_LUT(REG_LD_LUT_HDG_BASE,
nPRM.reg_LD_LUT_Hdg, 16, LD_LUT_LEN);
/* change here: gVDG_LUT: u10*32 */
LDIM_WR_BASE_LUT(REG_LD_LUT_VDG_BASE,
nPRM.reg_LD_LUT_Vdg, 16, LD_LUT_LEN);
/* change here: gVHk_LUT: u10*32 */
LDIM_WR_BASE_LUT(REG_LD_LUT_VHK_BASE,
nPRM.reg_LD_LUT_VHk, 16, LD_LUT_LEN);
/* reg_LD_LUT_VHk_pos[32]/reg_LD_LUT_VHk_neg[32]: u8 */
for (i = 0; i < 32; i++)
arrayTmp[i] = nPRM.reg_LD_LUT_VHk_pos[i];
for (i = 0; i < 32; i++)
arrayTmp[32+i] = nPRM.reg_LD_LUT_VHk_neg[i];
LDIM_WR_BASE_LUT(REG_LD_LUT_VHK_NEGPOS_BASE, arrayTmp, 8, 64);
/* reg_LD_LUT_VHo_pos[32]/reg_LD_LUT_VHo_neg[32]: s8 */
for (i = 0; i < 32; i++)
arrayTmp[i] = nPRM.reg_LD_LUT_VHo_pos[i];
for (i = 0; i < 32; i++)
arrayTmp[32+i] = nPRM.reg_LD_LUT_VHo_neg[i];
LDIM_WR_BASE_LUT(REG_LD_LUT_VHO_NEGPOS_BASE, arrayTmp, 8, 64);
/* reg_LD_LUT_HHk[32]:u8 */
LDIM_WR_BASE_LUT(REG_LD_LUT_HHK_BASE, nPRM.reg_LD_LUT_HHk, 8, 32);
/*gLD_REFLECT_DGR_LUT: u6 * (20+20+4) */
for (i = 0; i < 20; i++)
arrayTmp[i] = nPRM.reg_LD_Reflect_Hdgr[i];
for (i = 0; i < 20; i++)
arrayTmp[20+i] = nPRM.reg_LD_Reflect_Vdgr[i];
for (i = 0; i < 4; i++)
arrayTmp[40+i] = nPRM.reg_LD_Reflect_Xdgr[i];
LDIM_WR_BASE_LUT(REG_LD_REFLECT_DGR_BASE, arrayTmp, 8, 44);
/* X_lut: 12 * 3*16*32 */
for (i = 0; i < 3; i++)
for (j = 0; j < 16; j++)
for (k = 0; k < 32; k++)
arrayTmp[16*32*i+32*j+k] = nPRM.X_lut[i][j][k];
LDIM_WR_BASE_LUT(REG_LD_RGB_LUT_BASE, arrayTmp, 16, 32*16*3);
/* X_nrm: 4 * 16 */
LDIM_WR_BASE_LUT(REG_LD_RGB_NRMW_BASE, nPRM.X_nrm[0], 4, 16);
/* X_idx: 12*16 */
/*LDIM_WR_BASE_LUT(REG_LD_RGB_IDX_BASE, nPRM.X_idx[0], 12, 16);*/
LDIM_WR_BASE_LUT(REG_LD_RGB_IDX_BASE, nPRM.X_idx[0], 16, 16);
/* gMatrix_LUT: u12*LD_BLKREGNUM */
LDIM_WR_BASE_LUT_DRT(REG_LD_MATRIX_BASE, nPRM.BL_matrix, LD_BLKREGNUM);
/* LD_FRM_SIZE */
data = ((nPRM.reg_LD_pic_RowMax&0xfff)<<16) |
(nPRM.reg_LD_pic_ColMax&0xfff);
LDIM_WR_32Bits(REG_LD_FRM_SIZE, data);
/* LD_RGB_MOD */
data = ((nPRM.reg_LD_RGBmapping_demo & 0x1) << 19) |
((nPRM.reg_LD_X_LUT_interp_mode[2] & 0x1) << 18) |
((nPRM.reg_LD_X_LUT_interp_mode[1] & 0x1) << 17) |
((nPRM.reg_LD_X_LUT_interp_mode[0] & 0x1) << 16) |
((nPRM.reg_LD_BkLit_LPFmod & 0x7) << 12) |
((nPRM.reg_LD_Litshft & 0x7) << 8) |
((nPRM.reg_LD_BackLit_Xtlk & 0x1) << 7) |
((nPRM.reg_LD_BkLit_Intmod & 0x1) << 6) |
((nPRM.reg_LD_BkLUT_Intmod & 0x1) << 5) |
((nPRM.reg_LD_BkLit_curmod & 0x1) << 4) |
((nPRM.reg_LD_BackLit_mode & 0x3));
LDIM_WR_32Bits(REG_LD_RGB_MOD, data);
/* LD_BLK_HVNUM */
data = ((nPRM.reg_LD_Reflect_Vnum & 0x7) << 20) |
((nPRM.reg_LD_Reflect_Hnum & 0x7) << 16) |
((nPRM.reg_LD_BLK_Vnum & 0x3f) << 8) |
((nPRM.reg_LD_BLK_Hnum & 0x3f));
LDIM_WR_32Bits(REG_LD_BLK_HVNUM, data);
/* REG_LD_FRM_HBLAN_VHOLS */
data = ((nPRM.reg_LD_LUT_VHo_LS & 0x7) << 16) |
((6 & 0x1fff)) ; /*frm_hblank_num */
LDIM_WR_32Bits(REG_LD_FRM_HBLAN_VHOLS, data);
/* LD_HVGAIN */
data = ((nPRM.reg_LD_Vgain & 0xfff) << 16) |
(nPRM.reg_LD_Hgain & 0xfff);
LDIM_WR_32Bits(REG_LD_HVGAIN, data);
/* LD_LIT_GAIN_COMP */
data = ((nPRM.reg_LD_Litgain & 0xfff) << 16) |
(nPRM.reg_BL_matrix_Compensate & 0xfff);
LDIM_WR_32Bits(REG_LD_LIT_GAIN_COMP, data);
/* LD_BKLIT_VLD */
data = 0;
for (i = 0; i < 32; i++)
if (nPRM.reg_LD_BkLit_valid[i])
data = data | (1<<i);
LDIM_WR_32Bits(REG_LD_BKLIT_VLD, data);
/* LD_BKLIT_PARAM */
data = ((nPRM.reg_LD_BkLit_Celnum & 0xff) << 16) |
(nPRM.reg_BL_matrix_AVG & 0xfff);
LDIM_WR_32Bits(REG_LD_BKLIT_PARAM, data);
/* REG_LD_LUT_XDG_LEXT */
data = ((nPRM.reg_LD_LUT_Vdg_LEXT & 0x3ff) << 20) |
((nPRM.reg_LD_LUT_VHk_LEXT & 0x3ff) << 10) |
(nPRM.reg_LD_LUT_Hdg_LEXT & 0x3ff);
LDIM_WR_32Bits(REG_LD_LUT_XDG_LEXT, data);
/* LD_FRM_RST_POS */
data = (16<<16) | (3); /* h=16,v=3 :ldim_param_frm_rst_pos */
LDIM_WR_32Bits(REG_LD_FRM_RST_POS, data);
/* LD_FRM_BL_START_POS */
data = (16<<16) | (4); /* ldim_param_frm_bl_start_pos; */
LDIM_WR_32Bits(REG_LD_FRM_BL_START_POS, data);
/* REG_LD_XLUT_DEMO_ROI_XPOS */
data = ((nPRM.reg_LD_xlut_demo_roi_xend & 0x1fff) << 16) |
(nPRM.reg_LD_xlut_demo_roi_xstart & 0x1fff);
LDIM_WR_32Bits(REG_LD_XLUT_DEMO_ROI_XPOS, data);
/* REG_LD_XLUT_DEMO_ROI_YPOS */
data = ((nPRM.reg_LD_xlut_demo_roi_yend & 0x1fff) << 16) |
(nPRM.reg_LD_xlut_demo_roi_ystart & 0x1fff);
LDIM_WR_32Bits(REG_LD_XLUT_DEMO_ROI_YPOS, data);
/* REG_LD_XLUT_DEMO_ROI_CTRL */
data = ((nPRM.reg_LD_xlut_oroi_enable & 0x1) << 1) |
(nPRM.reg_LD_xlut_iroi_enable & 0x1);
LDIM_WR_32Bits(REG_LD_XLUT_DEMO_ROI_CTRL, data);
/* REG_LD_MISC_CTRL0 {ram_clk_gate_en,2'h0,ldlut_ram_sel,ram_clk_sel,
* reg_hvcnt_bypass,reg_ldim_bl_en,soft_bl_start,reg_soft_rst)
*/
data = (0 << 1) | (ldim_bl_en << 2) |
(ldim_hvcnt_bypass << 3) | (3 << 4) | (1 << 8);
/* ldim_param_misc_ctrl0; */
LDIM_WR_32Bits(REG_LD_MISC_CTRL0, data);
kfree(arrayTmp);
}
static int LDIM_Update_Matrix(int NewBlMatrix[], int BlMatrixNum)
{
int data;
@@ -548,7 +382,7 @@ Previous_Matrix:
return 1;
}
static void LDIM_Initial_TXLX(unsigned int ldim_bl_en,
static void ldim_initial_txlx(unsigned int ldim_bl_en,
unsigned int ldim_hvcnt_bypass)
{
unsigned int i;
@@ -733,8 +567,6 @@ static void LDIM_Initial(unsigned int pic_h, unsigned int pic_v,
unsigned int BackLit_mode, unsigned int ldim_bl_en,
unsigned int ldim_hvcnt_bypass)
{
struct aml_bl_drv_s *bl_drv = aml_bl_get_driver();
LDIMPR("%s: %d %d %d %d %d %d %d\n",
__func__, pic_h, pic_v, BLK_Vnum, BLK_Hnum,
BackLit_mode, ldim_bl_en, ldim_hvcnt_bypass);
@@ -752,18 +584,14 @@ static void LDIM_Initial(unsigned int pic_h, unsigned int pic_v,
/*config params end */
ld_fw_cfg_once(&nPRM);
if (LDIM_DATA_FROM_DB)
ldim_db_load_update(&nPRM, ldim_db_para);
ldim_db_load_update(&nPRM, ldim_dev.ldim_db_para);
switch (bl_drv->data->chip_type) {
case BL_CHIP_TXLX:
LDIM_Initial_TXLX(ldim_bl_en, ldim_hvcnt_bypass);
break;
case BL_CHIP_GXTVBB:
LDIM_Initial_GXTVBB(ldim_bl_en, ldim_hvcnt_bypass);
break;
default:
break;
if (ldim_dev.ldim_func == NULL) {
LDIMERR("%s: invalid ldim_func\n", __func__);
return;
}
if (ldim_dev.ldim_func->ldim_init)
ldim_dev.ldim_func->ldim_init(ldim_bl_en, ldim_hvcnt_bypass);
}
static void ldim_update_matrix(unsigned int mode)
@@ -830,44 +658,6 @@ static void ldim_update_matrix(unsigned int mode)
LDIM_WR_32Bits(REG_LD_MISC_CTRL0, data);
}
static void ldim_update_gxtvbb(void)
{
unsigned int data;
if (ldim_avg_update_en) {
/* LD_BKLIT_PARAM */
data = LDIM_RD_32Bits(REG_LD_BKLIT_PARAM);
data = (data&(~0xfff)) | (nPRM.reg_BL_matrix_AVG&0xfff);
LDIM_WR_32Bits(REG_LD_BKLIT_PARAM, data);
/* compensate */
data = LDIM_RD_32Bits(REG_LD_LIT_GAIN_COMP);
data = (data&(~0xfff)) |
(nPRM.reg_BL_matrix_Compensate & 0xfff);
LDIM_WR_32Bits(REG_LD_LIT_GAIN_COMP, data);
}
if (ldim_matrix_update_en) {
data = LDIM_RD_32Bits(REG_LD_MISC_CTRL0);
data = data & (~(3<<4));
data = data | (1<<2);
LDIM_WR_32Bits(REG_LD_MISC_CTRL0, data);
/* gMatrix_LUT: s12*100 ==> max to 8*8 enum ##r/w ram method*/
LDIM_WR_BASE_LUT_DRT(REG_LD_MATRIX_BASE,
&(nPRM.BL_matrix[0]), ldim_blk_row*ldim_blk_col);
/*data = LDIM_RD_32Bits(REG_LD_MISC_CTRL0);*/
data = data | (3<<4);
LDIM_WR_32Bits(REG_LD_MISC_CTRL0, data);
} else {
data = LDIM_RD_32Bits(REG_LD_MISC_CTRL0);
data = data & (~(1<<2));
LDIM_WR_32Bits(REG_LD_MISC_CTRL0, data);
}
/* disable the CBUS configure the RAM */
}
static void ldim_update_txlx(void)
{
unsigned int data;
@@ -892,43 +682,18 @@ static void ldim_update_txlx(void)
static void ldim_update_setting(void)
{
struct aml_bl_drv_s *bl_drv = aml_bl_get_driver();
switch (bl_drv->data->chip_type) {
case BL_CHIP_TXLX:
ldim_update_txlx();
break;
case BL_CHIP_GXTVBB:
ldim_update_gxtvbb();
break;
default:
break;
if (ldim_dev.ldim_func == NULL) {
if (ldim_debug_print)
LDIMERR("%s: invalid ldim_func\n", __func__);
return;
}
}
static irqreturn_t rdma_ldim_intr(int irq, void *dev_id)
{
ulong flags;
/*LDIMPR("*********rdma_ldim_intr start*********\n");*/
spin_lock_irqsave(&rdma_ldim_isr_lock, flags);
if (ldim_hist_en) {
/*schedule_work(&ldim_on_vs_work);*/
queue_work(ldim_queue, &ldim_on_vs_work);
}
rdma_ldim_irq_cnt++;
if (rdma_ldim_irq_cnt > 0xfffffff)
rdma_ldim_irq_cnt = 0;
spin_unlock_irqrestore(&rdma_ldim_isr_lock, flags);
/*LDIMPR("*********rdma_ldim_intr end*********\n");*/
return IRQ_HANDLED;
if (ldim_dev.ldim_func->update_setting)
ldim_dev.ldim_func->update_setting();
}
static irqreturn_t ldim_vsync_isr(int irq, void *dev_id)
{
ulong flags;
struct aml_bl_drv_s *bl_drv = aml_bl_get_driver();
unsigned long flags;
if (ldim_on_flag == 0)
return IRQ_HANDLED;
@@ -939,17 +704,9 @@ static irqreturn_t ldim_vsync_isr(int irq, void *dev_id)
if (ldim_avg_update_en)
ldim_update_setting();
switch (bl_drv->data->chip_type) {
case BL_CHIP_TXLX:
if (ldim_hist_en) {
/*schedule_work(&ldim_on_vs_work);*/
queue_work(ldim_queue, &ldim_on_vs_work);
}
break;
case BL_CHIP_GXTVBB:
break;
default:
break;
if (ldim_hist_en) {
/*schedule_work(&ldim_on_vs_work);*/
queue_work(ldim_queue, &ldim_on_vs_work);
}
} else {
/*schedule_work(&ldim_off_vs_work);*/
@@ -1126,6 +883,18 @@ static void ldim_on_vs_arithmetic(void)
kfree(local_ldim_max_rgb);
}
static void ldim_on_update_brightness(struct work_struct *work)
{
ldim_stts_read_region(ldim_hist_row, ldim_hist_col);
ldim_on_vs_arithmetic();
ldim_on_vs_brightness();
}
static void ldim_off_update_brightness(struct work_struct *work)
{
ldim_off_vs_brightness();
}
static void ldim_bl_remap_curve_print(void)
{
int i = 0, len;
@@ -2036,10 +1805,10 @@ static long ldim_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
LDIMERR("db_para malloc error\n");
return -EINVAL;
}
ldim_db_para = db_para;
if (copy_from_user(ldim_db_para, (void __user *)arg,
ldim_dev.ldim_db_para = db_para;
if (copy_from_user(ldim_dev.ldim_db_para, (void __user *)arg,
sizeof(struct ldim_param_s))) {
ldim_db_para = NULL;
ldim_dev.ldim_db_para = NULL;
kfree(db_para);
return -EINVAL;
}
@@ -2047,7 +1816,7 @@ static long ldim_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
LDIM_Initial(ldim_config.hsize, ldim_config.vsize,
ldim_blk_row, ldim_blk_col,
ldim_config.bl_mode, 1, 0);
ldim_db_para = NULL;
ldim_dev.ldim_db_para = NULL;
kfree(db_para);
break;
@@ -3422,11 +3191,23 @@ ldim_malloc_err0:
return -1;
}
static struct aml_ldim_func_s ldim_func_txlx = {
.update_setting = ldim_update_txlx,
.stts_init = ldim_stts_initial_txlx,
.ldim_init = ldim_initial_txlx,
};
static struct aml_ldim_func_s ldim_func_tl1 = {
.update_setting = NULL,
.stts_init = NULL,
.ldim_init = NULL,
};
int aml_ldim_probe(struct platform_device *pdev)
{
int ret = 0;
unsigned int i;
unsigned int ldim_vsync_irq = 0, ldim_rdma_irq = 0;
unsigned int ldim_vsync_irq = 0;
struct ldim_dev_s *devp = &ldim_dev;
struct aml_bl_drv_s *bl_drv = aml_bl_get_driver();
@@ -3454,7 +3235,19 @@ int aml_ldim_probe(struct platform_device *pdev)
/* db para */
LDIM_DATA_FROM_DB = 0;
ldim_db_para = NULL;
devp->ldim_db_para = NULL;
/* ldim_func */
switch (bl_drv->data->chip_type) {
case BL_CHIP_TL1:
devp->ldim_func = &ldim_func_tl1;
break;
case BL_CHIP_TXLX:
devp->ldim_func = &ldim_func_txlx;
break;
default:
devp->ldim_func = NULL;
break;
}
ret = aml_ldim_malloc(ldim_blk_row, ldim_blk_col);
if (ret) {
@@ -3534,27 +3327,6 @@ int aml_ldim_probe(struct platform_device *pdev)
else
LDIMPR("request ldim_vsync_irq successful\n");
switch (bl_drv->data->chip_type) {
case BL_CHIP_GXTVBB:
bl_drv->res_ldim_rdma_irq = platform_get_resource(pdev,
IORESOURCE_IRQ, 1);
if (!bl_drv->res_ldim_rdma_irq) {
ret = -ENODEV;
LDIMERR("ldim_rdma_irq resource error\n");
goto err;
}
ldim_rdma_irq = bl_drv->res_ldim_rdma_irq->start;
LDIMPR("ldim_rdma_irq: %d\n", ldim_rdma_irq);
if (request_irq(ldim_rdma_irq, rdma_ldim_intr, IRQF_SHARED,
"ldim_rdma", (void *)"ldim_rdma"))
LDIMERR("can't request ldim_rdma_irq\n");
else
LDIMPR("request ldim_rdma_irq successful\n");
break;
default:
break;
}
ldim_driver.valid_flag = 1;
LDIMPR("%s ok\n", __func__);
@@ -3594,16 +3366,6 @@ int aml_ldim_remove(void)
kfree(ldim_driver.local_ldim_matrix);
free_irq(bl_drv->res_ldim_vsync_irq->start, (void *)"ldim_vsync");
switch (bl_drv->data->chip_type) {
case BL_CHIP_GXTVBB:
if (bl_drv->res_ldim_rdma_irq) {
free_irq(bl_drv->res_ldim_rdma_irq->start,
(void *)"ldim_rdma");
}
break;
default:
break;
}
cdev_del(devp->aml_ldim_cdevp);
kfree(devp->aml_ldim_cdevp);

7
drivers/amlogic/media/vout/backlight/aml_ldim/ldim_drv.h
View File

@@ -36,6 +36,13 @@ extern int LD_remap_lut[16][32];
/*========================================*/
struct aml_ldim_func_s {
void (*update_setting)(void);
void (*stts_init)(unsigned int resolution);
void (*ldim_init)(unsigned int bl_en, unsigned int hvcnt_bypass);
};
/*========================================*/
extern int ldim_round(int ix, int ib);
extern void ldim_stts_en(unsigned int resolution, unsigned int pix_drop_mode,

359
drivers/amlogic/media/vout/backlight/aml_ldim/ldim_func.c
View File

@@ -41,51 +41,6 @@
#define Wr(reg, val) Wr_reg(reg, val)
#define Rd(reg) Rd_reg(reg)
static int LD_STA1max_Hidx[25] = {
/* U12* 25 */
0, 480, 960, 1440, 1920, 2400, 2880,
3360, 3840, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095, 4095
};
static int LD_STA1max_Vidx[17] = {
/* u12x 17 */
0, 2160, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095
};
static int LD_STA2max_Hidx[25] = {
/* U12* 25 */
0, 480, 960, 1440, 1920, 2400, 2880,
3360, 3840, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095, 4095
};
static int LD_STA2max_Vidx[17] = {
/* u12x 17 */
0, 2160, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095
};
static int LD_STAhist_Hidx[25] = {
/* U12* 25 */
0, 480, 960, 1440, 1920, 2400, 2880,
3360, 3840, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095, 4095
};
static int LD_STAhist_Vidx[17] = {
/* u12x 17 */
0, 2160, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095, 4095,
4095, 4095, 4095, 4095, 4095
};
static int LD_BLK_Hidx[33] = {
/* S14* 33 */
-1920, -1440, -960, -480, 0, 480,
@@ -104,27 +59,6 @@ static int LD_BLK_Vidx[25] = {
8191, 8191, 8191, 8191, 8191, 8191, 8191
};
static int LD_LUT_Hdg[32] = {
/* u10 */
503, 501, 494, 481, 465, 447, 430, 409, 388, 369, 354,
343, 334, 326, 318, 311, 305, 299, 293, 286, 279, 272,
266, 261, 257, 252, 245, 235, 226, 218, 214, 213
};
static int LD_LUT_Vdg[32] = {
/* u10 */
373, 371, 367, 364, 359, 353, 346, 337, 328, 318, 308,
297, 286, 274, 261, 247, 232, 218, 204, 191, 180, 169,
158, 148, 138, 130, 122, 115, 108, 104, 100, 97
};
static int LD_LUT_VHk[32] = {
/* u10 */
492, 492, 492, 492, 427, 356, 328, 298, 272, 251, 229,
206, 191, 175, 162, 151, 144, 139, 131, 127, 119, 110,
105, 101, 99, 98, 94, 85, 83, 77, 74, 73
};
static int LD_LUT_Hdg1[32] = {
/* u10 */
503, 501, 494, 481, 465, 447, 430, 409, 388, 369, 354,
@@ -162,17 +96,20 @@ static int LD_LUT_Hdg1_TXLX[32] = {
455, 487, 498, 505, 506, 509, 503, 494,
493, 483, 484, 480, 478, 476, 472, 472,
468, 465, 459, 449, 448, 439, 436, 432,
430, 413, 402, 386, 361, 343, 317, 307};
430, 413, 402, 386, 361, 343, 317, 307
};
static int LD_LUT_Vdg1_TXLX[32] = {
485, 483, 474, 465, 451, 435, 406, 381,
350, 320, 283, 251, 211, 178, 147, 113,
88, 65, 52, 37, 27, 20, 16, 8,
3, 2, 0, 0, 0, 0, 0, 0};
3, 2, 0, 0, 0, 0, 0, 0
};
static int LD_LUT_VHk1_TXLX[32] = {
490, 410, 356, 317, 288, 272, 266, 260,
258, 253, 249, 246, 242, 240, 236, 236,
232, 229, 226, 224, 224, 222, 221, 221,
221, 219, 219, 221, 219, 225, 228, 237};
221, 219, 219, 221, 219, 225, 228, 237
};
static int reg_LD_LUT_Hdg_TXLX[8][32] = {
{254, 248, 239, 226, 211, 194, 176, 156,
137, 119, 101, 85, 70, 57, 45, 36,
@@ -275,18 +212,23 @@ static int reg_LD_LUT_VHk_TXLX[8][32] = {
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128},
};
static int reg_LD_LUT_VHo_pos_TXLX[32] = {0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
static int reg_LD_LUT_VHo_neg_TXLX[32] = {0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
static int reg_LD_LUT_VHo_pos_TXLX[32] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
static int reg_LD_LUT_VHo_neg_TXLX[32] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
static int reg_LD_LUT_Hdg_LEXT_TXLX[8] = {
260, 260, 260, 260, 260, 260, 260, 260};
260, 260, 260, 260, 260, 260, 260, 260
};
static int reg_LD_LUT_Vdg_LEXT_TXLX[8] = {
260, 260, 260, 260, 260, 260, 260, 260};
260, 260, 260, 260, 260, 260, 260, 260
};
static int reg_LD_LUT_VHk_LEXT_TXLX[8] = {
128, 128, 128, 128, 128, 128, 128, 128};
128, 128, 128, 128, 128, 128, 128, 128
};
/* public function */
@@ -873,269 +815,11 @@ void LD_LUTInit(struct LDReg_s *Reg)
}
}
break;
case BL_CHIP_GXTVBB:
/* Emulate the FW to set the LUTs */
for (k = 0; k < 16; k++) {
/*set the LUT to be inverse of the Lit_value,*/
/* lit_idx distribute equal space, set by FW */
Reg->X_idx[0][k] = 4095 - 256 * k;
Reg->X_nrm[0][k] = 8;
for (t = 0; t < 32; t++) {
Reg->X_lut[0][k][t] = LD_remap_lut[k][t];
Reg->X_lut[1][k][t] = LD_remap_lut[k][t];
Reg->X_lut[2][k][t] = LD_remap_lut[k][t];
}
}
break;
default:
break;
}
}
static void ConLDReg_GXTVBB(struct LDReg_s *Reg)
{
unsigned int T = 0;
unsigned int Vnum = 0;
unsigned int Hnum = 0;
unsigned int BSIZE = 0;
/* General registers; */
Reg->reg_LD_pic_RowMax = 2160;/* setting default */
Reg->reg_LD_pic_ColMax = 3840;
LD_IntialData(Reg->reg_LD_pic_YUVsum, 3, 0);
/* only output u16*3, (internal ACC will be u32x3)*/
LD_IntialData(Reg->reg_LD_pic_RGBsum, 3, 0);
/* set same region division for statistics */
Reg->reg_LD_STA_Vnum = 8;
Reg->reg_LD_STA_Hnum = 8;
/*Image Statistic options */
Reg->reg_LD_BLK_Vnum = 1;/*u5: Maximum to BLKVMAX */
Reg->reg_LD_BLK_Hnum = 8;/*u5: Maximum to BLKHMAX */
Reg->reg_LD_STA1max_LPF = 1;
/*u1: STA1max statistics on [1 2 1]/4 filtered results */
Reg->reg_LD_STA2max_LPF = 1;
/*u1: STA2max statistics on [1 2 1]/4 filtered results*/
Reg->reg_LD_STAhist_LPF = 1;
/*u1: STAhist statistics on [1 2 1]/4 filtered results*/
Reg->reg_LD_STA1max_Hdlt = 0;
/*u2: (2^x) extra pixels into Max calculation*/
Reg->reg_LD_STA1max_Vdlt = 0;
/*u4: extra pixels into Max calculation vertically*/
Reg->reg_LD_STA2max_Hdlt = 0;
/*u2: (2^x) extra pixels into Max calculation*/
Reg->reg_LD_STA2max_Vdlt = 0;
/*u4: extra pixels into Max calculation vertically*/
Reg->reg_LD_STAhist_mode = 3;
/*u3: histogram statistics on XX separately 20bits*16bins:
* 0:R-only,1:G-only 2:B-only 3:Y-only; 4:MAX(R,G,B),5/6/7:R&G&B
*/
Reg->reg_LD_STAhist_pix_drop_mode = 0;/*u2 */
for (T = 0; T < LD_STA_LEN_H; T++) {
Reg->reg_LD_STA1max_Hidx[T] = LD_STA1max_Hidx[T];/*U12* 25*/
Reg->reg_LD_STA2max_Hidx[T] = LD_STA2max_Hidx[T];/*U12* 25*/
Reg->reg_LD_STAhist_Hidx[T] = LD_STAhist_Hidx[T];/*U12* 25*/
}
for (T = 0; T < LD_STA_LEN_V; T++) {
Reg->reg_LD_STA1max_Vidx[T] = LD_STA1max_Vidx[T];/*u12x 17*/
Reg->reg_LD_STA2max_Vidx[T] = LD_STA2max_Vidx[T];/*u12x 17*/
Reg->reg_LD_STAhist_Vidx[T] = LD_STAhist_Vidx[T];/*u12x 17*/
}
/****** FBC3 fw_hw_alg_frm *******/
Reg->reg_ldfw_BLmax = 4095; /*maximum BL value*/
Reg->reg_ldfw_blk_norm = 128;
/*u8: normalization gain for blk number,
* 1/blk_num= norm>>(rs+8), norm = (1<<(rs+8))/blk_num
*/
Reg->reg_ldfw_blk_norm_rs = 2;
/*u3: 0~7, 1/blk_num= norm>>(rs+8)*/
for (T = 0; T < 8; T++)
Reg->reg_ldfw_sta_hdg_weight[T] = 64;
Reg->reg_ldfw_sta_max_mode = 3;
/* u2: maximum selection for components:
* 0: r_max, 1: g_max, 2: b_max; 3: max(r,g,b)
*/
Reg->reg_ldfw_sta_max_hist_mode = 0;
/* u2: mode of reference max/hist mode:
* 0: MIN(max, hist), 1: MAX(max, hist) 2: (max+hist)/2,
* 3: (max(a,b)*3 + min(a,b))/4
*/
Reg->reg_ldfw_hist_valid_rate = 64;
/* u8, norm to 512 as "1", if hist_matrix[i]>(rate*histavg)>>9 */
Reg->reg_ldfw_hist_valid_ofst = 63;/* u8, hist valid bin upward offset*/
Reg->reg_ldfw_sedglit_RL = 1;/*u1: single edge lit right/bottom mode*/
Reg->reg_ldfw_sf_thrd = 1600;
/*u12: threshold of difference to enable the sf;*/
Reg->reg_ldfw_boost_gain = 64;
/* u8: boost gain for the region that is
* larger than the average, norm to 16 as "1"
*/
Reg->reg_ldfw_tf_alpha_rate = 16;
/*u8: rate to SFB_BL_matrix from last frame difference;*/
Reg->reg_ldfw_tf_alpha_ofst = 32;
/* u8: ofset to alpha SFB_BL_matrix from last frame difference;*/
Reg->reg_ldfw_tf_disable_th = 255;
/* u8: 4x is the threshod to disable tf to the alpha
* (SFB_BL_matrix from last frame difference;
*/
Reg->reg_ldfw_blest_acmode = 1;
/* u3: 0: est on BLmatrix; 1: est on (BL-DC);
* 2: est on (BL-MIN); 3: est on (BL-MAX) 4: 2048; 5:1024
*/
Reg->reg_ldfw_sf_enable = 0;
/* u1: enable signal for spatial filter on the tbl_matrix */
Reg->reg_ldfw_boost_enable = 0;
/* u1: enable signal for Boost filter on the tbl_matrix */
Reg->ro_ldfw_bl_matrix_avg = 0;
/* u12: read-only register for bl_matrix */
/*---------------------Setting BL_matrix initial value
* (will be updated frame to frame in FW)
*/
Vnum = Reg->reg_LD_BLK_Vnum;
Hnum = Reg->reg_LD_BLK_Hnum;
BSIZE = Vnum*Hnum;
/*Initialization */
LD_IntialData(Reg->BL_matrix, BSIZE, 4095);
/* BackLight Modeling control register setting*/
Reg->reg_LD_BackLit_Xtlk = 1;
/* u1: 0 no block to block Xtalk model needed; 1: Xtalk model needed*/
Reg->reg_LD_BackLit_mode = 1;
/*u2: 0- LEFT/RIGHT Edge Lit; 1- Top/Bot Edge Lit; 2 - DirectLit modeled
* H/V independent; 3- DirectLit modeled HV Circle distribution
*/
Reg->reg_LD_Reflect_Hnum = 3;
/*u3: numbers of band reflection considered in Horizontal
* direction; 0~4
*/
Reg->reg_LD_Reflect_Vnum = 0;
/*u3: numbers of band reflection considered in Horizontal
* direction; 0~4
*/
Reg->reg_LD_BkLit_curmod = 0;
/*u1: 0: H/V separately, 1 Circle distribution*/
Reg->reg_LD_BkLUT_Intmod = 1;
/*u1: 0: linear interpolation, 1 cubical interpolation*/
Reg->reg_LD_BkLit_Intmod = 1;
/*u1: 0: linear interpolation, 1 cubical interpolation*/
Reg->reg_LD_BkLit_LPFmod = 7;
/* u3: 0: no LPF, 1:[1 14 1]/16;2:[1 6 1]/8; 3: [1 2 1]/4;
* 4:[9 14 9]/32 5/6/7: [5 6 5]/16;
*/
Reg->reg_LD_BkLit_Celnum = 121;
/*u8:0:1920~61####((Reg->reg_LD_pic_ColMax+1)/32)+1;*/
Reg->reg_BL_matrix_AVG = 4095;
/* u12: DC of whole picture BL to be subtract from BL_matrix
* during modeling (Set by FW daynamically)
*/
Reg->reg_BL_matrix_Compensate = 4095;
/* u12: DC of whole picture BL to be compensated back to
* Litfull after the model (Set by FW dynamically);
*/
LD_IntialData(Reg->reg_LD_Reflect_Hdgr, 20, 32);
/*20*u6: cells 1~20 for H Gains of different dist of Left/Right;*/
LD_IntialData(Reg->reg_LD_Reflect_Vdgr, 20, 32);
/*20*u6: cells 1~20 for V Gains of different dist of Top/Bot; */
LD_IntialData(Reg->reg_LD_Reflect_Xdgr, 4, 32);/* 4*u6: */
Reg->reg_LD_Vgain = 256;/* u12 */
Reg->reg_LD_Hgain = 242;/* u12 */
Reg->reg_LD_Litgain = 256;/* u12 */
Reg->reg_LD_Litshft = 3;
/* u3 right shif of bits for the all Lit's sum */
LD_IntialData(Reg->reg_LD_BkLit_valid, 32, 1);
/*u1x32: valid bits for the 32 cell Bklit to contribut to current
* position (refer to the backlit padding pattern)
* region division index 1 2 3 4 5(0) 6(1) 7(2) 8(3) 9(4)
* 10(5)11(6)12(7)13(8) 14(9)15(10) 16 17 18 19
*/
for (T = 0; T < LD_BLK_LEN_H; T++)
Reg->reg_LD_BLK_Hidx[T] = LD_BLK_Hidx[T];/* S14* BLK_LEN_H */
for (T = 0; T < LD_BLK_LEN_V; T++)
Reg->reg_LD_BLK_Vidx[T] = LD_BLK_Vidx[T];/* S14x BLK_LEN_V */
for (T = 0; T < LD_LUT_LEN; T++) {
Reg->reg_LD_LUT_Hdg[T] = LD_LUT_Hdg[T];
Reg->reg_LD_LUT_Vdg[T] = LD_LUT_Vdg[T];
Reg->reg_LD_LUT_VHk[T] = LD_LUT_VHk[T];
}
/* set the VHk_pos and VHk_neg value ,normalized to
* 128 as "1" 20150428
*/
for (T = 0; T < 32; T++) {
Reg->reg_LD_LUT_VHk_pos[T] = 128;/* vdist>=0 */
Reg->reg_LD_LUT_VHk_neg[T] = 128;/* vdist<0 */
Reg->reg_LD_LUT_HHk[T] = 128;/* hdist gain */
Reg->reg_LD_LUT_VHo_pos[T] = 0;/* vdist>=0 */
Reg->reg_LD_LUT_VHo_neg[T] = 0;/* vdist<0 */
}
Reg->reg_LD_LUT_VHo_LS = 0;
Reg->reg_LD_LUT_Hdg_LEXT = 505;
/* 2*(nPRM->reg_LD_LUT_Hdg[0]) - (nPRM->reg_LD_LUT_Hdg[1]); */
Reg->reg_LD_LUT_Vdg_LEXT = 372;
/* 2*(nPRM->reg_LD_LUT_Vdg[0]) - (nPRM->reg_LD_LUT_Vdg[1]); */
Reg->reg_LD_LUT_VHk_LEXT = 492;
/* 2*(nPRM->reg_LD_LUT_VHk[0]) - (nPRM->reg_LD_LUT_VHk[1]); */
/* set the demo window */
Reg->reg_LD_xlut_demo_roi_xstart = (Reg->reg_LD_pic_ColMax/4);
/* u14 start col index of the region of interest */
Reg->reg_LD_xlut_demo_roi_xend = (Reg->reg_LD_pic_ColMax*3/4);
/* u14 end col index of the region of interest */
Reg->reg_LD_xlut_demo_roi_ystart = (Reg->reg_LD_pic_RowMax/4);
/* u14 start row index of the region of interest */
Reg->reg_LD_xlut_demo_roi_yend = (Reg->reg_LD_pic_RowMax*3/4);
/* u14 end row index of the region of interest */
Reg->reg_LD_xlut_iroi_enable = 1;
/* u1: enable rgb LUT remapping inside regon of interest:
* 0: no rgb remapping; 1: enable rgb remapping
*/
Reg->reg_LD_xlut_oroi_enable = 1;
/* u1: enable rgb LUT remapping outside regon of interest:
* 0: no rgb remapping; 1: enable rgb remapping
*/
/* Registers used in LD_RGB_LUT for RGB remaping */
Reg->reg_LD_RGBmapping_demo = 0;
/* u2: 0 no demo mode 1: display BL_fulpel on RGB */
Reg->reg_LD_X_LUT_interp_mode[0] = 1;
/* U1 0: using linear interpolation between to neighbour LUT;
* 1: use the nearest LUT results
*/
Reg->reg_LD_X_LUT_interp_mode[1] = 1;
/* U1 0: using linear interpolation between to neighbour LUT;
* 1: use the nearest LUT results
*/
Reg->reg_LD_X_LUT_interp_mode[2] = 1;
/* U1 0: using linear interpolation between to neighbour LUT;
* 1: use the nearest LUT results
*/
LD_LUTInit(Reg);
/* only do the Lit modleing on the AC part */
Reg->fw_LD_BLEst_ACmode = 0;
/* u2: 0: est on BLmatrix; 1: est on (BL-DC);
* 2: est on (BL-MIN); 3: est on (BL-MAX)
*/
}
static void ConLDReg_TXLX(struct LDReg_s *Reg)
{
int i, j;
@@ -1399,9 +1083,6 @@ void LD_ConLDReg(struct LDReg_s *Reg)
case BL_CHIP_TXLX:
ConLDReg_TXLX(Reg);
break;
case BL_CHIP_GXTVBB:
ConLDReg_GXTVBB(Reg);
break;
default:
break;
}

6
include/linux/amlogic/media/vout/lcd/aml_bl.h
View File

@@ -24,7 +24,7 @@
#include <linux/amlogic/pwm_meson.h>
#define BLPR(fmt, args...) pr_info("bl: "fmt"", ## args)
#define BLERR(fmt, args...) pr_err("bl error: "fmt"", ## args)
#define BLERR(fmt, args...) pr_err("bl error: "fmt"", ## args)
#define AML_BL_NAME "aml-bl"
#define BL_LEVEL_MAX 255
@@ -42,7 +42,6 @@
#define BL_FREQ_VS_DEFAULT 2 /* multiple 2 of vfreq */
enum bl_chip_type_e {
BL_CHIP_GXTVBB,
BL_CHIP_GXL,
BL_CHIP_GXM,
BL_CHIP_TXL,
@@ -50,6 +49,7 @@ enum bl_chip_type_e {
BL_CHIP_AXG,
BL_CHIP_G12A,
BL_CHIP_G12B,
BL_CHIP_TL1,
BL_CHIP_MAX,
};
@@ -183,7 +183,7 @@ struct aml_bl_drv_s {
struct workqueue_struct *workqueue;
struct delayed_work bl_delayed_work;
struct resource *res_ldim_vsync_irq;
struct resource *res_ldim_rdma_irq;
/*struct resource *res_ldim_rdma_irq;*/
};
extern struct aml_bl_drv_s *aml_bl_get_driver(void);