shinys000114/kernel_common_drivers
1
0
Fork 0
mirror of https://github.com/hardkernel/kernel_common_drivers.git synced 2026-06-25 12:03:48 +09:00
Code Issues Packages Projects Releases Wiki Activity

lcd: tcon: remove unused code [2/2]

Browse Source 
PD#SWPL-162001

Problem:
need cleanup tcon unused code

Solution:
cleanup tcon unused code

Verify:
ay301

Change-Id: I936dce510a039fd7eb9a1bfdb63e6171d6e0f272
Signed-off-by: Evoke Zhang <evoke.zhang@amlogic.com>
This commit is contained in:
Evoke Zhang
2024-03-22 15:09:23 +08:00
committed by gerrit autosubmit
parent 85b0e173b9
commit ca2ea8cb9c
7 changed files with 499 additions and 1194 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/media/vout/lcd/lcd_common.h
+1
View File
@@ -126,6 +126,7 @@ void *lcd_alloc_dma_buffer(struct aml_lcd_drv_s *pdrv, unsigned int size, dma_ad
u8 *lcd_vmap(ulong addr, u32 size);
void lcd_unmap_phyaddr(u8 *vaddr);
int lcd_debug_parse_param(char *buf_orig, char **parm, int max_parm);
void lcd_debug_info_print(char *print_buf);
void lcd_cpu_gpio_probe(struct aml_lcd_drv_s *pdrv, unsigned int index);
void lcd_cpu_gpio_set(struct aml_lcd_drv_s *pdrv, unsigned int index, int value);
drivers/media/vout/lcd/lcd_debug.c
+1 -1
View File
@@ -47,7 +47,7 @@ int lcd_debug_parse_param(char *buf_orig, char **parm, int max_parm)
return n;
}
static void lcd_debug_info_print(char *print_buf)
void lcd_debug_info_print(char *print_buf)
{
char *ps, *token;
char str[3] = {'\n', '\0'};
drivers/media/vout/lcd/lcd_tcon.c
+108 -539
View File
File diff suppressed because it is too large Load Diff
drivers/media/vout/lcd/lcd_tcon.h
+15 -15
View File
@@ -20,6 +20,8 @@
#define REG_LCD_TCON_MAX 0xffff
#define TCON_INTR_MASKN_VAL 0x0 /* default mask all */
//#define TCON_DBG_TIME
struct lcd_tcon_axi_mem_cfg_s {
unsigned int mem_type;
unsigned int mem_size;
@@ -62,7 +64,6 @@ struct lcd_tcon_config_s {
unsigned int axi_tbl_len;
struct lcd_tcon_axi_mem_cfg_s *axi_mem_cfg_tbl;
unsigned int *axi_reg;
void (*tcon_axi_mem_config)(void);
void (*tcon_axi_mem_secure)(void);
void (*tcon_init_table_pre_proc)(unsigned char *table);
@@ -98,12 +99,14 @@ struct tcon_rmem_s {
unsigned char flag;
unsigned int rsv_mem_size;
unsigned int axi_mem_size;
unsigned int axi_bank;
void *rsv_mem_vaddr;
phys_addr_t rsv_mem_paddr;
phys_addr_t axi_mem_paddr;
phys_addr_t sw_mem_paddr;
unsigned int *axi_reg;
struct tcon_rmem_config_s *axi_rmem;
struct tcon_rmem_config_s bin_path_rmem;
struct tcon_rmem_config_s secure_cfg_rmem;
@@ -147,20 +150,16 @@ struct tcon_data_init_s {
struct tcon_data_list_s *list_header;
};
struct tcon_data_priority_s {
unsigned int index;
unsigned int priority;
};
struct tcon_mem_map_table_s {
/*header*/
unsigned int version;
unsigned char tcon_data_flag;
unsigned int data_load_level;
unsigned int block_cnt;
unsigned char init_load;
//unsigned char init_load;
unsigned char data_complete;
unsigned char bin_path_valid;
unsigned int valid_flag;
unsigned int lut_valid_flag;
unsigned char demura_cnt;
unsigned int block_bit_flag;
unsigned int frame_rate;
@@ -169,7 +168,6 @@ struct tcon_mem_map_table_s {
struct lcd_tcon_init_block_header_s *core_reg_header;
unsigned char *core_reg_table;
struct tcon_data_priority_s *data_priority;
unsigned int *data_size;
unsigned char **data_mem_vaddr;
dma_addr_t *data_mem_paddr;
@@ -180,8 +178,10 @@ struct tcon_mem_map_table_s {
struct tcon_data_init_s *data_init;
#ifdef TCON_DBG_TIME
unsigned long long vsync_time[10];
unsigned long long list_trave_time[10];
#endif
};
#define TCON_BIN_VER_LEN 9
@@ -324,16 +324,16 @@ int lcd_tcon_data_common_parse_set(struct aml_lcd_drv_s *pdrv,
unsigned char *data_buf, phys_addr_t paddr, int init_flag);
void lcd_tcon_init_data_version_update(char *data_buf);
int lcd_tcon_data_load(struct aml_lcd_drv_s *pdrv, unsigned char *data_buf, int index);
int lcd_tcon_bin_load(struct aml_lcd_drv_s *pdrv);
void lcd_tcon_reg_table_print(void);
void lcd_tcon_reg_readback_print(struct aml_lcd_drv_s *pdrv);
void lcd_tcon_multi_lut_print(void);
void lcd_tcon_axi_rmem_lut_load(struct aml_lcd_drv_s *pdrv,
unsigned int index, unsigned char *buf, unsigned int size);
void lcd_tcon_axi_rmem_lut_load(struct aml_lcd_drv_s *pdrv, unsigned int index,
unsigned char *buf, unsigned int size);
#ifdef TCON_DBG_TIME
void lcd_tcon_dbg_trace_clear(void);
void lcd_tcon_dbg_trace_print(unsigned int flag);
#endif
int lcd_tcon_axi_mem_print(struct tcon_rmem_s *tcon_rmem, char *buf, int offset);
void lcd_tcon_debug_file_add(struct aml_lcd_drv_s *pdrv, struct lcd_tcon_local_cfg_s *local_cfg);
void lcd_tcon_debug_file_remove(struct lcd_tcon_local_cfg_s *local_cfg);
drivers/media/vout/lcd/lcd_tcon_debug.c
+338 -560
View File
@@ -55,489 +55,329 @@ static struct lcd_tcon_adb_reg_s adb_reg = {
.len = 0,
};
static const char *lcd_debug_tcon_usage_str = {
"Usage:\n"
" echo reg > tcon ; print tcon system regs\n"
" echo reg rb <reg> > tcon ; read tcon byte reg\n"
" echo reg wb <reg> <val> > tcon ; write tcon byte reg\n"
" echo reg db <reg> <cnt> > tcon ; dump tcon byte regs\n"
" echo reg r <reg> > tcon ; write tcon reg\n"
" echo reg w <reg> <val> > tcon ; write tcon reg\n"
" echo reg d <reg> <cnt> > tcon ; dump tcon regs\n"
"\n"
" echo table > tcon ; print tcon reg table\n"
" echo table r <index> > tcon ; read tcon reg table by specified index\n"
" echo table w <index> <value> > tcon ; write tcon reg table by specified index\n"
" echo table d <index> <len> > tcon ; dump tcon reg table\n"
"data format:\n"
" <index> : hex number\n"
" <value> : hex number\n"
" <len> : dec number\n"
"\n"
" echo table update > tcon ; update tcon reg table into tcon system regs\n"
"\n"
" echo od <en> > tcon ; tcon over driver control\n"
"data format:\n"
" <en> : 0=disable, 1=enable\n"
"\n"
" echo save <str> <path> > tcon ; tcon mem save to file\n"
"data format:\n"
" <str> : table, reg, vac, demura, acc\n"
" <path> : save file path\n"
"\n"
" echo gamma <bit_width> <gamma_r> <gamma_g> <gamma_b> > tcon ; tcon gamma pattern\n"
"data format:\n"
" <bit_width> : 12, 10, 8\n"
" <gamma_r/g/b> : gamma value in hex\n"
};
static void lcd_tcon_multi_lut_print(void)
{
struct tcon_mem_map_table_s *mm_table = get_lcd_tcon_mm_table();
struct tcon_data_multi_s *data_multi;
struct tcon_data_list_s *data_list;
int i, j;
if (!mm_table->data_multi || mm_table->data_multi_cnt == 0) {
LCDERR("tcon data_multi is null\n");
return;
}
LCDPR("tcon multi_update: %d\n", mm_table->multi_lut_update);
for (i = 0; i < mm_table->data_multi_cnt; i++) {
data_multi = &mm_table->data_multi[i];
LCDPR("data_multi[%d]:\n"
" type: 0x%x\n"
" list_cnt: %d\n"
" bypass_flag: %d\n",
i, data_multi->block_type, data_multi->list_cnt,
data_multi->bypass_flag);
if (data_multi->list_cur) {
data_list = data_multi->list_cur;
pr_info("data_multi[%d] current:\n"
" sel_id: %d\n"
" sel_name: %s\n"
" range: %d, %d\n"
" ctrl_data_cnt: %d\n",
i, data_list->id,
data_list->block_name,
data_list->min,
data_list->max,
data_list->ctrl_data_cnt);
if (data_list->ctrl_data_cnt) {
if (data_list->ctrl_data) {
pr_info(" ctrl_data:\n");
for (j = 0; j < data_list->ctrl_data_cnt; j++) {
pr_info(" [%d]: %d\n",
j, data_list->ctrl_data[j]);
}
} else {
pr_info(" ctrl_data is NULL\n");
}
}
} else {
pr_info("data_multi[%d] current: NULL\n", i);
}
pr_info("data_multi[%d] list:\n", i);
data_list = data_multi->list_header;
while (data_list) {
pr_info(" block[%d]: %s, range: %d,%d, ctrl_data_cnt:%d, vaddr=0x%px\n",
data_list->id,
data_list->block_name,
data_list->min,
data_list->max,
data_list->ctrl_data_cnt,
data_list->block_vaddr);
data_list = data_list->next;
}
pr_info("\n");
}
}
int lcd_tcon_axi_mem_print(struct tcon_rmem_s *tcon_rmem, char *buf, int offset)
{
int len = 0, n, i;
if (!tcon_rmem || !tcon_rmem->axi_rmem)
return 0;
if (tcon_rmem->secure_axi_rmem.sec_protect) {
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n, "axi secure mem paddr: 0x%lx, size:0x%x\n",
(unsigned long)tcon_rmem->secure_axi_rmem.mem_paddr,
tcon_rmem->secure_axi_rmem.mem_size);
}
for (i = 0; i < tcon_rmem->axi_bank; i++) {
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"axi_mem[%d] paddr: 0x%lx\n"
"axi_mem[%d] size: 0x%x\n",
i, (unsigned long)tcon_rmem->axi_rmem[i].mem_paddr,
i, tcon_rmem->axi_rmem[i].mem_size);
}
return len;
}
static int lcd_tcon_mm_table_v0_print(struct tcon_mem_map_table_s *mm_table,
struct tcon_rmem_s *tcon_rmem, char *buf, int offset)
{
int len = 0, n;
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"vac_mem\n"
" paddr: 0x%lx\n"
" vaddr: 0x%p\n"
" size: 0x%x\n"
"demura_set_mem\n"
" paddr: 0x%lx\n"
" vaddr: 0x%p\n"
" size: 0x%x\n"
"demura_lut_mem\n"
" paddr: 0x%lx\n"
" vaddr: 0x%p\n"
" size: 0x%x\n"
"acc_lut_mem\n"
" paddr: 0x%lx\n"
" vaddr: 0x%p\n"
" size: 0x%x\n\n",
(unsigned long)tcon_rmem->vac_rmem.mem_paddr,
tcon_rmem->vac_rmem.mem_vaddr,
tcon_rmem->vac_rmem.mem_size,
(unsigned long)tcon_rmem->demura_set_rmem.mem_paddr,
tcon_rmem->demura_set_rmem.mem_vaddr,
tcon_rmem->demura_set_rmem.mem_size,
(unsigned long)tcon_rmem->demura_lut_rmem.mem_paddr,
tcon_rmem->demura_lut_rmem.mem_vaddr,
tcon_rmem->demura_lut_rmem.mem_size,
(unsigned long)tcon_rmem->acc_lut_rmem.mem_paddr,
tcon_rmem->acc_lut_rmem.mem_vaddr,
tcon_rmem->acc_lut_rmem.mem_size);
return len;
}
static int lcd_tcon_mm_table_v1_print(struct tcon_mem_map_table_s *mm_table,
struct tcon_rmem_s *tcon_rmem, char *buf, int offset)
{
unsigned char *mem_vaddr;
struct lcd_tcon_data_block_header_s *bin_header;
struct tcon_data_list_s *cur_list;
int len = 0, n, i;
if (mm_table->data_mem_vaddr && mm_table->data_size) {
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"data_mem block_cnt: %d\n"
"data_mem list:\n",
mm_table->block_cnt);
for (i = 0; i < mm_table->block_cnt; i++) {
mem_vaddr = mm_table->data_mem_vaddr[i];
n = lcd_debug_info_len(len + offset);
if (mem_vaddr) {
bin_header = (struct lcd_tcon_data_block_header_s *)mem_vaddr;
len += snprintf((buf + len), n,
" [%d]: vaddr: 0x%px, size: 0x%x, %s(0x%x)\n",
i, mem_vaddr,
mm_table->data_size[i],
bin_header->name, bin_header->block_type);
} else {
len += snprintf((buf + len), n,
" [%d]: vaddr: NULL, size: 0\n", i);
}
}
}
if (mm_table->data_multi_cnt > 0 && mm_table->data_multi) {
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"tcon multi_update: %d\n",
mm_table->multi_lut_update);
for (i = 0; i < mm_table->data_multi_cnt; i++) {
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"data_multi[%d] current (bypass:%d):\n",
i, mm_table->data_multi[i].bypass_flag);
if (!mm_table->data_multi[i].list_cur) {
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n, " NULL\n");
} else {
cur_list = mm_table->data_multi[i].list_cur;
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
" type: 0x%x\n"
" list_cnt: %d\n"
" sel_id: %d\n"
" sel_name: %s\n"
" sel_range: %d,%d\n",
mm_table->data_multi[i].block_type,
mm_table->data_multi[i].list_cnt,
cur_list->id, cur_list->block_name,
cur_list->min, cur_list->max);
}
}
}
return len;
}
int lcd_tcon_info_print(struct aml_lcd_drv_s *pdrv, char *buf, int offset)
{
struct tcon_mem_map_table_s *mm_table = get_lcd_tcon_mm_table();
struct tcon_rmem_s *tcon_rmem = get_lcd_tcon_rmem();
struct lcd_tcon_local_cfg_s *local_cfg = get_lcd_tcon_local_cfg();
struct lcd_tcon_config_s *tcon_conf = get_lcd_tcon_config();
unsigned int size, file_size, cnt, m, sec_protect, sec_handle, *data;
unsigned char *mem_vaddr;
char *str;
int len = 0, n, i, ret;
ret = lcd_tcon_valid_check();
if (ret)
return len;
if (!mm_table || !tcon_rmem || !local_cfg || !tcon_conf)
return len;
lcd_tcon_init_setting_check(pdrv, &pdrv->config.timing.act_timing,
local_cfg->cur_core_reg_table);
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"\ntcon info:\n"
"core_reg_width: %d\n"
"reg_table_len: %d\n"
"tcon_bin_ver: %s\n"
"tcon_rmem_flag: %d\n"
"rsv_mem paddr: 0x%lx\n"
"rsv_mem size: 0x%x\n",
tcon_conf->core_reg_width,
tcon_conf->reg_table_len,
local_cfg->bin_ver,
tcon_rmem->flag,
(unsigned long)tcon_rmem->rsv_mem_paddr,
tcon_rmem->rsv_mem_size);
if (mm_table->bin_path_valid) {
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"bin_path_mem\n"
" paddr: 0x%lx\n"
" vaddr: 0x%px\n"
" size: 0x%x\n",
(unsigned long)tcon_rmem->bin_path_rmem.mem_paddr,
tcon_rmem->bin_path_rmem.mem_vaddr,
tcon_rmem->bin_path_rmem.mem_size);
}
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n, "\n");
if (tcon_rmem->flag) {
len += lcd_tcon_axi_mem_print(tcon_rmem, (buf + len), (len + offset));
if (mm_table->version == 0) {
len += lcd_tcon_mm_table_v0_print(mm_table, tcon_rmem,
(buf + len), (len + offset));
} else if (mm_table->version < 0xff) {
len += lcd_tcon_mm_table_v1_print(mm_table, tcon_rmem,
(buf + len), (len + offset));
}
if (tcon_rmem->bin_path_rmem.mem_vaddr) {
mem_vaddr = tcon_rmem->bin_path_rmem.mem_vaddr;
size = *(unsigned int *)&mem_vaddr[4];
cnt = *(unsigned int *)&mem_vaddr[16];
if (size < (32 + 256 * cnt))
return len;
if (cnt > 32)
return len;
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"\nbin_path rsv_mem\n"
"bin cnt: %d\n"
"data_complete: %d\n"
"bin_path_valid: %d\n",
cnt, mm_table->data_complete, mm_table->bin_path_valid);
for (i = 0; i < cnt; i++) {
m = 32 + 256 * i;
file_size = *(unsigned int *)&mem_vaddr[m];
str = (char *)&mem_vaddr[m + 4];
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"bin[%d]: size: 0x%x, %s\n", i, file_size, str);
}
}
if (tcon_rmem->secure_cfg_rmem.mem_vaddr) {
data = (unsigned int *)tcon_rmem->secure_cfg_rmem.mem_vaddr;
cnt = tcon_rmem->axi_bank;
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"\nsecure_cfg rsv_mem:\n"
" paddr: 0x%lx\n"
" vaddr: 0x%px\n"
" size: 0x%x\n",
(unsigned long)tcon_rmem->secure_cfg_rmem.mem_paddr,
tcon_rmem->secure_cfg_rmem.mem_vaddr,
tcon_rmem->secure_cfg_rmem.mem_size);
for (i = 0; i < cnt; i++) {
m = 2 * i;
sec_protect = *(data + m);
sec_handle = *(data + m + 1);
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
" [%d]: protect: %d, handle: %d\n",
i, sec_protect, sec_handle);
}
}
}
n = lcd_debug_info_len(len + offset);
len += snprintf((buf + len), n,
"\nlut_valid:\n"
"acc: %d\n"
"od: %d\n"
"lod: %d\n"
"vac: %d\n"
"demura: %d\n"
"dither: %d\n",
!!(mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_ACC),
!!(mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_OD),
!!(mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_LOD),
!!(mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_VAC),
!!(mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_DEMURA),
!!(mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_DITHER));
return len;
}
ssize_t lcd_tcon_debug_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sprintf(buf, "%s\n", lcd_debug_tcon_usage_str);
}
struct aml_lcd_drv_s *pdrv = dev_get_drvdata(dev);
static int lcd_tcon_buf_save(char *path, unsigned char *save_buf, unsigned int size)
{
#ifdef CONFIG_AMLOGIC_ENABLE_MEDIA_FILE
struct file *filp = NULL;
loff_t pos = 0;
void *buf = NULL;
if (!save_buf) {
LCDERR("%s: save_buf is null\n", __func__);
return -1;
}
if (size == 0) {
LCDERR("%s: size is zero\n", __func__);
return -1;
}
filp = filp_open(path, O_RDWR | O_CREAT, 0666);
if (IS_ERR(filp)) {
LCDERR("%s: create %s error\n", __func__, path);
return -1;
}
pos = 0;
buf = (void *)save_buf;
vfs_write(filp, buf, size, &pos);
vfs_fsync(filp, 0);
filp_close(filp, NULL);
#endif
return 0;
}
static void lcd_tcon_reg_table_save(char *path, unsigned char *reg_table, unsigned int size)
{
int ret;
ret = lcd_tcon_buf_save(path, reg_table, size);
LCDPR("save tcon reg table to %s finished\n", path);
}
static void lcd_tcon_reg_save(struct aml_lcd_drv_s *pdrv, char *path, unsigned int size)
{
#ifdef CONFIG_AMLOGIC_ENABLE_MEDIA_FILE
struct file *filp = NULL;
loff_t pos = 0;
unsigned char *temp;
void *buf = NULL;
int ret;
filp = filp_open(path, O_RDWR | O_CREAT, 0666);
if (IS_ERR(filp)) {
LCDERR("%s: create %s error\n", __func__, path);
return;
}
temp = kcalloc(size, sizeof(unsigned char), GFP_KERNEL);
if (!temp) {
LCDERR("%s: Not enough memory\n", __func__);
filp_close(filp, NULL);
return;
}
ret = lcd_tcon_core_reg_get(pdrv, temp, size);
if (ret) {
LCDPR("save tcon reg failed\n");
filp_close(filp, NULL);
kfree(temp);
return;
}
pos = 0;
buf = (void *)temp;
vfs_write(filp, buf, size, &pos);
vfs_fsync(filp, 0);
filp_close(filp, NULL);
kfree(temp);
LCDPR("save tcon reg to %s success\n", path);
#endif
}
static void lcd_tcon_axi_rmem_save(unsigned int index, char *path)
{
#ifdef CONFIG_AMLOGIC_ENABLE_MEDIA_FILE
unsigned int mem_size;
struct file *filp = NULL;
loff_t pos = 0;
struct tcon_rmem_s *tcon_rmem = get_lcd_tcon_rmem();
struct lcd_tcon_config_s *tcon_conf = get_lcd_tcon_config();
unsigned long paddr;
unsigned char *vaddr = NULL;
if (!tcon_rmem || !tcon_rmem->axi_rmem) {
pr_info("axi_rmem is NULL\n");
return;
}
if (!tcon_conf)
return;
if (index > tcon_conf->axi_bank) {
pr_info("axi_rmem index %d invalid\n", index);
return;
}
filp = filp_open(path, O_RDWR | O_CREAT, 0666);
if (IS_ERR(filp)) {
pr_info("%s: create %s error\n", __func__, path);
return;
}
pos = 0;
paddr = tcon_rmem->axi_rmem[index].mem_paddr;
mem_size = tcon_rmem->axi_rmem[index].mem_size;
vaddr = lcd_tcon_paddrtovaddr(paddr, mem_size);
if (!vaddr)
goto lcd_tcon_axi_rmem_save_end;
vfs_write(filp, vaddr, mem_size, &pos);
vfs_fsync(filp, 0);
filp_close(filp, NULL);
pr_info("save tcon vac to %s finished\n", path);
return;
lcd_tcon_axi_rmem_save_end:
vfs_fsync(filp, 0);
filp_close(filp, NULL);
pr_info("tcon axi_rmem[%d] mapping failed: 0x%lx\n", index, paddr);
#endif
}
static void lcd_tcon_rmem_save(char *path, unsigned int flag)
{
struct lcd_tcon_config_s *tcon_conf = get_lcd_tcon_config();
struct tcon_rmem_s *rmem = get_lcd_tcon_rmem();
struct tcon_mem_map_table_s *table = get_lcd_tcon_mm_table();
char *str = NULL;
int ret;
if (!tcon_conf) {
LCDPR("%s: tcon_conf is null\n", __func__);
return;
}
if (!rmem) {
LCDPR("%s: tcon_rmem is null\n", __func__);
return;
}
if (!table) {
LCDPR("%s: tcon_mm_table is null\n", __func__);
return;
}
str = kcalloc(512, sizeof(char), GFP_KERNEL);
if (!str)
return;
switch (flag) {
case 0: /* bin path */
if (rmem->bin_path_rmem.mem_vaddr) {
sprintf(str, "%s.bin", path);
ret = lcd_tcon_buf_save(str, rmem->bin_path_rmem.mem_vaddr,
rmem->bin_path_rmem.mem_size);
if (ret == 0)
LCDPR("save tcon bin_path to %s finished\n", str);
} else {
pr_info("bin_path invalid\n");
}
break;
case 1: /* vac */
if (table->valid_flag & LCD_TCON_DATA_VALID_VAC) {
sprintf(str, "%s.bin", path);
ret = lcd_tcon_buf_save(str, rmem->vac_rmem.mem_vaddr,
rmem->vac_rmem.mem_size);
if (ret == 0)
LCDPR("save tcon vac to %s finished\n", str);
} else {
pr_info("vac invalid\n");
}
break;
case 2: /* demura */
if (table->valid_flag & LCD_TCON_DATA_VALID_DEMURA) {
sprintf(str, "%s_set.bin", path);
ret = lcd_tcon_buf_save(str, rmem->demura_set_rmem.mem_vaddr,
rmem->demura_set_rmem.mem_size);
if (ret == 0)
LCDPR("save tcon demura_set to %s finished\n", str);
sprintf(str, "%s_lut.bin", path);
ret = lcd_tcon_buf_save(str, rmem->demura_lut_rmem.mem_vaddr,
rmem->demura_lut_rmem.mem_size);
if (ret == 0)
LCDPR("save tcon demura_lut to %s finished\n", str);
} else {
pr_info("demura invalid\n");
}
break;
case 3: /* acc */
if (table->valid_flag & LCD_TCON_DATA_VALID_ACC) {
sprintf(str, "%s.bin", path);
ret = lcd_tcon_buf_save(str, rmem->acc_lut_rmem.mem_vaddr,
rmem->acc_lut_rmem.mem_size);
if (ret == 0)
LCDPR("save tcon acc_lut to %s finished\n", str);
} else {
pr_info("acc invalid\n");
}
break;
default:
break;
}
kfree(str);
}
static void lcd_tcon_data_save(unsigned int index, char *path)
{
struct tcon_mem_map_table_s *table = get_lcd_tcon_mm_table();
struct lcd_tcon_data_block_header_s *block_header;
char *str = NULL;
int ret, i;
if (!table) {
LCDPR("%s: tcon_mm_table is null\n", __func__);
return;
}
if (table->version == 0) {
LCDPR("%s: tcon_data invalid\n", __func__);
return;
}
str = kcalloc(512, sizeof(char), GFP_KERNEL);
if (!str)
return;
if (index == 0xff) {
LCDPR("data_mem_block_cnt: %d\n", table->block_cnt);
for (i = 0; i < table->block_cnt; i++) {
if ((table->block_bit_flag & (1 << i)) == 0) {
LCDERR("%s: index %d is not ready\n", __func__, i);
continue;
}
if (!table->data_mem_vaddr[i]) {
LCDERR("%s: data_mem_vaddr[%d] is null\n",
__func__, i);
continue;
}
sprintf(str, "%s_%d.bin", path, i);
block_header = (struct lcd_tcon_data_block_header_s *)
table->data_mem_vaddr[i];
ret = lcd_tcon_buf_save(str, table->data_mem_vaddr[i],
block_header->block_size);
if (ret == 0)
LCDPR("save tcon_data to %s finish\n", str);
}
} else {
if (index >= table->block_cnt) {
LCDERR("%s: index %d invalid\n", __func__, index);
goto lcd_tcon_data_save_exit;
}
if ((table->block_bit_flag & (1 << index)) == 0) {
LCDERR("%s: index %d is not ready\n", __func__, index);
goto lcd_tcon_data_save_exit;
}
if (!table->data_mem_vaddr[index]) {
LCDERR("%s: data_mem_vaddr[%d] is null\n",
__func__, index);
goto lcd_tcon_data_save_exit;
}
sprintf(str, "%s_%d.bin", path, index);
block_header =
(struct lcd_tcon_data_block_header_s *)table->data_mem_vaddr[index];
ret = lcd_tcon_buf_save(str, table->data_mem_vaddr[index],
block_header->block_size);
if (ret == 0)
LCDPR("save tcon_data to %s finish\n", str);
}
lcd_tcon_data_save_exit:
kfree(str);
}
static void lcd_tcon_reg_table_load(char *path, unsigned char *reg_table, unsigned int table_size)
{
#ifdef CONFIG_AMLOGIC_ENABLE_MEDIA_FILE
unsigned int size = 0;
struct file *filp = NULL;
loff_t pos = 0;
filp = filp_open(path, O_RDONLY, 0);
if (IS_ERR_OR_NULL(filp)) {
pr_info("read %s error or filp is NULL.\n", path);
return;
}
size = vfs_read(filp, reg_table, table_size, &pos);
if (size < table_size) {
pr_info("%s read size %u < %u error.\n",
__func__, size, table_size);
return;
}
vfs_fsync(filp, 0);
filp_close(filp, NULL);
pr_info("load bin file path: %s finish\n", path);
#endif
}
static void lcd_tcon_reg_setting_load(struct aml_lcd_drv_s *pdrv, char *path)
{
#ifdef CONFIG_AMLOGIC_ENABLE_MEDIA_FILE
unsigned int size = 0, table_size = 0, len = 0;
char *reg_table;
struct file *filp = NULL;
loff_t pos = 0;
/*struct kstat stat;*/
unsigned int i, n;
char *ps, *token;
char str[4] = {',', ' ', '\n', '\0'};
unsigned int temp[2];
/*vfs_stat(path, &stat);
*table_size = stat.size;
*/
filp = filp_open(path, O_RDONLY, 0);
if (IS_ERR_OR_NULL(filp)) {
pr_info("read %s error or filp is NULL.\n", path);
return;
}
table_size = filp->f_inode->i_size;
reg_table = kzalloc((table_size + 2), GFP_KERNEL);
if (!reg_table) {
filp_close(filp, NULL);
return;
}
size = vfs_read(filp, reg_table, table_size, &pos);
if (size < table_size) {
pr_info("%s read size %u < %u error.\n",
__func__, size, table_size);
filp_close(filp, NULL);
kfree(reg_table);
return;
}
vfs_fsync(filp, 0);
filp_close(filp, NULL);
ps = reg_table;
len = 0;
i = 0;
n = 0;
while (1) {
if (len >= table_size)
break;
if (!ps)
break;
token = strsep(&ps, str);
if (!token)
break;
if (*token == '\0') {
len++;
continue;
}
if (kstrtouint(token, 16, &temp[i % 2]) < 0) {
kfree(reg_table);
return;
}
if ((i % 2) == 1) {
if (lcd_debug_print_flag & LCD_DBG_PR_TEST)
pr_info("write tcon reg 0x%04x = 0x%08x\n", temp[0], temp[1]);
lcd_tcon_reg_write(pdrv, temp[0], temp[1]);
n++;
}
len += (strlen(token) + 1);
i++;
}
pr_info("load setting file path: %s finish, total line %d\n", path, n);
kfree(reg_table);
#endif
}
static void lcd_tcon_axi_rmem_load(unsigned int index, char *path)
{
#ifdef CONFIG_AMLOGIC_ENABLE_MEDIA_FILE
unsigned int size = 0, mem_size;
struct file *filp = NULL;
loff_t pos = 0;
unsigned char *buf;
struct tcon_rmem_s *tcon_rmem = get_lcd_tcon_rmem();
struct lcd_tcon_config_s *tcon_conf = get_lcd_tcon_config();
if (!tcon_rmem || !tcon_rmem->axi_rmem) {
pr_info("axi_rmem is NULL\n");
return;
}
if (!tcon_conf)
return;
if (index > tcon_conf->axi_bank) {
pr_info("axi_rmem index %d invalid\n", index);
return;
}
mem_size = tcon_rmem->axi_rmem[index].mem_size;
buf = kcalloc(mem_size, sizeof(char), GFP_KERNEL);
if (!buf)
return;
filp = filp_open(path, O_RDONLY, 0);
if (IS_ERR_OR_NULL(filp)) {
pr_info("read %s error or filp is NULL.\n", path);
kfree(buf);
return;
}
size = vfs_read(filp, buf, mem_size, &pos);
pr_info("%s read size %u\n", __func__, size);
vfs_fsync(filp, 0);
filp_close(filp, NULL);
lcd_tcon_axi_rmem_lut_load(1, buf, size);
kfree(buf);
pr_info("load bin file path: %s finish\n", path);
#endif
}
static int lcd_tcon_reg_table_check(unsigned char *table, unsigned int size)
{
if (size == 0)
return -1;
if (!table)
return -1;
return 0;
return lcd_tcon_info_print(pdrv, buf, 0);
}
ssize_t lcd_tcon_debug_store(struct device *dev, struct device_attribute *attr,
@@ -553,11 +393,6 @@ ssize_t lcd_tcon_debug_store(struct device *dev, struct device_attribute *attr,
unsigned char *table = NULL;
int ret = -1;
if (mm_table) {
size = mm_table->core_reg_table_size;
table = mm_table->core_reg_table;
}
if (!buf)
return count;
buf_orig = kstrdup(buf, GFP_KERNEL);
@@ -700,7 +535,13 @@ ssize_t lcd_tcon_debug_store(struct device *dev, struct device_attribute *attr,
}
}
} else if (strcmp(parm[0], "table") == 0) {
if (lcd_tcon_reg_table_check(table, size))
if (!mm_table)
goto lcd_tcon_debug_store_end;
table = mm_table->core_reg_table;
size = mm_table->core_reg_table_size;
if (!table)
goto lcd_tcon_debug_store_end;
if (size == 0)
goto lcd_tcon_debug_store_end;
if (!parm[1]) {
lcd_tcon_reg_table_print();
@@ -747,22 +588,13 @@ ssize_t lcd_tcon_debug_store(struct device *dev, struct device_attribute *attr,
}
} else if (strcmp(parm[1], "update") == 0) {
lcd_tcon_core_update(pdrv);
} else if (strcmp(parm[1], "load") == 0) {
if (!parm[2]) {
pr_info("invalid load path\n");
goto lcd_tcon_debug_store_err;
}
lcd_tcon_reg_table_load(parm[2], table, size);
} else {
goto lcd_tcon_debug_store_err;
}
} else if (strcmp(parm[0], "od") == 0) { /* over drive */
if (!parm[1]) {
temp = lcd_tcon_od_get(pdrv);
if (temp)
LCDPR("tcon od is enabled: %d\n", temp);
else
LCDPR("tcon od is disabled: %d\n", temp);
LCDPR("tcon od is %s: %d\n", temp ? "enabled" : "disabled", temp);
} else {
ret = kstrtouint(parm[1], 10, &temp);
if (ret)
@@ -775,6 +607,8 @@ ssize_t lcd_tcon_debug_store(struct device *dev, struct device_attribute *attr,
} else if (strcmp(parm[0], "multi_lut") == 0) {
lcd_tcon_multi_lut_print();
} else if (strcmp(parm[0], "multi_update") == 0) {
if (!mm_table)
goto lcd_tcon_debug_store_end;
if (!parm[1])
goto lcd_tcon_debug_store_err;
ret = kstrtouint(parm[1], 10, &temp);
@@ -783,6 +617,8 @@ ssize_t lcd_tcon_debug_store(struct device *dev, struct device_attribute *attr,
mm_table->multi_lut_update = temp;
LCDPR("tcon multi_update: %d\n", temp);
} else if (strcmp(parm[0], "multi_bypass") == 0) {
if (!mm_table)
goto lcd_tcon_debug_store_end;
if (!parm[2])
goto lcd_tcon_debug_store_err;
ret = kstrtouint(parm[2], 16, &temp);
@@ -792,79 +628,20 @@ ssize_t lcd_tcon_debug_store(struct device *dev, struct device_attribute *attr,
lcd_tcon_data_multi_bypass_set(mm_table, temp, 1);
else //clr
lcd_tcon_data_multi_bypass_set(mm_table, temp, 0);
} else if (strcmp(parm[0], "save") == 0) { /* save buf to bin */
if (!parm[2])
goto lcd_tcon_debug_store_err;
if (strcmp(parm[1], "table") == 0) {
if (lcd_tcon_reg_table_check(table, size))
goto lcd_tcon_debug_store_end;
lcd_tcon_reg_table_save(parm[2], table, size);
} else if (strcmp(parm[1], "reg") == 0) {
lcd_tcon_reg_save(pdrv, parm[2], size);
} else if (strcmp(parm[1], "axi") == 0) {
if (!parm[3])
goto lcd_tcon_debug_store_err;
ret = kstrtouint(parm[2], 10, &temp);
if (ret)
goto lcd_tcon_debug_store_err;
/* parm[2]: axi index */
/* parm[3]: save path */
lcd_tcon_axi_rmem_save(temp, parm[3]);
} else if (strcmp(parm[1], "path") == 0) {
lcd_tcon_rmem_save(parm[2], 0);
} else if (strcmp(parm[1], "vac") == 0) {
lcd_tcon_rmem_save(parm[2], 1);
} else if (strcmp(parm[1], "demura") == 0) {
lcd_tcon_rmem_save(parm[2], 2);
} else if (strcmp(parm[1], "acc") == 0) {
lcd_tcon_rmem_save(parm[2], 3);
} else if (strcmp(parm[1], "data") == 0) {
if (!parm[3])
goto lcd_tcon_debug_store_err;
ret = kstrtouint(parm[2], 10, &temp);
if (ret)
goto lcd_tcon_debug_store_err;
/* parm[2]: tcon data index */
/* parm[3]: save path */
lcd_tcon_data_save(temp, parm[3]);
} else {
goto lcd_tcon_debug_store_err;
}
} else if (strcmp(parm[0], "tee") == 0) {
if (!parm[1])
goto lcd_tcon_debug_store_err;
#if IS_ENABLED(CONFIG_AMLOGIC_TEE)
if (strcmp(parm[1], "status") == 0) {
if (strcmp(parm[1], "status") == 0)
lcd_tcon_mem_tee_get_status();
} else if (strcmp(parm[1], "off") == 0) {
else if (strcmp(parm[1], "off") == 0)
ret = lcd_tcon_mem_tee_protect(0);
pr_info("%s: tcon tee unprotect ret %d\n", __func__, ret);
} else if (strcmp(parm[1], "on") == 0) {
else if (strcmp(parm[1], "on") == 0)
ret = lcd_tcon_mem_tee_protect(1);
pr_info("%s: tcon tee protect ret %d\n", __func__, ret);
} else {
else
goto lcd_tcon_debug_store_err;
}
#endif
} else if (strcmp(parm[0], "load") == 0) {
if (!parm[2])
goto lcd_tcon_debug_store_err;
if (strcmp(parm[1], "axi") == 0) {
if (!parm[3])
goto lcd_tcon_debug_store_err;
ret = kstrtouint(parm[2], 10, &temp);
if (ret)
goto lcd_tcon_debug_store_err;
lcd_tcon_axi_rmem_load(temp, parm[3]);
} else if (strcmp(parm[1], "table") == 0) {
lcd_tcon_reg_table_load(parm[2], table, size);
} else if (strcmp(parm[1], "setting") == 0) {
lcd_tcon_reg_setting_load(pdrv, parm[2]);
} else {
goto lcd_tcon_debug_store_err;
}
#ifdef TCON_DBG_TIME
} else if (strcmp(parm[0], "isr") == 0) {
if (parm[1]) {
if (strcmp(parm[1], "dbg") == 0) {
@@ -904,6 +681,7 @@ ssize_t lcd_tcon_debug_store(struct device *dev, struct device_attribute *attr,
(lcd_debug_print_flag & LCD_DBG_PR_TEST) ? 1 : 0);
if (lcd_debug_print_flag & LCD_DBG_PR_TEST)
lcd_tcon_dbg_trace_print(0);
#endif
} else {
goto lcd_tcon_debug_store_err;
}
@@ -1710,7 +1488,7 @@ void lcd_tcon_debug_file_add(struct aml_lcd_drv_s *pdrv, struct lcd_tcon_local_c
for (i = 0; i < ARRAY_SIZE(lcd_tcon_debug_attrs); i++) {
if (device_create_file(local_cfg->dev, &lcd_tcon_debug_attrs[i])) {
LCDERR("tcon: create tcon debug attribute %s fail\n",
LCDERR("tcon: create attribute %s fail\n",
lcd_tcon_debug_attrs[i].attr.name);
goto err3;
}
drivers/media/vout/lcd/lcd_tcon_fw_param.c
+6 -6
View File
@@ -307,17 +307,17 @@ void lcd_tcon_fw_prepare(struct aml_lcd_drv_s *pdrv, struct lcd_tcon_config_s *t
if (pdrv->status & LCD_STATUS_IF_ON)
lcd_tcon_fw.tcon_state |= TCON_FW_STATE_TCON_EN;
if (mm_table->valid_flag & LCD_TCON_DATA_VALID_VAC)
if (mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_VAC)
lcd_tcon_fw.tcon_state |= TCON_FW_STATE_VAC_VALID;
if (mm_table->valid_flag & LCD_TCON_DATA_VALID_DEMURA)
if (mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_DEMURA)
lcd_tcon_fw.tcon_state |= TCON_FW_STATE_DEMURA_VALID;
if (mm_table->valid_flag & LCD_TCON_DATA_VALID_ACC)
if (mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_ACC)
lcd_tcon_fw.tcon_state |= TCON_FW_STATE_ACC_VALID;
if (mm_table->valid_flag & LCD_TCON_DATA_VALID_DITHER)
if (mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_DITHER)
lcd_tcon_fw.tcon_state |= TCON_FW_STATE_DITHER_VALID;
if (mm_table->valid_flag & LCD_TCON_DATA_VALID_OD)
if (mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_OD)
lcd_tcon_fw.tcon_state |= TCON_FW_STATE_OD_VALID;
if (mm_table->valid_flag & LCD_TCON_DATA_VALID_LOD)
if (mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_LOD)
lcd_tcon_fw.tcon_state |= TCON_FW_STATE_LOD_VALID;
lcd_tcon_fw_base_timing_update(pdrv);
drivers/media/vout/lcd/lcd_tcon_hw.c
+30 -73
View File
@@ -157,10 +157,8 @@ static void lcd_tcon_core_reg_pre_od(struct lcd_tcon_config_s *tcon_conf,
unsigned int *table32;
unsigned int reg, bit, en = 0;
if (!mm_table || !mm_table->core_reg_table) {
LCDERR("%s: table is NULL\n", __func__);
if (!mm_table || !mm_table->core_reg_table)
return;
}
if (tcon_conf->reg_core_od == REG_LCD_TCON_MAX)
return;
@@ -181,8 +179,7 @@ static void lcd_tcon_core_reg_pre_od(struct lcd_tcon_config_s *tcon_conf,
}
if (en == 0) {
table8[reg] &= ~(1 << bit);
LCDPR("%s: invalid buf, disable od function\n",
__func__);
LCDPR("%s: invalid buf, disable od\n", __func__);
}
} else {
table32 = (unsigned int *)mm_table->core_reg_table;
@@ -198,20 +195,18 @@ static void lcd_tcon_core_reg_pre_od(struct lcd_tcon_config_s *tcon_conf,
}
if (en == 0) {
table32[reg] &= ~(1 << bit);
LCDPR("%s: invalid buf, disable od function\n",
__func__);
LCDPR("%s: invalid buf, disable od\n", __func__);
}
}
}
void lcd_tcon_init_table_pre_proc(unsigned char *table)
{
struct lcd_tcon_config_s *tcon_conf = get_lcd_tcon_config();
struct tcon_rmem_s *tcon_rmem = get_lcd_tcon_rmem();
unsigned int reg = 0, paddr, i;
unsigned int *table32;
if (!table || !tcon_conf || !tcon_rmem)
if (!table || !tcon_rmem)
return;
table32 = (unsigned int *)table;
@@ -224,11 +219,11 @@ void lcd_tcon_init_table_pre_proc(unsigned char *table)
table32[0x1a3] &= ~(1 << 31);
//update axi paddr
if (tcon_rmem->flag == 0 || !tcon_rmem->axi_rmem || !tcon_conf->axi_reg) {
if (tcon_rmem->flag == 0 || !tcon_rmem->axi_rmem || !tcon_rmem->axi_reg) {
LCDPR("%s: invalid axi_rmem\n", __func__);
} else {
for (i = 0; i < tcon_conf->axi_bank; i++) {
reg = tcon_conf->axi_reg[i];
for (i = 0; i < tcon_rmem->axi_bank; i++) {
reg = tcon_rmem->axi_reg[i];
paddr = tcon_rmem->axi_rmem[i].mem_paddr;
table32[reg] = paddr;
if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) {
@@ -440,12 +435,6 @@ static int lcd_tcon_demura_set_tl1(struct aml_lcd_drv_s *pdrv)
return 0;
}
if (lcd_debug_print_flag & LCD_DBG_PR_TCON) {
for (i = 0; i < 30; i++)
LCDPR("demura_set data[%d]: 0x%x\n",
i, tcon_rmem->demura_set_rmem.mem_vaddr[i]);
}
/*demura_setting:
* 8byte chk_data + demura_set_data: 161byte
*/
@@ -488,12 +477,6 @@ static int lcd_tcon_demura_lut_tl1(struct aml_lcd_drv_s *pdrv)
lcd_tcon_write_byte(pdrv, 0x184, 0x01);
lcd_tcon_write_byte(pdrv, 0x185, 0x87);
if (lcd_debug_print_flag & LCD_DBG_PR_TCON) {
for (i = 0; i < 30; i++)
LCDPR("demura_lut data[%d]: 0x%x\n",
i, tcon_rmem->demura_lut_rmem.mem_vaddr[i]);
}
/*demura_lut is
*chk_data: 8byte + demura_lut_data: 391053byte
*/
@@ -512,7 +495,7 @@ static int lcd_tcon_demura_lut_tl1(struct aml_lcd_drv_s *pdrv)
lcd_tcon_setb_byte(pdrv, 0x23d, 1, 0, 1);
LCDPR("tcon demura_lut cnt %d\n", data_cnt);
LCDPR("lcd_tcon 0x23d = 0x%02x\n", lcd_tcon_read_byte(pdrv, 0x23d));
//LCDPR("lcd_tcon 0x23d = 0x%02x\n", lcd_tcon_read_byte(pdrv, 0x23d));
return 0;
}
@@ -561,7 +544,6 @@ void lcd_tcon_axi_rmem_lut_load(struct aml_lcd_drv_s *pdrv,
unsigned int index, unsigned char *buf, unsigned int size)
{
struct tcon_rmem_s *tcon_rmem = get_lcd_tcon_rmem();
struct lcd_tcon_config_s *tcon_conf = get_lcd_tcon_config();
unsigned long paddr;
unsigned char *vaddr = NULL;
@@ -569,9 +551,7 @@ void lcd_tcon_axi_rmem_lut_load(struct aml_lcd_drv_s *pdrv,
LCDERR("axi_rmem is NULL\n");
return;
}
if (!tcon_conf)
return;
if (index >= tcon_conf->axi_bank) {
if (index >= tcon_rmem->axi_bank) {
LCDERR("axi_rmem index %d invalid\n", index);
return;
}
@@ -1148,7 +1128,7 @@ static int lcd_tcon_data_set(struct aml_lcd_drv_s *pdrv,
struct lcd_tcon_data_block_header_s *block_header;
unsigned char *data_buf;
unsigned int temp_crc32;
unsigned int i, index, chk_size;
unsigned int i, chk_size;
phys_addr_t paddr = 0;
int ret;
@@ -1157,46 +1137,31 @@ static int lcd_tcon_data_set(struct aml_lcd_drv_s *pdrv,
return -1;
}
if (!mm_table->data_priority) {
LCDERR("%s: data_priority is null\n", __func__);
return -1;
}
for (i = 0; i < mm_table->block_cnt; i++) {
index = mm_table->data_priority[i].index;
if (index >= mm_table->block_cnt) {
LCDERR("%s: data index %d is invalid\n",
__func__, index);
return -1;
}
if (!mm_table->data_mem_vaddr[index]) {
LCDERR("%s: data_mem_vaddr[%d] is null\n",
__func__, index);
if (!mm_table->data_mem_vaddr[i]) {
LCDERR("%s: data_mem_vaddr[%d] is null\n", __func__, i);
continue;
}
data_buf = mm_table->data_mem_vaddr[index];
paddr = mm_table->data_mem_paddr[index];
data_buf = mm_table->data_mem_vaddr[i];
paddr = mm_table->data_mem_paddr[i];
block_header = (struct lcd_tcon_data_block_header_s *)data_buf;
if (block_header->block_size < sizeof(struct lcd_tcon_data_block_header_s)) {
LCDERR("%s: block_size[%d] 0x%x is invalid\n",
__func__, index, block_header->block_size);
LCDERR("%s: block[%d] size 0x%x is invalid\n",
__func__, i, block_header->block_size);
continue;
}
chk_size = block_header->block_size - 4;
temp_crc32 = cal_crc32(0, &data_buf[4], chk_size);
if (temp_crc32 != block_header->crc32) {
LCDERR("%s: block %d, %s data crc error\n",
__func__, mm_table->data_priority[i].index,
block_header->name);
LCDERR("%s: block[%d] %s: data crc error\n",
__func__, i, block_header->name);
continue;
}
if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) {
LCDPR
("%s: block %d, %s, priority %d: size=0x%x, type=0x%02x, ctrl=0x%x\n",
__func__, mm_table->data_priority[i].index,
LCDPR("%s: block[%d] %s: size=0x%x, type=0x%02x, ctrl=0x%x\n",
__func__, i,
block_header->name,
mm_table->data_priority[i].priority,
block_header->block_size,
block_header->block_type,
block_header->block_ctrl);
@@ -1214,7 +1179,7 @@ static int lcd_tcon_data_set(struct aml_lcd_drv_s *pdrv,
if (!lcd_tcon_mem_od_is_valid()) {
if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
LCDERR("%s: bypass block[%d]: type 0x%x\n",
__func__, index, block_header->block_type);
__func__, i, block_header->block_type);
continue;
}
break;
@@ -1224,7 +1189,7 @@ static int lcd_tcon_data_set(struct aml_lcd_drv_s *pdrv,
if (!lcd_tcon_mem_demura_is_valid()) {
if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
LCDERR("%s: bypass block[%d]: type 0x%x\n",
__func__, index, block_header->block_type);
__func__, i, block_header->block_type);
continue;
}
break;
@@ -1238,7 +1203,7 @@ static int lcd_tcon_data_set(struct aml_lcd_drv_s *pdrv,
ret = lcd_tcon_data_common_parse_set(pdrv, data_buf, paddr, 1);
if (ret == 0) {
lcd_tcon_data_multi_current_update(mm_table,
block_header, index);
block_header, i);
}
}
} else {
@@ -1378,10 +1343,6 @@ int lcd_tcon_enable_tl1(struct aml_lcd_drv_s *pdrv)
return -1;
if (!tcon_conf || !mm_table || !local_cfg)
return -1;
if (mm_table->init_load == 0) {
if (mm_table->tcon_data_flag == 0)
lcd_tcon_bin_load(pdrv);
}
/* step 1: tcon top */
lcd_tcon_top_set_tl1(pdrv);
@@ -1406,20 +1367,20 @@ int lcd_tcon_enable_tl1(struct aml_lcd_drv_s *pdrv)
}
}
if (mm_table->version == 0) {
if (mm_table->valid_flag & LCD_TCON_DATA_VALID_VAC) {
if (mm_table->valid_flag & LCD_TCON_DATA_VALID_DEMURA)
if (mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_VAC) {
if (mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_DEMURA)
flag = 1;
else
flag = 0;
lcd_tcon_vac_set_tl1(pdrv, flag);
}
if (mm_table->valid_flag & LCD_TCON_DATA_VALID_DEMURA) {
if (mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_DEMURA) {
lcd_tcon_demura_set_tl1(pdrv);
lcd_tcon_demura_lut_tl1(pdrv);
}
if (mm_table->valid_flag & LCD_TCON_DATA_VALID_ACC)
if (mm_table->lut_valid_flag & LCD_TCON_DATA_VALID_ACC)
lcd_tcon_acc_lut_tl1(pdrv);
} else {
} else if (mm_table->version < 0xff) {
lcd_tcon_data_set(pdrv, mm_table);
}
@@ -1491,10 +1452,6 @@ int lcd_tcon_enable_t5(struct aml_lcd_drv_s *pdrv)
return -1;
if (!tcon_conf || !mm_table || !local_cfg)
return -1;
if (mm_table->init_load == 0) {
if (mm_table->tcon_data_flag == 0)
lcd_tcon_bin_load(pdrv);
}
//don't disable encl for system continuous vsync,
// just disable tcon pre_proc_clk in tcon bin
@@ -1513,7 +1470,7 @@ int lcd_tcon_enable_t5(struct aml_lcd_drv_s *pdrv)
}
/* step 3: tcon data set */
if (mm_table->version)
if (mm_table->version > 0 && mm_table->version < 0xff)
lcd_tcon_data_set(pdrv, mm_table);
/* step 4: tcon_top_output_set */
@@ -1583,7 +1540,7 @@ int lcd_tcon_reload_t3(struct aml_lcd_drv_s *pdrv)
//lcd_venc_enable(pdrv, 1);
local_time[1] = sched_clock();
if (mm_table->version)
if (mm_table->version > 0 && mm_table->version < 0xff)
lcd_tcon_data_set(pdrv, mm_table);
lcd_tcon_setb(pdrv, 0x207, 1, 4, 1);//enable pre_proc_clk