diff --git a/drivers/media/vout/lcd/lcd_common.h b/drivers/media/vout/lcd/lcd_common.h index 6e07e943e..de91acb19 100644 --- a/drivers/media/vout/lcd/lcd_common.h +++ b/drivers/media/vout/lcd/lcd_common.h @@ -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); diff --git a/drivers/media/vout/lcd/lcd_debug.c b/drivers/media/vout/lcd/lcd_debug.c index 9dd7c3dc9..c395a704b 100644 --- a/drivers/media/vout/lcd/lcd_debug.c +++ b/drivers/media/vout/lcd/lcd_debug.c @@ -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'}; diff --git a/drivers/media/vout/lcd/lcd_tcon.c b/drivers/media/vout/lcd/lcd_tcon.c index e6b594cfb..84f0d6e4c 100644 --- a/drivers/media/vout/lcd/lcd_tcon.c +++ b/drivers/media/vout/lcd/lcd_tcon.c @@ -57,12 +57,21 @@ static struct tcon_rmem_s tcon_rmem = { .rsv_mem_size = 0, .rsv_mem_paddr = 0, }; -static struct tcon_mem_map_table_s tcon_mm_table; + +static struct tcon_mem_map_table_s tcon_mm_table = { + .version = 0xff, + .block_cnt = 0, + .data_complete = 0, + .bin_path_valid = 0, + + .lut_valid_flag = 0, +}; static struct lcd_tcon_local_cfg_s tcon_local_cfg; static int lcd_tcon_data_multi_remvoe(struct tcon_mem_map_table_s *mm_table); static int lcd_tcon_data_multi_reset(struct tcon_mem_map_table_s *mm_table); +#ifdef TCON_DBG_TIME static unsigned long long *dbg_vsync_time, *dbg_list_trave_time; static unsigned int dbg_vsync_cnt, dbg_list_trave_cnt; static unsigned int dbg_cnt_0, dbg_cnt_1; @@ -192,6 +201,7 @@ void lcd_tcon_dbg_trace_print(unsigned int flag) } kfree(buf); } +#endif /* ********************************** * tcon common function @@ -631,281 +641,6 @@ unsigned int lcd_tcon_table_write(unsigned int addr, unsigned int val) return read_val; } -void lcd_tcon_multi_lut_print(void) -{ - struct tcon_data_multi_s *data_multi; - struct tcon_data_list_s *data_list; - int i, j; - - if (tcon_mm_table.data_multi_cnt == 0) { - LCDPR("tcon data_multi_cnt is 0\n"); - return; - } - if (!tcon_mm_table.data_multi) { - LCDERR("tcon data_multi is null\n"); - return; - } - - LCDPR("tcon multi_update: %d\n", tcon_mm_table.multi_lut_update); - for (i = 0; i < tcon_mm_table.data_multi_cnt; i++) { - data_multi = &tcon_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"); - } -} - -static int lcd_tcon_axi_mem_print(char *buf, int offset) -{ - int len = 0, n, i; - - if (!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 < lcd_tcon_conf->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; -} - -int lcd_tcon_info_print(struct aml_lcd_drv_s *pdrv, char *buf, int offset) -{ - unsigned int size, file_size, cnt, m, sec_protect, sec_handle, *data; - unsigned char *mem_vaddr; - struct tcon_data_list_s *cur_list; - char *str; - int len = 0, n, i, ret; - - ret = lcd_tcon_valid_check(); - if (ret) - return len; - - lcd_tcon_init_setting_check(pdrv, &pdrv->config.timing.act_timing, - tcon_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", - lcd_tcon_conf->core_reg_width, - lcd_tcon_conf->reg_table_len, - tcon_local_cfg.bin_ver, - tcon_rmem.flag, - (unsigned long)tcon_rmem.rsv_mem_paddr, - tcon_rmem.rsv_mem_size); - if (tcon_rmem.bin_path_rmem.mem_size) { - n = lcd_debug_info_len(len + offset); - len += snprintf((buf + len), n, - "bin_path_mem paddr: 0x%lx\n" - "bin_path_mem vaddr: 0x%px\n" - "bin_path_mem 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((buf + len), (len + offset)); - if (tcon_mm_table.version == 0) { - n = lcd_debug_info_len(len + offset); - len += snprintf((buf + len), n, - "vac_mem paddr: 0x%lx\n" - "vac_mem vaddr: 0x%p\n" - "vac_mem size: 0x%x\n" - "demura_set_mem paddr: 0x%lx\n" - "demura_set_mem vaddr: 0x%p\n" - "demura_set_mem size: 0x%x\n" - "demura_lut_mem paddr: 0x%lx\n" - "demura_lut_mem vaddr: 0x%p\n" - "demura_lut_mem size: 0x%x\n" - "acc_lut_mem paddr: 0x%lx\n" - "acc_lut_mem vaddr: 0x%p\n" - "acc_lut_mem 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); - } else { - if (tcon_mm_table.data_mem_vaddr && tcon_mm_table.data_size) { - n = lcd_debug_info_len(len + offset); - len += snprintf((buf + len), n, - "data_mem block_cnt: %d\n", - tcon_mm_table.block_cnt); - for (i = 0; i < tcon_mm_table.block_cnt; i++) { - n = lcd_debug_info_len(len + offset); - len += snprintf((buf + len), n, - "data_mem[%d] vaddr: 0x%px\n" - "data_mem[%d] size: 0x%x\n", - i, tcon_mm_table.data_mem_vaddr[i], - i, tcon_mm_table.data_size[i]); - } - } - if (tcon_mm_table.data_multi_cnt > 0 && tcon_mm_table.data_multi) { - n = lcd_debug_info_len(len + offset); - len += snprintf((buf + len), n, - "tcon multi_update: %d\n", - tcon_mm_table.multi_lut_update); - for (i = 0; i < tcon_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, tcon_mm_table.data_multi[i].bypass_flag); - if (!tcon_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" - " list_cur: NULL\n", - tcon_mm_table.data_multi[i].block_type, - tcon_mm_table.data_multi[i].list_cnt); - } else { - cur_list = tcon_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", - tcon_mm_table.data_multi[i].block_type, - tcon_mm_table.data_multi[i].list_cnt, - cur_list->id, cur_list->block_name, - cur_list->min, cur_list->max); - } - } - } - } - } - - 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 cnt: %d\n" - "init_load: %d\n" - "data_flag: %d\n", - cnt, tcon_mm_table.init_load, - tcon_mm_table.tcon_data_flag); - 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 = lcd_tcon_conf->axi_bank; - n = lcd_debug_info_len(len + offset); - len += snprintf((buf + len), n, - "\nsecure_cfg rsv_mem:\n" - "mem_paddr: 0x%lx\n" - "mem_vaddr: 0x%px\n" - "mem_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, - "\ntcon_status:\n" - "vac_valid: %d\n" - "demura_valid: %d\n" - "acc_valid: %d\n", - ((tcon_mm_table.valid_flag >> LCD_TCON_DATA_VALID_VAC) & 0x1), - ((tcon_mm_table.valid_flag >> LCD_TCON_DATA_VALID_DEMURA) & 0x1), - ((tcon_mm_table.valid_flag >> LCD_TCON_DATA_VALID_ACC) & 0x1)); - return len; -} - int lcd_tcon_core_reg_get(struct aml_lcd_drv_s *pdrv, unsigned char *buf, unsigned int size) { @@ -1083,8 +818,6 @@ int lcd_tcon_enable(struct aml_lcd_drv_s *pdrv) void lcd_tcon_disable(struct aml_lcd_drv_s *pdrv) { struct lcd_tcon_fw_s *tcon_fw = aml_lcd_tcon_get_fw(); - struct lcd_tcon_data_block_header_s *block_header; - unsigned int i; int ret; ret = lcd_tcon_valid_check(); @@ -1096,33 +829,8 @@ void lcd_tcon_disable(struct aml_lcd_drv_s *pdrv) tcon_fw->tcon_state &= ~TCON_FW_STATE_TCON_EN; /* release data*/ - if (tcon_mm_table.version) { - if (tcon_mm_table.init_load == 0) { - tcon_mm_table.valid_flag = 0; - tcon_mm_table.tcon_data_flag = 0; - tcon_mm_table.block_bit_flag = 0; - lcd_tcon_data_multi_remvoe(&tcon_mm_table); - for (i = 0; i < tcon_mm_table.block_cnt; i++) { - if (!tcon_mm_table.data_mem_vaddr[i]) - continue; - block_header = (struct lcd_tcon_data_block_header_s *) - tcon_mm_table.data_mem_vaddr[i]; - - if (!is_block_type_basic_init(block_header->block_type) && - is_block_ctrl_dma(block_header->block_ctrl)) { - dma_free_coherent(&pdrv->pdev->dev, - block_header->block_size, - tcon_mm_table.data_mem_vaddr[i], - tcon_mm_table.data_mem_paddr[i]); - } else { - kfree(tcon_mm_table.data_mem_vaddr[i]); - tcon_mm_table.data_mem_vaddr[i] = NULL; - } - } - } else { - lcd_tcon_data_multi_reset(&tcon_mm_table); - } - } + if (tcon_mm_table.version > 0 && tcon_mm_table.version < 0xff) + lcd_tcon_data_multi_reset(&tcon_mm_table); if (lcd_tcon_conf->tcon_disable) lcd_tcon_conf->tcon_disable(pdrv); @@ -1141,6 +849,7 @@ void lcd_tcon_dbg_check(struct aml_lcd_drv_s *pdrv, struct lcd_detail_timing_s * pr_info("lcd tcon setting check: PASS\n"); } +#ifdef TCON_DBG_TIME static void lcd_tcon_time_sort_save(unsigned long long *table, unsigned long long data) { int i, j; @@ -1154,6 +863,7 @@ static void lcd_tcon_time_sort_save(unsigned long long *table, unsigned long lon } } } +#endif static int lcd_tcon_data_multi_match_policy(struct aml_lcd_drv_s *pdrv, unsigned int frame_rate, struct tcon_data_multi_s *data_multi, struct tcon_data_list_s *data_list) @@ -1651,8 +1361,11 @@ static int lcd_tcon_data_multi_update(struct aml_lcd_drv_s *pdrv, { struct tcon_data_multi_s *data_multi = NULL; struct tcon_data_list_s *temp_list, *match_list; - unsigned int acc_data[2], n = 0, frame_rate, temp; + unsigned int acc_data[2], n = 0, frame_rate; +#ifdef TCON_DBG_TIME unsigned long long local_time[4]; + unsigned int temp; +#endif int i, ret = 0; if (!mm_table || !mm_table->data_multi) @@ -1660,10 +1373,12 @@ static int lcd_tcon_data_multi_update(struct aml_lcd_drv_s *pdrv, if (mm_table->data_multi_cnt == 0) return 0; +#ifdef TCON_DBG_TIME if (lcd_debug_print_flag & LCD_DBG_PR_TEST) { local_time[0] = sched_clock(); lcd_tcon_dbg_list_trave_time_save(local_time[0], 0); } +#endif frame_rate = mm_table->frame_rate; for (i = 0; i < mm_table->data_multi_cnt; i++) { @@ -1684,10 +1399,12 @@ static int lcd_tcon_data_multi_update(struct aml_lcd_drv_s *pdrv, if (ret == 0) //current range, no need update continue; } +#ifdef TCON_DBG_TIME if (lcd_debug_print_flag & LCD_DBG_PR_TEST) { local_time[1] = sched_clock(); lcd_tcon_dbg_list_trave_time_save((local_time[1] - local_time[0]), 1); } +#endif /* step2: traversing list*/ temp_list = data_multi->list_header; @@ -1702,10 +1419,12 @@ static int lcd_tcon_data_multi_update(struct aml_lcd_drv_s *pdrv, } temp_list = temp_list->next; } +#ifdef TCON_DBG_TIME if (lcd_debug_print_flag & LCD_DBG_PR_TEST) { local_time[2] = sched_clock(); lcd_tcon_dbg_list_trave_time_save((local_time[2] - local_time[0]), 2); } +#endif if (!match_list) //no active list, no need update setting continue; @@ -1740,6 +1459,7 @@ static int lcd_tcon_data_multi_update(struct aml_lcd_drv_s *pdrv, } } +#ifdef TCON_DBG_TIME if (lcd_debug_print_flag & LCD_DBG_PR_TEST) { local_time[3] = sched_clock(); temp = (0xf << 12) | (n << 4) | 3; @@ -1747,6 +1467,7 @@ static int lcd_tcon_data_multi_update(struct aml_lcd_drv_s *pdrv, lcd_tcon_time_sort_save(mm_table->list_trave_time, (local_time[3] - local_time[0])); } +#endif return ret; } @@ -1755,19 +1476,24 @@ static int lcd_tcon_data_multi_set(struct aml_lcd_drv_s *pdrv, struct tcon_mem_map_table_s *mm_table) { struct tcon_data_multi_s *data_multi = NULL; +#ifdef TCON_DBG_TIME unsigned long long local_time[4]; - int i, lut_hit = 0, temp, line_cnt, ret = 0; + int line_cnt; +#endif + int i, lut_hit = 0, temp, ret = 0; if (!mm_table || !mm_table->data_multi) return 0; if (mm_table->data_multi_cnt == 0) return 0; +#ifdef TCON_DBG_TIME if (lcd_debug_print_flag & LCD_DBG_PR_TEST) { local_time[0] = sched_clock(); line_cnt = lcd_get_encl_line_cnt(pdrv); lcd_tcon_dbg_vsync_time_save(local_time[0], line_cnt, 0); } +#endif temp = vout_frame_rate_measure(1); //1000 multi if (temp == 0) @@ -1776,18 +1502,22 @@ static int lcd_tcon_data_multi_set(struct aml_lcd_drv_s *pdrv, temp /= 1000; mm_table->frame_rate = temp; +#ifdef TCON_DBG_TIME if (lcd_debug_print_flag & LCD_DBG_PR_TEST) { local_time[1] = sched_clock(); line_cnt = lcd_get_encl_line_cnt(pdrv); lcd_tcon_dbg_vsync_time_save(local_time[1] - local_time[0], line_cnt, 1); } +#endif lcd_tcon_data_multi_update(pdrv, &tcon_mm_table); +#ifdef TCON_DBG_TIME if (lcd_debug_print_flag & LCD_DBG_PR_TEST) { local_time[2] = sched_clock(); line_cnt = lcd_get_encl_line_cnt(pdrv); lcd_tcon_dbg_vsync_time_save(local_time[2] - local_time[0], line_cnt, 2); } +#endif for (i = 0; i < mm_table->data_multi_cnt; i++) { data_multi = &mm_table->data_multi[i]; @@ -1811,6 +1541,7 @@ static int lcd_tcon_data_multi_set(struct aml_lcd_drv_s *pdrv, data_multi->list_cur = data_multi->list_update; data_multi->list_update = NULL; } +#ifdef TCON_DBG_TIME if (lcd_debug_print_flag & LCD_DBG_PR_TEST) { local_time[3] = sched_clock(); line_cnt = lcd_get_encl_line_cnt(pdrv); @@ -1818,6 +1549,7 @@ static int lcd_tcon_data_multi_set(struct aml_lcd_drv_s *pdrv, lcd_tcon_dbg_vsync_time_save(local_time[3] - local_time[0], line_cnt, temp); lcd_tcon_time_sort_save(mm_table->vsync_time, (local_time[3] - local_time[0])); } +#endif return ret; } @@ -1839,7 +1571,7 @@ void lcd_tcon_vsync_isr(struct aml_lcd_drv_s *pdrv) if (lcd_tcon_conf->lut_dma_update) lcd_tcon_conf->lut_dma_update(pdrv); - if (tcon_mm_table.version) { + if (tcon_mm_table.version > 0 && tcon_mm_table.version < 0xff) { if (tcon_mm_table.multi_lut_update) { spin_lock_irqsave(&tcon_local_cfg.multi_list_lock, flags); lcd_tcon_data_multi_set(pdrv, &tcon_mm_table); @@ -2221,7 +1953,7 @@ static void lcd_tcon_data_complete_check(struct aml_lcd_drv_s *pdrv, int index) unsigned char *table = tcon_mm_table.core_reg_table; int i, n = 0; - if (tcon_mm_table.tcon_data_flag) + if (tcon_mm_table.data_complete) return; if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) @@ -2235,14 +1967,14 @@ static void lcd_tcon_data_complete_check(struct aml_lcd_drv_s *pdrv, int index) if (n < tcon_mm_table.block_cnt) return; - tcon_mm_table.tcon_data_flag = 1; - LCDPR("%s: tcon_data_flag: %d\n", __func__, tcon_mm_table.tcon_data_flag); + tcon_mm_table.data_complete = 1; + LCDPR("%s: data_complete: %d\n", __func__, tcon_mm_table.data_complete); /* specially check demura setting */ if (pdrv->data->chip_type == LCD_CHIP_TL1 || pdrv->data->chip_type == LCD_CHIP_TM2) { if (tcon_mm_table.demura_cnt < 2) { - tcon_mm_table.valid_flag &= ~LCD_TCON_DATA_VALID_DEMURA; + tcon_mm_table.lut_valid_flag &= ~LCD_TCON_DATA_VALID_DEMURA; if (table) { /* disable demura */ table[0x178] = 0x38; @@ -2288,23 +2020,15 @@ int lcd_tcon_data_load(struct aml_lcd_drv_s *pdrv, unsigned char *data_buf, int { struct lcd_tcon_data_block_header_s *block_header; struct lcd_tcon_init_block_header_s *init_header; - struct tcon_data_priority_s *data_prio; - unsigned int priority; struct lcd_tcon_config_s *tcon_conf = get_lcd_tcon_config(); struct lcd_detail_timing_s match_timing; unsigned char *core_reg_table; - int j; if (!tcon_mm_table.data_size) { LCDERR("%s: data_size buf error\n", __func__); return -1; } - if (!tcon_mm_table.data_priority) { - LCDERR("%s: data_priority buf error\n", __func__); - return -1; - } - data_prio = tcon_mm_table.data_priority; 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[%d] size 0x%x error\n", @@ -2327,36 +2051,11 @@ int lcd_tcon_data_load(struct aml_lcd_drv_s *pdrv, unsigned char *data_buf, int match_timing.v_active = init_header->v_active; lcd_tcon_init_setting_check(pdrv, &match_timing, core_reg_table); } else { - tcon_mm_table.valid_flag |= block_header->block_flag; + tcon_mm_table.lut_valid_flag |= block_header->block_flag; if (block_header->block_flag == LCD_TCON_DATA_VALID_DEMURA) tcon_mm_table.demura_cnt++; } - /* insertion sort for block data init_priority */ - data_prio[index].index = index; - /*data_prio[i].priority = block_header->init_priority;*/ - /* update init_priority by index */ - priority = index; - data_prio[index].priority = priority; - if (index > 0) { - j = index - 1; - while (j >= 0) { - if (priority > data_prio[j].priority) - break; - if (priority == data_prio[j].priority) { - LCDERR("%s: block %d init_prio same as block %d\n", - __func__, data_prio[index].index, - data_prio[j].index); - return -1; - } - data_prio[j + 1].index = data_prio[j].index; - data_prio[j + 1].priority = data_prio[j].priority; - j--; - } - data_prio[j + 1].index = index; - data_prio[j + 1].priority = priority; - } - tcon_mm_table.data_size[index] = block_header->block_size; /* add data multi list */ @@ -2379,12 +2078,11 @@ int lcd_tcon_data_load(struct aml_lcd_drv_s *pdrv, unsigned char *data_buf, int } if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) { - LCDPR("%s %d: size=0x%x, type=0x%02x, name=%s, init_priority=%d\n", + LCDPR("%s block[%d]: size=0x%x, type=0x%02x, name=%s\n", __func__, index, block_header->block_size, block_header->block_type, - block_header->name, - priority); + block_header->name); } lcd_tcon_data_complete_check(pdrv, index); @@ -2392,146 +2090,53 @@ int lcd_tcon_data_load(struct aml_lcd_drv_s *pdrv, unsigned char *data_buf, int return 0; } -int lcd_tcon_bin_load(struct aml_lcd_drv_s *pdrv) +static int lcd_tcon_reserved_mem_data_load(struct aml_lcd_drv_s *pdrv) { unsigned char *table = tcon_mm_table.core_reg_table; -#ifdef CONFIG_AMLOGIC_ENABLE_MEDIA_FILE - struct file *filp = NULL; - loff_t pos = 0; - struct lcd_tcon_data_block_header_s block_header; - unsigned int header_size = LCD_TCON_DATA_BLOCK_HEADER_SIZE; - char *str; - int i, data_cnt = 0; - unsigned int n = 0, size; -#else - char *str; - int i; - unsigned int n = 0; -#endif int ret; - if (tcon_mm_table.version == 0) { - LCDPR("%s\n", __func__); - if (!table) { - LCDERR("%s: no tcon bin table\n", __func__); - return -1; - } - if (pdrv->data->chip_type == LCD_CHIP_TL1 || - pdrv->data->chip_type == LCD_CHIP_TM2) { - ret = lcd_tcon_vac_load(); - if (ret == 0) - tcon_mm_table.valid_flag |= LCD_TCON_DATA_VALID_VAC; - ret = lcd_tcon_demura_set_load(); - if (ret) { - table[0x178] = 0x38; - table[0x17c] = 0x20; - table[0x181] = 0x00; - table[0x23d] &= ~(1 << 0); - } else { - ret = lcd_tcon_demura_lut_load(); - if (ret) { - table[0x178] = 0x38; - table[0x17c] = 0x20; - table[0x181] = 0x00; - table[0x23d] &= ~(1 << 0); - } else { - tcon_mm_table.valid_flag |= LCD_TCON_DATA_VALID_DEMURA; - } - } - } + if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) + LCDPR("%s: mm_table version: %d\n", __func__, tcon_mm_table.version); - ret = lcd_tcon_acc_lut_load(); - if (ret == 0) - tcon_mm_table.valid_flag |= LCD_TCON_DATA_VALID_ACC; + //only for old chip method, tcon_mm_table.version == 0 + if (pdrv->data->chip_type != LCD_CHIP_TL1 && + pdrv->data->chip_type != LCD_CHIP_TM2) + return 0; + if (tcon_mm_table.version) + return 0; - tcon_mm_table.tcon_data_flag = 1; + if (!table) { + LCDERR("%s: no tcon bin table\n", __func__); + return -1; + } + + ret = lcd_tcon_vac_load(); + if (ret == 0) + tcon_mm_table.lut_valid_flag |= LCD_TCON_DATA_VALID_VAC; + ret = lcd_tcon_demura_set_load(); + if (ret) { + table[0x178] = 0x38; + table[0x17c] = 0x20; + table[0x181] = 0x00; + table[0x23d] &= ~(1 << 0); } else { - if (tcon_mm_table.init_load) //bypass load bin path - return 0; - LCDPR("%s\n", __func__); - if (!tcon_mm_table.data_mem_vaddr) { - LCDERR("%s: data_mem buf error\n", __func__); - return -1; - } - if (!tcon_mm_table.data_size) { - LCDERR("%s: data_size buf error\n", __func__); - return -1; - } - - for (i = 0; i < tcon_mm_table.block_cnt; i++) { - n = 32 + i * 256; - str = (char *)&tcon_rmem.bin_path_rmem.mem_vaddr[n + 4]; -#ifdef CONFIG_AMLOGIC_ENABLE_MEDIA_FILE - filp = filp_open(str, O_RDONLY, 0); - if (IS_ERR(filp)) { - LCDERR("%s: bin[%d]: %s error\n", __func__, i, str); - continue; - } - - pos = 0; /* must reset pos for file read */ - data_cnt = vfs_read(filp, (void *)&block_header, - header_size, &pos); - if (data_cnt != header_size) { - LCDERR("%s: block[%d] header failed, read data_cnt: %d\n", - __func__, i, data_cnt); - goto lcd_tcon_bin_load_next; - } - size = block_header.block_size; - if (size < sizeof(struct lcd_tcon_data_block_header_s)) { - LCDERR("%s: block[%d] size 0x%x error\n", - __func__, i, size); - goto lcd_tcon_bin_load_next; - } - - if (!is_block_type_basic_init(block_header.block_type) && - is_block_ctrl_dma(block_header.block_ctrl)) { - tcon_mm_table.data_mem_vaddr[i] = - lcd_alloc_dma_buffer(pdrv, size, - tcon_mm_table.data_mem_paddr[i]); - } else { - tcon_mm_table.data_mem_vaddr[i] = - kcalloc(size, sizeof(unsigned char), GFP_KERNEL); - tcon_mm_table.data_mem_paddr[i] = 0; - } - if (!tcon_mm_table.data_mem_vaddr[i]) { - LCDERR("%s: Not enough memory\n", __func__); - goto lcd_tcon_bin_load_next; - } - - pos = 0; /* must reset pos for file read */ - data_cnt = vfs_read(filp, (char *)tcon_mm_table.data_mem_vaddr[i], - size, &pos); - if (data_cnt != size) { - LCDERR("%s: block[%d]: read data_cnt: 0x%x, block_size: 0x%x\n", - __func__, i, data_cnt, size); - goto lcd_tcon_bin_load_next; - } - - if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) { - LCDPR("%s: bin[%d]: %s, size: 0x%x -> 0x%x\n", - __func__, i, str, tcon_mm_table.data_size[i], size); - } - ret = lcd_tcon_data_load(pdrv, tcon_mm_table.data_mem_vaddr[i], i); - if (ret) { - if (!is_block_type_basic_init(block_header.block_type) && - is_block_ctrl_dma(block_header.block_ctrl)) { - dma_free_coherent(&pdrv->pdev->dev, - block_header.block_size, - tcon_mm_table.data_mem_vaddr[i], - tcon_mm_table.data_mem_paddr[i]); - } else { - kfree(tcon_mm_table.data_mem_vaddr[i]); - tcon_mm_table.data_mem_vaddr[i] = NULL; - } - } - -lcd_tcon_bin_load_next: - vfs_fsync(filp, 0); - filp_close(filp, NULL); -#endif + ret = lcd_tcon_demura_lut_load(); + if (ret) { + table[0x178] = 0x38; + table[0x17c] = 0x20; + table[0x181] = 0x00; + table[0x23d] &= ~(1 << 0); + } else { + tcon_mm_table.lut_valid_flag |= LCD_TCON_DATA_VALID_DEMURA; } } + ret = lcd_tcon_acc_lut_load(); + if (ret == 0) + tcon_mm_table.lut_valid_flag |= LCD_TCON_DATA_VALID_ACC; + + tcon_mm_table.data_complete = 1; + return 0; } @@ -2581,8 +2186,10 @@ static int lcd_tcon_bin_path_update(unsigned int size) (mem_vaddr[14] << 16) | (mem_vaddr[15] << 24); tcon_mm_table.block_cnt = block_cnt; - tcon_mm_table.init_load = mem_vaddr[20]; - LCDPR("%s: init_load: %d\n", __func__, tcon_mm_table.init_load); + //tcon_mm_table.init_load = mem_vaddr[20]; + //LCDPR("%s: init_load: %d\n", __func__, tcon_mm_table.init_load); + + tcon_mm_table.bin_path_valid = 1; return 0; } @@ -2690,13 +2297,6 @@ static int lcd_tcon_mm_table_config_v1(void) if (!tcon_mm_table.data_mem_vaddr || !tcon_mm_table.data_mem_paddr) return -1; - tcon_mm_table.data_priority = - kcalloc(cnt, sizeof(struct tcon_data_priority_s), GFP_KERNEL); - if (!tcon_mm_table.data_priority) - return -1; - - memset(tcon_mm_table.data_priority, 0xff, cnt * sizeof(struct tcon_data_priority_s)); - tcon_mm_table.data_size = kcalloc(cnt, sizeof(unsigned int), GFP_KERNEL); if (!tcon_mm_table.data_size) return -1; @@ -2754,9 +2354,9 @@ static int lcd_tcon_axi_tbl_check_valid(unsigned int type) } } else { if (type == TCON_AXI_MEM_TYPE_OD) - return (lcd_tcon_conf->axi_bank > 0); + return (tcon_rmem.axi_bank > 0); else if (type == TCON_AXI_MEM_TYPE_DEMURA) - return (lcd_tcon_conf->axi_bank > 1); + return (tcon_rmem.axi_bank > 1); } return 0; @@ -2778,7 +2378,7 @@ static void lcd_tcon_axi_mem_config_tl1(void) unsigned int total_size = 0, temp_size = 0; int i; - for (i = 0; i < lcd_tcon_conf->axi_bank; i++) + for (i = 0; i < tcon_rmem.axi_bank; i++) total_size += size[i]; if (total_size > tcon_rmem.axi_mem_size) { LCDERR("%s: tcon axi_mem size 0x%x is not enough, need 0x%x\n", @@ -2787,11 +2387,11 @@ static void lcd_tcon_axi_mem_config_tl1(void) } tcon_rmem.axi_rmem = - kcalloc(lcd_tcon_conf->axi_bank, sizeof(struct tcon_rmem_config_s), GFP_KERNEL); + kcalloc(tcon_rmem.axi_bank, sizeof(struct tcon_rmem_config_s), GFP_KERNEL); if (!tcon_rmem.axi_rmem) return; - for (i = 0; i < lcd_tcon_conf->axi_bank; i++) { + for (i = 0; i < tcon_rmem.axi_bank; i++) { tcon_rmem.axi_rmem[i].mem_paddr = tcon_rmem.axi_mem_paddr + temp_size; tcon_rmem.axi_rmem[i].mem_vaddr = NULL; @@ -2844,7 +2444,7 @@ void lcd_tcon_mem_tee_get_status(void) return; } - lcd_tcon_axi_mem_print(print_buf, 0); + lcd_tcon_axi_mem_print(&tcon_rmem, print_buf, 0); pr_info("%s\n", print_buf); kfree(print_buf); } @@ -2909,21 +2509,20 @@ static void lcd_tcon_axi_mem_config(void) if (!lcd_tcon_conf->axi_tbl_len || !lcd_tcon_conf->axi_mem_cfg_tbl) return; - tcon_rmem.axi_rmem = kcalloc(lcd_tcon_conf->axi_bank, + tcon_rmem.axi_rmem = kcalloc(tcon_rmem.axi_bank, sizeof(struct tcon_rmem_config_s), GFP_KERNEL); if (!tcon_rmem.axi_rmem) return; - lcd_tcon_conf->axi_reg = kcalloc(lcd_tcon_conf->axi_bank, - sizeof(unsigned int), GFP_KERNEL); - if (!lcd_tcon_conf->axi_reg) { + tcon_rmem.axi_reg = kcalloc(tcon_rmem.axi_bank, sizeof(unsigned int), GFP_KERNEL); + if (!tcon_rmem.axi_reg) { kfree(tcon_rmem.axi_rmem); return; } for (i = 0; i < lcd_tcon_conf->axi_tbl_len; i++) { axi_mem_cfg = &lcd_tcon_conf->axi_mem_cfg_tbl[i]; - lcd_tcon_conf->axi_reg[i] = axi_mem_cfg->axi_reg; + tcon_rmem.axi_reg[i] = axi_mem_cfg->axi_reg; if (!axi_mem_cfg->mem_valid) continue; tcon_rmem.axi_rmem[i].mem_paddr = tcon_rmem.axi_mem_paddr + temp_size; @@ -2955,6 +2554,7 @@ static int lcd_tcon_mem_config(void) if (tcon_rmem.flag == 0) return -1; + tcon_rmem.axi_bank = lcd_tcon_conf->axi_bank; if (lcd_tcon_conf->axi_tbl_len && lcd_tcon_conf->axi_mem_cfg_tbl) { for (i = 0; i < lcd_tcon_conf->axi_tbl_len; i++) { axi_cfg = &lcd_tcon_conf->axi_mem_cfg_tbl[i]; @@ -3189,9 +2789,6 @@ static void lcd_tcon_intr_init(struct aml_lcd_drv_s *pdrv) if (request_irq(tcon_irq, lcd_tcon_isr, IRQF_SHARED, "lcd_tcon", (void *)"lcd_tcon")) { LCDERR("can't request lcd_tcon irq\n"); - } else { - if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) - LCDPR("request lcd_tcon irq successful\n"); } lcd_tcon_write(pdrv, TCON_INTR_MASKN, TCON_INTR_MASKN_VAL); @@ -3223,7 +2820,7 @@ static int lcd_tcon_load_init_data_from_unifykey(struct aml_lcd_drv_s *pdrv) lcd_tcon_load_init_data_err: kfree(tcon_mm_table.core_reg_table); tcon_mm_table.core_reg_table = NULL; - LCDERR("%s: !!!!!!tcon unifykey load error!!!!!!\n", __func__); + LCDERR("%s: tcon unifykey load error!!!\n", __func__); return -1; } @@ -3298,7 +2895,7 @@ static int lcd_tcon_load_init_data_from_unifykey_new(struct aml_lcd_drv_s *pdrv) lcd_tcon_load_init_data_new_err: kfree(buf); - LCDERR("%s: !!!!!!tcon unifykey load error!!!!!!\n", __func__); + LCDERR("%s: tcon unifykey load error!!!\n", __func__); return -1; } @@ -3315,8 +2912,8 @@ static int lcd_tcon_get_config(struct aml_lcd_drv_s *pdrv) lcd_tcon_pdf_init(pdrv); //lcd_swpdf_init(pdrv); - lcd_tcon_bin_load(pdrv); - pdrv->tcon_status = tcon_mm_table.valid_flag; + lcd_tcon_reserved_mem_data_load(pdrv); + pdrv->tcon_status = tcon_mm_table.lut_valid_flag; tcon_mm_table.multi_lut_update = 1; lcd_tcon_intr_init(pdrv); @@ -3411,7 +3008,6 @@ static struct lcd_tcon_config_s tcon_data_tl1 = { .demura_lut_size = 0x00120000, /* 1152k */ .acc_lut_size = 0x00001000, /* 4k */ - .axi_reg = NULL, .tcon_axi_mem_config = lcd_tcon_axi_mem_config_tl1, .tcon_axi_mem_secure = lcd_tcon_axi_mem_secure_tl1, .tcon_init_table_pre_proc = NULL, @@ -3462,7 +3058,6 @@ static struct lcd_tcon_config_s tcon_data_t5 = { .axi_tbl_len = ARRAY_SIZE(axi_mem_cfg_tbl_t5), .axi_mem_cfg_tbl = axi_mem_cfg_tbl_t5, - .axi_reg = NULL, .tcon_axi_mem_secure = lcd_tcon_axi_mem_secure_t3, .tcon_init_table_pre_proc = lcd_tcon_init_table_pre_proc, .tcon_global_reset = lcd_tcon_global_reset_t5, @@ -3508,7 +3103,6 @@ static struct lcd_tcon_config_s tcon_data_t5d = { .axi_tbl_len = ARRAY_SIZE(axi_mem_cfg_tbl_t5d), .axi_mem_cfg_tbl = axi_mem_cfg_tbl_t5d, - .axi_reg = NULL, .tcon_axi_mem_secure = lcd_tcon_axi_mem_secure_t3, .tcon_init_table_pre_proc = lcd_tcon_init_table_pre_proc, .tcon_global_reset = lcd_tcon_global_reset_t5, @@ -3558,7 +3152,6 @@ static struct lcd_tcon_config_s tcon_data_t3 = { .axi_tbl_len = ARRAY_SIZE(axi_mem_cfg_tbl_t5), .axi_mem_cfg_tbl = axi_mem_cfg_tbl_t5, - .axi_reg = NULL, .tcon_axi_mem_secure = lcd_tcon_axi_mem_secure_t3, .tcon_init_table_pre_proc = lcd_tcon_init_table_pre_proc, .tcon_global_reset = lcd_tcon_global_reset_t3, @@ -3608,7 +3201,6 @@ static struct lcd_tcon_config_s tcon_data_t5m = { .axi_tbl_len = ARRAY_SIZE(axi_mem_cfg_tbl_t5), .axi_mem_cfg_tbl = axi_mem_cfg_tbl_t5, - .axi_reg = NULL, .tcon_axi_mem_secure = lcd_tcon_axi_mem_secure_t3, .tcon_init_table_pre_proc = lcd_tcon_init_table_pre_proc, .tcon_global_reset = lcd_tcon_global_reset_t3, @@ -3660,7 +3252,6 @@ static struct lcd_tcon_config_s tcon_data_t5w = { .axi_tbl_len = ARRAY_SIZE(axi_mem_cfg_tbl_t5), .axi_mem_cfg_tbl = axi_mem_cfg_tbl_t5, - .axi_reg = NULL, .tcon_axi_mem_secure = lcd_tcon_axi_mem_secure_t3, .tcon_init_table_pre_proc = lcd_tcon_init_table_pre_proc, .tcon_global_reset = lcd_tcon_global_reset_t5, @@ -3710,7 +3301,6 @@ static struct lcd_tcon_config_s tcon_data_t3x = { .axi_tbl_len = ARRAY_SIZE(axi_mem_cfg_tbl_t3x), .axi_mem_cfg_tbl = (axi_mem_cfg_tbl_t3x), - .axi_reg = NULL, .tcon_axi_mem_secure = lcd_tcon_axi_mem_secure_t3, .tcon_init_table_pre_proc = lcd_tcon_init_table_pre_proc, .tcon_global_reset = lcd_tcon_global_reset_t3x, @@ -3755,7 +3345,6 @@ static struct lcd_tcon_config_s tcon_data_txhd2 = { .axi_tbl_len = ARRAY_SIZE(axi_mem_cfg_tbl_txhd2), .axi_mem_cfg_tbl = axi_mem_cfg_tbl_txhd2, - .axi_reg = NULL, .tcon_axi_mem_secure = lcd_tcon_axi_mem_secure_t3, .tcon_init_table_pre_proc = lcd_tcon_init_table_pre_proc, .tcon_global_reset = lcd_tcon_global_reset_t5, @@ -3832,6 +3421,7 @@ int lcd_tcon_probe(struct aml_lcd_drv_s *pdrv) lcd_tcon_reserved_memory_init(pdrv); lcd_tcon_mem_config(); +#ifdef TCON_DBG_TIME dbg_cnt_0 = 120 * 60 * 7; dbg_vsync_time = kcalloc(dbg_cnt_0, sizeof(unsigned long long), GFP_KERNEL); if (!dbg_vsync_time) @@ -3840,6 +3430,7 @@ int lcd_tcon_probe(struct aml_lcd_drv_s *pdrv) dbg_list_trave_time = kcalloc(dbg_cnt_1, sizeof(unsigned long long), GFP_KERNEL); if (!dbg_list_trave_time) LCDERR("%s: dbg_list_trave_time error\n", __func__); +#endif spin_lock_init(&tcon_local_cfg.multi_list_lock); INIT_DELAYED_WORK(&pdrv->tcon_config_dly_work, lcd_tcon_get_config_work); @@ -3861,10 +3452,10 @@ int lcd_tcon_remove(struct aml_lcd_drv_s *pdrv) kfree(tcon_mm_table.core_reg_table); tcon_mm_table.core_reg_table = NULL; - if (tcon_mm_table.version) { + if (tcon_mm_table.version > 0 && tcon_mm_table.version < 0xff) { tcon_mm_table.data_init = NULL; - tcon_mm_table.valid_flag = 0; - tcon_mm_table.tcon_data_flag = 0; + tcon_mm_table.lut_valid_flag = 0; + tcon_mm_table.data_complete = 0; tcon_mm_table.block_bit_flag = 0; lcd_tcon_data_multi_remvoe(&tcon_mm_table); if (tcon_mm_table.data_mem_vaddr) { @@ -3924,25 +3515,3 @@ int lcd_tcon_remove(struct aml_lcd_drv_s *pdrv) return 0; } - -static int __init tcon_buf_device_init(struct reserved_mem *rmem, struct device *dev) -{ - return 0; -} - -static const struct reserved_mem_ops tcon_buf_ops = { - .device_init = tcon_buf_device_init, -}; - -static int __init tcon_buf_setup(struct reserved_mem *rmem) -{ - tcon_rmem.rsv_mem_paddr = rmem->base; - tcon_rmem.rsv_mem_size = rmem->size; - rmem->ops = &tcon_buf_ops; - LCDPR("tcon: Reserved memory: created buf at 0x%lx, size %ld MiB\n", - (unsigned long)rmem->base, (unsigned long)rmem->size / SZ_1M); - return 0; -} - -RESERVEDMEM_OF_DECLARE(buf, "amlogic, lcd_tcon-memory", tcon_buf_setup); - diff --git a/drivers/media/vout/lcd/lcd_tcon.h b/drivers/media/vout/lcd/lcd_tcon.h index 6e6c3bb3d..3b39df2ac 100644 --- a/drivers/media/vout/lcd/lcd_tcon.h +++ b/drivers/media/vout/lcd/lcd_tcon.h @@ -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); diff --git a/drivers/media/vout/lcd/lcd_tcon_debug.c b/drivers/media/vout/lcd/lcd_tcon_debug.c index c7a1c2b3f..1b389e1f6 100644 --- a/drivers/media/vout/lcd/lcd_tcon_debug.c +++ b/drivers/media/vout/lcd/lcd_tcon_debug.c @@ -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 > tcon ; read tcon byte reg\n" - " echo reg wb > tcon ; write tcon byte reg\n" - " echo reg db > tcon ; dump tcon byte regs\n" - " echo reg r > tcon ; write tcon reg\n" - " echo reg w > tcon ; write tcon reg\n" - " echo reg d > tcon ; dump tcon regs\n" - "\n" - " echo table > tcon ; print tcon reg table\n" - " echo table r > tcon ; read tcon reg table by specified index\n" - " echo table w > tcon ; write tcon reg table by specified index\n" - " echo table d > tcon ; dump tcon reg table\n" - "data format:\n" - " : hex number\n" - " : hex number\n" - " : dec number\n" - "\n" - " echo table update > tcon ; update tcon reg table into tcon system regs\n" - "\n" - " echo od > tcon ; tcon over driver control\n" - "data format:\n" - " : 0=disable, 1=enable\n" - "\n" - " echo save > tcon ; tcon mem save to file\n" - "data format:\n" - " : table, reg, vac, demura, acc\n" - " : save file path\n" - "\n" - " echo gamma > tcon ; tcon gamma pattern\n" - "data format:\n" - " : 12, 10, 8\n" - " : 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; } diff --git a/drivers/media/vout/lcd/lcd_tcon_fw_param.c b/drivers/media/vout/lcd/lcd_tcon_fw_param.c index f9ba17d97..32a416bd7 100644 --- a/drivers/media/vout/lcd/lcd_tcon_fw_param.c +++ b/drivers/media/vout/lcd/lcd_tcon_fw_param.c @@ -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); diff --git a/drivers/media/vout/lcd/lcd_tcon_hw.c b/drivers/media/vout/lcd/lcd_tcon_hw.c index cc7156c9b..51e1269c1 100644 --- a/drivers/media/vout/lcd/lcd_tcon_hw.c +++ b/drivers/media/vout/lcd/lcd_tcon_hw.c @@ -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