/*
|
* Allwinner SoCs display driver.
|
*
|
* Copyright (C) 2016 Allwinner.
|
*
|
* This file is licensed under the terms of the GNU General Public
|
* License version 2. This program is licensed "as is" without any
|
* warranty of any kind, whether express or implied.
|
*/
|
|
/******************************************************************************
|
* All Winner Tech, All Right Reserved. 2014-2015 Copyright (c)
|
*
|
* File name : de_enhance.c
|
*
|
* Description : display engine 2.0 enhance basic function definition
|
*
|
* History : 2014/04/29 vito cheng v0.1 Initial version
|
*
|
*****************************************************************************/
|
#include "de_rtmx.h"
|
#include "de_enhance.h"
|
#include "de_feat.h"
|
#include "de_vep_table.h"
|
|
#define ONE_SCREEN_ONE_PARA
|
/*
|
* only ONE parameters for one screen,
|
* and all VEPs in this screen use SAME parameters
|
*/
|
/* DEBUG */
|
#define ASE_EXIST
|
#define LTI_EXIST
|
#define FCC_EXIST
|
|
static int device_num;
|
static int vep_num[DE_NUM];
|
static unsigned int frame_cnt[DE_NUM] = { 0 };
|
|
static unsigned int g_demo_enable[DE_NUM] = { 0 };
|
static struct disp_enhance_config g_config[DE_NUM];
|
unsigned int g_format[DE_NUM] = { 0xff };
|
unsigned int g_size_bypass[DE_NUM] = { 0 };
|
/* size too small to enable vep */
|
static struct disp_rect g_size[DE_NUM];
|
static bool g_size_change[DE_NUM];
|
|
/* global histogram, use for bws and ce */
|
unsigned int *g_hist[DE_NUM][CHN_NUM];
|
unsigned int *g_hist_p[DE_NUM][CHN_NUM];
|
unsigned int g_sum[DE_NUM][CHN_NUM];
|
|
static unsigned int
|
enhance_mode_to_para[ENHANCE_MODE_NUM][MODE_NUM][FORMAT_NUM][PARA_NUM] = {
|
/* SHARP AUTO_CONTRAST AUTO_COLOR FC_R FC_G FC_B */
|
{
|
/* lcd normal */
|
{
|
/* rgb */
|
{0x00, 0x00000, 0x00, 0, 0, 0},
|
/* yuv */
|
{0x00, 0x00000, 0x00, 0, 0, 0},
|
},
|
/* hdmi normal */
|
{
|
/* rgb */
|
{0x00, 0x00000, 0x00, 0, 0, 0},
|
/* yuv disable all */
|
{0x00, 0x00000, 0x00, 0, 0, 0},
|
},
|
},
|
/* lcd vivid */
|
{
|
{
|
/* rgb */
|
{0x22, 0x10001, 0x21, 1, 1, 1},
|
/* yuv */
|
{0x11, 0x10010, 0x21, 1, 2, 1},
|
},
|
/* hdmi vivid */
|
{
|
/* rgb */
|
{0x00, 0x00000, 0x21, 1, 1, 1},
|
/* yuv disable all */
|
{0x20, 0x01020, 0x21, 1, 1, 1},
|
},
|
},
|
{
|
/* lcd soft */
|
{
|
/* rgb */
|
{0x00, 0x00000, 0x00, 0, 0, 0},
|
/* yuv */
|
{0x00, 0x00000, 0x00, 0, 0, 0},
|
},
|
/* hdmi soft */
|
{
|
/* rgb */
|
{0x00, 0x00000, 0x00, 0, 0, 0},
|
/* yuv disable all */
|
{0x00, 0x00000, 0x00, 0, 0, 0},
|
}
|
},
|
};
|
|
int de_enhance_info2data(struct disp_enhance_config *config,
|
struct vep_config_data *data, unsigned int bypass)
|
{
|
struct de_rect tmp_win;
|
struct disp_enhance_config tmp_config;
|
|
memcpy(&tmp_config.info, config, sizeof(struct disp_enhance_config));
|
memset(data, 0, sizeof(struct vep_config_data));
|
|
/* FIXME : should be deleted */
|
tmp_win.x = config->info.window.x;
|
tmp_win.y = config->info.window.y;
|
tmp_win.w = config->info.window.width;
|
tmp_win.h = config->info.window.height;
|
/* FIXME end: should be deleted */
|
|
tmp_config.info.sharp = (tmp_config.info.enable == 0
|
|| bypass == 1) ? 0 : tmp_config.info.sharp;
|
tmp_config.info.auto_color = (tmp_config.info.enable == 0
|
|| bypass ==
|
1) ? 0 : tmp_config.info.auto_color;
|
tmp_config.info.auto_contrast = (tmp_config.info.enable == 0
|
|| bypass ==
|
1) ? 0 : tmp_config.info.auto_contrast;
|
tmp_config.info.fancycolor_red = (tmp_config.info.enable == 0
|
|| bypass ==
|
1) ? 0 : tmp_config.info.
|
fancycolor_red;
|
tmp_config.info.fancycolor_green = (tmp_config.info.enable == 0
|
|| bypass ==
|
1) ? 0 : tmp_config.info.
|
fancycolor_green;
|
tmp_config.info.fancycolor_blue = (tmp_config.info.enable == 0
|
|| bypass ==
|
1) ? 0 : tmp_config.info.
|
fancycolor_blue;
|
|
/* FIXME : tmp_win should be deleted */
|
/* fce */
|
de_fce_info2para(tmp_config.info.sharp, tmp_config.info.auto_contrast,
|
tmp_config.info.auto_color, tmp_win, &data->fce_para);
|
|
/* FIXME */
|
/* peak */
|
de_peak_info2para(tmp_config.info.sharp, tmp_win,
|
&data->peak_para);
|
#ifdef LTI_EXIST
|
/* lti */
|
de_lti_info2para(tmp_config.info.sharp, tmp_win,
|
&data->lti_para);
|
#endif
|
#ifdef ASE_EXIST
|
/* ase */
|
de_ase_info2para(tmp_config.info.auto_color, tmp_win, &data->ase_para);
|
#endif
|
#ifdef FCC_EXIST
|
/* fcc */
|
de_fcc_info2para(tmp_config.info.fancycolor_red,
|
tmp_config.info.fancycolor_green,
|
tmp_config.info.fancycolor_blue, 0, 0, 0, tmp_win,
|
&data->fcc_para);
|
#endif
|
|
return 0;
|
}
|
|
int de_enhance_set_format(unsigned int screen_id, unsigned int format)
|
{
|
int format_change = 0;
|
|
if (g_format[screen_id] != format) {
|
g_format[screen_id] = format;
|
format_change = 1;
|
g_config[screen_id].flags |= ENH_FORMAT_DIRTY;
|
}
|
|
if (format_change == 1 || g_size_change[screen_id])
|
de_enhance_apply(screen_id, &g_config[screen_id]);
|
|
return 0;
|
}
|
|
int de_enhance_apply(unsigned int screen_id,
|
struct disp_enhance_config *config)
|
{
|
int ch_id, chno;
|
struct vep_config_data *data;
|
int auto_contrast_dirty;
|
|
data = kmalloc(sizeof(struct vep_config_data), GFP_KERNEL | __GFP_ZERO);
|
if (!data) {
|
__wrn("kmalloc fail!\n");
|
goto err;
|
}
|
chno = vep_num[screen_id];
|
|
__inf("disp %d, en=%d, sharp=%d\n", screen_id, config[0].info.enable,
|
config[0].info.sharp);
|
memcpy(&g_config[screen_id], config,
|
sizeof(struct disp_enhance_config));
|
de_enhance_set_mode(g_format[screen_id], config);
|
for (ch_id = 0; ch_id < chno; ch_id++) {
|
auto_contrast_dirty = (config[0].flags & (ENH_ENABLE_DIRTY
|
| ENH_SIZE_DIRTY
|
| ENH_FORMAT_DIRTY
|
| ENH_MODE_DIRTY)) ?
|
1 : 0;
|
|
/* disp_enhance_info -> vep_config_data */
|
de_enhance_info2data(&config[0], data,
|
g_size_bypass[screen_id]);
|
/* FIXME: Update according to dirty flag */
|
/* fce */
|
de_hist_apply(screen_id, ch_id, data->fce_para.hist_en,
|
auto_contrast_dirty);
|
de_ce_apply(screen_id, ch_id, data->fce_para.ce_en,
|
data->fce_para.b_automode,
|
data->fce_para.up_precent_thr,
|
data->fce_para.down_precent_thr,
|
data->fce_para.update_diff_thr,
|
data->fce_para.slope_black_lmt,
|
data->fce_para.slope_white_lmt,
|
auto_contrast_dirty);
|
de_fce_enable(screen_id, ch_id, data->fce_para.fce_en);
|
de_fce_set_para(screen_id, ch_id, data->fce_para);
|
|
/* peak */
|
de_peak_enable(screen_id, ch_id, data->peak_para.peak_en);
|
de_peak_set_para(screen_id, ch_id, data->peak_para.gain,
|
data->peak_para.hp_ratio,
|
data->peak_para.bp0_ratio);
|
|
/* lti */
|
de_lti_enable(screen_id, ch_id, data->lti_para.lti_en);
|
de_lti_set_para(screen_id, ch_id, data->lti_para.lti_en);
|
|
/* ase */
|
de_ase_enable(screen_id, ch_id, data->ase_para.ase_en);
|
de_ase_set_para(screen_id, ch_id, data->ase_para.gain);
|
|
/* fcc */
|
de_fcc_enable(screen_id, ch_id, data->fcc_para.fcc_en);
|
de_fcc_set_para(screen_id, ch_id, data->fcc_para.sgain);
|
|
}
|
de_enhance_demo_enable(screen_id, config[0].info.demo_enable);
|
g_config[screen_id].flags = 0;
|
|
kfree(data);
|
err:
|
return 0;
|
}
|
|
int de_enhance_set_size(unsigned int screen_id, struct disp_rect *size)
|
{
|
int ch_id, chno;
|
struct de_rect tmp_win;
|
unsigned int demo_enable;
|
|
chno = vep_num[screen_id];
|
demo_enable = g_demo_enable[screen_id] ? 1 : 0;
|
|
for (ch_id = 0; ch_id < chno; ch_id++) {
|
tmp_win.x = 0;
|
tmp_win.y = 0;
|
if (demo_enable) {
|
if (size[ch_id].width > size[ch_id].height) {
|
tmp_win.w = size[ch_id].width >> 1;
|
tmp_win.h = size[ch_id].height;
|
} else {
|
tmp_win.w = size[ch_id].width;
|
tmp_win.h = size[ch_id].height >> 1;
|
}
|
} else {
|
tmp_win.w = size[ch_id].width;
|
tmp_win.h = size[ch_id].height;
|
}
|
|
/* fce */
|
de_fce_set_size(screen_id, ch_id, size[ch_id].width,
|
size[ch_id].height);
|
de_fce_set_window(screen_id, ch_id, demo_enable, tmp_win);
|
g_ce_status[screen_id][ch_id]->width = size[ch_id].width;
|
g_ce_status[screen_id][ch_id]->height = size[ch_id].height;
|
|
/* peak */
|
de_peak_set_size(screen_id, ch_id, size[ch_id].width,
|
size[ch_id].height);
|
de_peak_set_window(screen_id, ch_id, demo_enable, tmp_win);
|
|
/* lti */
|
de_lti_set_size(screen_id, ch_id, size[ch_id].width,
|
size[ch_id].height);
|
de_lti_set_window(screen_id, ch_id, demo_enable, tmp_win);
|
|
/* ase */
|
de_ase_set_size(screen_id, ch_id, size[ch_id].width,
|
size[ch_id].height);
|
de_ase_set_window(screen_id, ch_id, demo_enable, tmp_win);
|
|
/* fcc */
|
de_fcc_set_size(screen_id, ch_id, size[ch_id].width,
|
size[ch_id].height);
|
de_fcc_set_window(screen_id, ch_id, demo_enable, tmp_win);
|
}
|
|
if ((size->width != g_size[screen_id].width)
|
|| (size->height != g_size[screen_id].height)) {
|
g_size_change[screen_id] = true;
|
g_config[screen_id].flags |= ENH_SIZE_DIRTY;
|
} else
|
g_size_change[screen_id] = false;
|
memcpy(&g_size[screen_id], size, sizeof(struct disp_rect));
|
|
if (size[0].width < ENAHNCE_MIN_WIDTH
|
|| size[0].height < ENAHNCE_MIN_HEIGHT) {
|
g_size_bypass[screen_id] = 1;
|
} else {
|
g_size_bypass[screen_id] = 0;
|
}
|
|
return 0;
|
}
|
|
int de_enhance_demo_enable(unsigned int screen_id, unsigned int enable)
|
{
|
if (enable)
|
g_demo_enable[screen_id] = 1;
|
else
|
g_demo_enable[screen_id] = 0;
|
return 0;
|
}
|
|
int de_enhance_sync(unsigned int screen_id)
|
{
|
return 0;
|
}
|
|
int de_enhance_tasklet(unsigned int screen_id)
|
{
|
int ch_id, chno;
|
|
chno = vep_num[screen_id];
|
|
for (ch_id = 0; ch_id < chno; ch_id++) {
|
/* hist */
|
de_hist_tasklet(screen_id, ch_id, frame_cnt[screen_id]);
|
|
/* ce */
|
de_ce_tasklet(screen_id, ch_id, frame_cnt[screen_id]);
|
frame_cnt[screen_id]++;
|
}
|
return 0;
|
}
|
|
int de_enhance_update_regs(unsigned int screen_id)
|
{
|
int chno, ch_id;
|
|
chno = vep_num[screen_id];
|
for (ch_id = 0; ch_id < chno; ch_id++) {
|
de_fce_update_regs(screen_id, ch_id);
|
#ifdef LTI_EXIST
|
de_lti_update_regs(screen_id, ch_id);
|
#endif
|
de_peak_update_regs(screen_id, ch_id);
|
#ifdef ASE_EXIST
|
de_ase_update_regs(screen_id, ch_id);
|
#endif
|
#ifdef FCC_EXIST
|
de_fcc_update_regs(screen_id, ch_id);
|
#endif
|
}
|
return 0;
|
}
|
|
int de_enhance_init(struct disp_bsp_init_para *para)
|
{
|
int screen_id, ch_id;
|
|
device_num = de_feat_get_num_screens();
|
|
for (screen_id = 0; screen_id < device_num; screen_id++)
|
vep_num[screen_id] = de_feat_is_support_vep(screen_id);
|
|
for (screen_id = 0; screen_id < device_num; screen_id++)
|
for (ch_id = 0; ch_id < vep_num[screen_id]; ch_id++) {
|
#if defined(CONFIG_INDEPENDENT_DE)
|
de_fce_init(screen_id, ch_id,
|
para->reg_base[DISP_MOD_DE + screen_id]);
|
#ifdef LTI_EXIST
|
de_lti_init(screen_id, ch_id,
|
para->reg_base[DISP_MOD_DE + screen_id]);
|
#endif
|
de_peak_init(screen_id, ch_id,
|
para->reg_base[DISP_MOD_DE + screen_id]);
|
#ifdef ASE_EXIST
|
de_ase_init(screen_id, ch_id,
|
para->reg_base[DISP_MOD_DE + screen_id]);
|
#endif
|
#ifdef FCC_EXIST
|
de_fcc_init(screen_id, ch_id,
|
para->reg_base[DISP_MOD_DE + screen_id]);
|
#endif
|
#else/*for CONFIG_INDEPENDENT_DE*/
|
de_fce_init(screen_id, ch_id,
|
para->reg_base[DISP_MOD_DE]);
|
#ifdef LTI_EXIST
|
de_lti_init(screen_id, ch_id,
|
para->reg_base[DISP_MOD_DE]);
|
#endif
|
de_peak_init(screen_id, ch_id,
|
para->reg_base[DISP_MOD_DE]);
|
#ifdef ASE_EXIST
|
de_ase_init(screen_id, ch_id,
|
para->reg_base[DISP_MOD_DE]);
|
#endif
|
#ifdef FCC_EXIST
|
de_fcc_init(screen_id, ch_id,
|
para->reg_base[DISP_MOD_DE]);
|
#endif
|
#endif
|
}
|
|
/* initial */
|
for (screen_id = 0; screen_id < device_num; screen_id++)
|
frame_cnt[screen_id] = 0;
|
|
return 0;
|
}
|
|
int de_enhance_exit(void)
|
{
|
int screen_id, ch_id;
|
|
device_num = de_feat_get_num_screens();
|
|
for (screen_id = 0; screen_id < device_num; screen_id++)
|
vep_num[screen_id] = de_feat_is_support_vep(screen_id);
|
|
for (screen_id = 0; screen_id < device_num; screen_id++)
|
for (ch_id = 0; ch_id < vep_num[screen_id]; ch_id++) {
|
de_fce_exit(screen_id, ch_id);
|
#ifdef LTI_EXIST
|
de_lti_exit(screen_id, ch_id);
|
#endif
|
de_peak_exit(screen_id, ch_id);
|
#ifdef ASE_EXIST
|
de_ase_exit(screen_id, ch_id);
|
#endif
|
#ifdef FCC_EXIST
|
de_fcc_exit(screen_id, ch_id);
|
#endif
|
}
|
|
return 0;
|
}
|
|
int de_enhance_set_mode(unsigned int format, struct disp_enhance_config *config)
|
{
|
unsigned int mode, enhance_mode;
|
|
mode = config->info.mode & 0xffff;
|
enhance_mode = (config->info.mode & 0xffff0000) >> 16;
|
|
if ((mode >= MODE_NUM) || (format >= 2)
|
|| (enhance_mode >= ENHANCE_MODE_NUM)) {
|
__wrn("para excess! mode = %d, enhance_mode = %d, format=%d\n",
|
mode, enhance_mode, format);
|
return 1;
|
}
|
|
config->info.sharp =
|
enhance_mode_to_para[enhance_mode][mode][format][0];
|
config->info.auto_contrast =
|
enhance_mode_to_para[enhance_mode][mode][format][1];
|
config->info.auto_color =
|
enhance_mode_to_para[enhance_mode][mode][format][2];
|
config->info.fancycolor_red =
|
enhance_mode_to_para[enhance_mode][mode][format][3];
|
config->info.fancycolor_green =
|
enhance_mode_to_para[enhance_mode][mode][format][4];
|
config->info.fancycolor_blue =
|
enhance_mode_to_para[enhance_mode][mode][format][5];
|
|
return 0;
|
}
|
