1 files changed, 761 insertions, 0 deletions

diff --git a/drivers/video/fbdev/msm/lcd_effect.c b/drivers/video/fbdev/msm/lcd_effect.c
new file mode 100644
index 000000000000..567e33ac750e
--- /dev/null
+++ b/drivers/video/fbdev/msm/lcd_effect.c
@@ -0,0 +1,761 @@
+#include "lcd_effect.h"
+
+extern int is_show_lcd_param;
+extern void show_lcd_param(struct dsi_cmd_desc *cmds, int cmd_cnt);
+#ifdef CONFIG_BACKLIGHT_LM36923
+int lm36923_sunlight_settings (int level);
+#endif
+
+#define TAG "[LCD_EFFECT: ]"
+//#define LCDDEBUG
+#ifdef LCDDEBUG
+#define lcd_effect_info(fmt, ...) printk(TAG fmt, ##__VA_ARGS__);
+#else
+#define lcd_effect_info(fmt, ...) do {} while (0)
+#endif
+
+#ifdef READ_LCD_PARAM
+static int read_lcd_file = 0;
+struct lcd_cmds lcd_txt_cmds;
+
+#define BUFSIZE 3
+#define LENGHT 256
+#define LENGHT_POS	0
+#define TYPE_POS	1
+#define DELAY_POS	2
+#define DATA_POS	3
+#define FILEPATH	"/data/lcd.txt"
+static char data_buf[LENGHT] = {0};
+static char *data_pos[LENGHT];
+
+static int get_data(char *buf)
+{
+	char a, b;
+
+	if (buf[0] >= 'A' && buf[0] <= 'F') {
+		a = buf[0] - 55;
+	} else if (buf[0] >= 'a' && buf[0] <= 'f') {
+		a = buf[0] - 87;
+	} else {
+		a = buf[0] - 48;
+	}
+	if (buf[1] >= 'A' && buf[1] <= 'F') {
+		b = buf[1] - 55;
+	} else if (buf[1] >= 'a' && buf[1] <= 'f') {
+		b = buf[1] - 87;
+	} else {
+		b = buf[1] - 48;
+	}
+	return a * 16 + b;
+}
+static void clear_data_and_mem(void)
+{
+	int i;
+
+	if (lcd_txt_cmds.cnt) {
+		pr_info("Free mem for lcd txt file's cmds buf.\n");
+		for (i = 0; i < lcd_txt_cmds.cnt; i++) {
+			if (data_pos[i])
+				kfree(data_pos[i]);
+		}
+		if (lcd_txt_cmds.cmd)
+			kfree(lcd_txt_cmds.cmd);
+		lcd_txt_cmds.cnt = 0;
+	}
+}
+static int open_lcd_and_get_data(void)
+{
+	struct file *fp;
+	int ret, lenght = 0;
+	int i = 0, j = 0;
+	char buf[BUFSIZE] = {0};
+	char *filepath = FILEPATH;
+	mm_segment_t old_fs;
+
+	lcd_txt_cmds.cnt = 0;
+	//清空BUF
+	for (i = 0; i < LENGHT; i++) {
+		data_buf[i] = 0;
+	}
+	fp = filp_open(filepath, O_RDONLY, 0);
+	if (IS_ERR(fp)) {
+		pr_info("open file failure\n");
+		return -1;
+	} else {
+		pr_info("open file success, begin to read\n");
+		old_fs = get_fs();
+		set_fs(KERNEL_DS);	
+		do {
+			ret = vfs_read(fp, buf, BUFSIZE, &fp->f_pos);
+			if (ret == -1) {
+				pr_info("read file failure\n");
+				goto read_err;
+			}
+			if (ret == BUFSIZE) {
+				lenght++;
+				//buf里留一个位置给lenght
+				data_buf[lenght] = get_data(buf); //数据格式为:长度＋格式 + 延时＋数据,现在长度data_buf[0]为空
+
+				if (buf[2] == '\n') { //标记一行结束
+					if (lenght > LENGHT) { //如果一行的数据超过buf的大小
+						pr_info("data too long !!!!!!!!!!!!!!!\n");
+						goto large_err;
+					}
+
+					//把data_buf[0]赋值为长度
+					data_buf[LENGHT_POS] = lenght + 1;
+					data_pos[lcd_txt_cmds.cnt] = kmalloc(sizeof(char) * data_buf[LENGHT_POS], GFP_KERNEL);
+					if (!data_pos[lcd_txt_cmds.cnt]) {
+						pr_info("kmalloc failure !!!!\n");
+						goto mem_err;
+					}
+
+					memcpy(data_pos[lcd_txt_cmds.cnt], data_buf, data_buf[0]); //把数据拷贝到新分配的空间
+
+					//pr_info("buf[%d] lenght = %d\n", lcd_txt_cmds.cnt, lenght);
+					lcd_txt_cmds.cnt++; //数据的行号＋1
+					lenght = 0;
+				} 
+			}
+		} while (ret != 0);
+		j = 0;
+
+		lcd_txt_cmds.cmd = kmalloc(sizeof(struct dsi_cmd_desc) * lcd_txt_cmds.cnt, GFP_KERNEL);
+		if (!lcd_txt_cmds.cmd) {
+			pr_info("kmalloc failure !!!!\n");
+			goto cmds_err;
+		}
+
+		for (i = 0; i < lcd_txt_cmds.cnt; i++) {
+			lcd_txt_cmds.cmd[i].dchdr.dtype = data_pos[i][TYPE_POS];
+			lcd_txt_cmds.cmd[i].dchdr.last = 1;
+			lcd_txt_cmds.cmd[i].dchdr.vc = 0;
+			lcd_txt_cmds.cmd[i].dchdr.ack = 0;
+			lcd_txt_cmds.cmd[i].dchdr.wait = data_pos[i][DELAY_POS];
+			lcd_txt_cmds.cmd[i].dchdr.dlen = data_pos[i][LENGHT_POS] - DATA_POS;
+			lcd_txt_cmds.cmd[i].payload = &data_pos[i][DATA_POS];
+		}
+
+		filp_close(fp, NULL);
+	}
+	return 0;
+cmds_err:
+large_err:
+read_err:
+mem_err:
+	for (i = 0; i < lcd_txt_cmds.cnt; i++) {
+		kfree(data_pos[i]);
+	}
+	lcd_txt_cmds.cnt = 0;
+	return -1;
+}
+
+
+#endif
+static int is_custom_mode(struct lcd_mode_data *mode_data)
+{
+	return !mode_data->current_mode;
+}
+
+int get_effect_index_by_name(char *name, struct panel_effect_data *lcd_data)
+{
+	int i;
+	struct lcd_effect *effect = lcd_data->effect_data->effect;
+
+	for (i = 0; i < lcd_data->effect_data->supported_effect; i++) {
+		if (!strcmp(name, effect[i].name))
+			return i;
+	}
+	return -EINVAL;
+}
+int get_mode_index_by_name(char *name, struct panel_effect_data *lcd_data)
+{
+	int i;
+	struct lcd_mode *mode= lcd_data->mode_data->mode;
+
+	for (i = 0; i < lcd_data->mode_data->supported_mode; i++) {
+		if (!strcmp(name, mode[i].name))
+			return i;
+	}
+	return -EINVAL;
+}
+static void update_effect_cmds(struct lcd_effect *effect, int level)
+{
+	struct lcd_effect_cmd_data *effect_cmd_data = &effect->effect_cmd_data;
+	struct lcd_effect_cmds *effect_cmd = effect_cmd_data->effect_cmd;
+	int cmd_cnt = effect_cmd_data->cnt;
+	int code_cnt ;
+	int i;
+
+	for (i = 0; i < cmd_cnt; i++) {
+		code_cnt = effect_cmd[i].effect_code.cnt;
+		effect_cmd[i].lcd_cmd.cmd->payload = effect_cmd[i].effect_code.code[level >= code_cnt ? code_cnt -1 : level];
+	}
+}
+
+static void inline update_level(struct lcd_effect *effect, int level)
+{
+	effect->level = level;
+}
+
+static inline void update_mode(struct lcd_mode_data *mode_data, int index)
+{
+	mode_data->current_mode = index;
+}
+
+static inline int get_level(struct lcd_effect *effect)
+{
+	return effect->level;
+}
+
+static inline int get_effect_cmd_cnt(struct lcd_effect *effect)
+{
+	return effect->effect_cmd_data.cnt;
+}
+
+static inline int get_head_cmd_cnt(struct lcd_cmds *head_cmd)
+{
+	return head_cmd->cnt;
+}
+
+static inline struct dsi_cmd_desc *get_head_cmd(struct lcd_cmds *head_cmd)
+{
+	return head_cmd->cmd;
+}
+static inline struct lcd_cmds *get_lcd_cmd(struct lcd_effect_cmds *effect_cmd)
+{
+	return &effect_cmd->lcd_cmd;
+}
+static inline struct lcd_effect_cmds * get_effect_cmd(struct lcd_effect *effect)
+{
+	return effect->effect_cmd_data.effect_cmd;
+}
+
+static inline struct dsi_cmd_desc *get_effect_cmd_desc(struct lcd_effect_cmds *effect_cmd)
+{
+	return effect_cmd->lcd_cmd.cmd;
+}
+static inline struct dsi_cmd_desc * get_mode_cmd(struct lcd_mode *mode)
+{
+	return mode->mode_cmd.cmd;
+}
+static inline int get_mode_cmd_cnt(struct lcd_mode *mode)
+{
+	return mode->mode_cmd.cnt;
+}
+
+static int get_mode_max_cnt(struct lcd_mode_data *mode_data)
+{
+	int i;
+	int temp;
+	int cnt = 0;
+
+	for (i = 0; i < mode_data->supported_mode; i++) {
+		temp = mode_data->mode[i].mode_cmd.cnt;
+		cnt = (cnt > temp) ? cnt : temp;
+		lcd_effect_info("%s cnt = %d temp = %d\n", __func__, cnt, temp);
+	}
+
+	return cnt;
+}
+
+static int get_effect_max_cnt(struct lcd_effect_data *effect_data)
+{
+	int cnt = 0;
+	int temp;
+	int i;
+
+	for (i = 0; i < effect_data->supported_effect; i++) {
+		temp = effect_data->effect[i].effect_cmd_data.cnt;
+		cnt = cnt + temp;
+		lcd_effect_info("%s cnt = %d temp = %d\n", __func__, cnt, temp);
+	}
+
+	return cnt;
+}
+
+static int get_init_code_max_cnt(struct panel_effect_data *panel_data, struct lcd_cmds *save_cmd)
+{
+	int cnt = save_cmd->cnt;
+
+	cnt += get_mode_max_cnt(panel_data->mode_data);
+	cnt += get_effect_max_cnt(panel_data->effect_data);
+	lcd_effect_info("%s cnt: %d\n", __func__, cnt);
+	return cnt;
+}
+
+static int send_lcd_cmds(struct msm_fb_data_type *mfd, struct lcd_cmds *cmds)
+{
+	struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
+	struct dcs_cmd_req cmdreq;
+	struct mdss_panel_data *pdata;
+	struct mdss_panel_info *pinfo;
+
+	int ret;
+
+	pdata = dev_get_platdata(&mfd->pdev->dev);
+	ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata, panel_data);
+	if (mfd->panel_power_state == false) {
+		pr_err("%s: LCD panel have powered off\n", __func__);
+		return -EPERM;
+	}
+	
+	pinfo = &(ctrl_pdata->panel_data.panel_info);
+	if (pinfo->dcs_cmd_by_left) {
+		if (ctrl_pdata->ndx != DSI_CTRL_LEFT)
+			return 1;
+	}
+
+	memset(&cmdreq, 0, sizeof(cmdreq));
+	cmdreq.flags = CMD_REQ_COMMIT | CMD_CLK_CTRL | CMD_REQ_LP_MODE;
+	cmdreq.rlen = 0;
+	cmdreq.cb = NULL;
+	cmdreq.cmds = cmds->cmd;
+	cmdreq.cmds_cnt = cmds->cnt;
+
+	ret = mdss_dsi_cmdlist_put(ctrl_pdata, &cmdreq);
+
+	return ret;
+}
+
+static struct dsi_cmd_desc *copy_init_code(struct panel_effect_data *panel_data, int *cnt)
+{
+	int init_cnt = panel_data->save_cmd.cnt;
+
+	memcpy(panel_data->buf, panel_data->save_cmd.cmd, (init_cnt - CMDS_LAST_CNT) * sizeof (struct dsi_cmd_desc));
+	*cnt += (init_cnt - CMDS_LAST_CNT);
+	lcd_effect_info("%s: line=%d\n", __func__,__LINE__);
+	return (panel_data->buf + (init_cnt - CMDS_LAST_CNT));
+}
+
+static struct dsi_cmd_desc *copy_sleep_out_code(
+		struct panel_effect_data *panel_data, 
+		struct dsi_cmd_desc *buf, 
+		int *cnt)
+{
+	memcpy(buf, panel_data->save_cmd.cmd + panel_data->save_cmd.cnt - CMDS_LAST_CNT, CMDS_LAST_CNT * sizeof (struct dsi_cmd_desc));
+	*cnt += CMDS_LAST_CNT;
+	lcd_effect_info("%s: line=%d\n", __func__,__LINE__);
+	return (buf + CMDS_LAST_CNT);
+}
+static struct dsi_cmd_desc *copy_head_code(struct panel_effect_data *panel_data, struct dsi_cmd_desc *buf, int *cnt)
+{
+	struct lcd_cmds *head_cmds = panel_data->effect_data->head_cmd;
+	int head_cnt = get_head_cmd_cnt(head_cmds); 
+
+	memcpy(buf, head_cmds->cmd, head_cnt * sizeof (struct dsi_cmd_desc));
+	*cnt +=  head_cnt;
+
+	lcd_effect_info("%s: line=%d\n", __func__,__LINE__);
+	return (buf + head_cnt);
+}
+
+static struct dsi_cmd_desc * copy_single_effect_code(
+		struct panel_effect_data *panel_data, 
+		struct dsi_cmd_desc *buf, 
+		int index, 
+		int level,
+		int *cnt)
+{
+	struct lcd_effect_data *effect_data = panel_data->effect_data;
+	struct lcd_effect *effect = &effect_data->effect[index];
+	struct dsi_cmd_desc *temp = buf;
+	struct lcd_effect_cmds *effect_cmd;
+	int cmd_cnt;
+	int i;
+
+	update_effect_cmds(effect, level);
+	cmd_cnt = get_effect_cmd_cnt(effect);
+	effect_cmd = get_effect_cmd(effect);
+	*cnt += cmd_cnt;
+	for (i = 0; i < cmd_cnt; i++)
+		memcpy(temp++, get_effect_cmd_desc(&effect_cmd[i]), sizeof (struct dsi_cmd_desc));
+
+	return (buf + cmd_cnt);
+}
+
+static struct dsi_cmd_desc *copy_used_effect_code(struct panel_effect_data *panel_data, struct dsi_cmd_desc *buf, int *cnt)
+{
+	struct dsi_cmd_desc *temp;
+	struct lcd_effect_data *effect_data = panel_data->effect_data;
+	struct lcd_effect *effect = effect_data->effect;
+
+	temp = buf;
+	//protect eys mode(ct level 3) is highest priority
+	if((effect[EFFECT_CE].level) && (effect[EFFECT_CT].level!=3))
+		temp = copy_single_effect_code(panel_data, temp, EFFECT_CE, effect[EFFECT_CE].level, cnt);
+	else
+		temp = copy_single_effect_code(panel_data, temp, EFFECT_CT, effect[EFFECT_CT].level, cnt);
+
+	temp = copy_single_effect_code(panel_data, temp, EFFECT_CABC, effect[EFFECT_CABC].level, cnt);
+	temp = copy_single_effect_code(panel_data, temp, EFFECT_HBM, effect[EFFECT_HBM].level, cnt);
+
+	lcd_effect_info("%s,EFFECT_CE level:%d,EFFECT_CT level:%d,EFFECT_CABC level:%d,EFFECT_HBM level:%d\n",__func__,
+	effect[EFFECT_CE].level,effect[EFFECT_CT].level,effect[EFFECT_CABC].level,effect[EFFECT_HBM].level);
+
+	return temp;
+}
+
+static struct dsi_cmd_desc *copy_all_effect_code(struct panel_effect_data *panel_data, struct dsi_cmd_desc *buf, int *cnt)
+{
+	struct dsi_cmd_desc *temp;
+	struct lcd_effect_data *effect_data = panel_data->effect_data;
+	struct lcd_effect *effect = effect_data->effect;
+	struct lcd_effect_cmds *effect_cmd;
+	int i, j;
+	int cmd_cnt;
+
+	temp = buf;
+	for (i = 0; i < effect_data->supported_effect; i++) {
+		update_effect_cmds(&effect[i], effect[i].level);
+		cmd_cnt = get_effect_cmd_cnt(&effect[i]);
+		effect_cmd = get_effect_cmd(&effect[i]);
+		lcd_effect_info("%s name: [%s] level: [%d],cmd_cnt:[%d]\n", __func__,
+			effect[i].name, effect[i].level,cmd_cnt);
+		*cnt += cmd_cnt;
+		for (j = 0; j < cmd_cnt; j++)
+			memcpy(temp++, get_effect_cmd_desc(&effect_cmd[j]), sizeof (struct dsi_cmd_desc));
+	}
+
+	return temp;
+}
+
+static struct dsi_cmd_desc * copy_mode_code(
+		struct panel_effect_data *panel_data, 
+		struct dsi_cmd_desc *buf, 
+		int mode_index, 
+		int *cnt)
+{
+	struct lcd_mode *mode = &panel_data->mode_data->mode[mode_index];
+	struct lcd_cmds *mode_cmds = &mode->mode_cmd; 
+	struct dsi_cmd_desc *temp;
+	int count = 0;
+	int mode_cnt = get_mode_cmd_cnt(mode);
+	lcd_effect_info("%s: line=%d mode_cnt=%d\n", __func__,__LINE__,mode_cnt);
+	if (mode_index == 0) {
+		lcd_effect_info("%s: current is custom mode\n", __func__);
+		temp = copy_all_effect_code(panel_data, buf, &count);
+		*cnt += count;
+	} else {
+		lcd_effect_info("%s: current is %s\n", __func__, mode->name);
+		memcpy(buf, mode_cmds->cmd, mode_cnt * sizeof (struct dsi_cmd_desc));
+		temp = buf + mode_cnt;
+		*cnt += mode_cnt;
+	}
+
+	return temp;
+}
+
+static int set_mode(struct msm_fb_data_type *mfd, struct panel_effect_data *panel_data, int index)
+{
+	struct lcd_cmds lcd_cmd;
+	struct dsi_cmd_desc *temp;
+	int cnt = 0;
+	int ret;
+
+	lcd_cmd.cmd = panel_data->buf;
+
+	temp = copy_head_code(panel_data, panel_data->buf, &cnt);
+	copy_mode_code(panel_data, temp, index, &cnt);
+
+	lcd_cmd.cnt = cnt;
+
+	ret = send_lcd_cmds(mfd, &lcd_cmd);
+	if (ret >= 0 || ret == -EPERM) {
+		panel_data->mode_data->current_mode = index;
+		lcd_effect_info("%s %s success\n", __func__, panel_data->mode_data->mode[index].name);
+		ret = 0;
+	}
+	if (is_show_lcd_param)
+		show_lcd_param(lcd_cmd.cmd, lcd_cmd.cnt);
+
+	return ret;
+}
+
+static int set_effect(struct msm_fb_data_type *mfd, struct panel_effect_data *panel_data, int index, int level)
+{
+	struct lcd_cmds lcd_cmd;
+	struct dsi_cmd_desc *temp;
+	int cnt = 0;
+	int ret;
+
+	lcd_cmd.cmd = panel_data->buf;
+
+	temp = copy_head_code(panel_data, panel_data->buf, &cnt);
+	copy_single_effect_code(panel_data, temp, index, level, &cnt);
+
+	lcd_cmd.cnt = cnt;
+
+	ret = send_lcd_cmds(mfd, &lcd_cmd);
+
+	if (ret >= 0 || ret == -EPERM) {
+		panel_data->effect_data->effect[index].level = level;
+		lcd_effect_info("%s name: [%s] level: [%d] success\n", __func__, panel_data->effect_data->effect[index].name, level);
+		ret = 0;
+	}
+	if (is_show_lcd_param)
+		show_lcd_param(lcd_cmd.cmd, lcd_cmd.cnt);
+
+	return ret;
+}
+
+static int lcd_get_mode(struct lcd_mode_data *mode_data)
+{
+	if (mode_data == NULL)
+		return -EINVAL;
+
+	lcd_effect_info("%s name: [%s] index: [%d]\n", __func__, mode_data->mode[mode_data->current_mode].name, mode_data->current_mode);
+	return mode_data->current_mode;
+}
+
+static int lcd_get_supported_effect_level(struct lcd_effect_data *effect_data, int index)
+{
+	if (effect_data == NULL || index < 0) {
+		lcd_effect_info("%s index: %d invalid, max index is: 0 - %d\n", __func__, index, effect_data->supported_effect - 1);
+		return -EINVAL;
+	}
+
+	lcd_effect_info("%s name: [%s] index: [%d] max_level: [%d]\n", __func__, effect_data->effect[index].name, index, effect_data->effect[index].max_level);
+	return effect_data->effect[index].max_level;
+}
+static int lcd_get_effect_level(struct lcd_effect_data *effect_data, int index)
+{
+	if (effect_data == NULL || index < 0) {
+		lcd_effect_info("%s index: %d invalid, max index is: 0 - %d\n", __func__, index, effect_data->supported_effect - 1);
+		return -EINVAL;
+	}
+
+	lcd_effect_info("%s name: [%s] index: [%d] level: [%d]\n", __func__, effect_data->effect[index].name, index, effect_data->effect[index].level);
+	return effect_data->effect[index].level;
+}
+
+static int lcd_get_supported_effect(struct lcd_effect_data *effect_data, struct hal_panel_data *data)
+{
+	int i;
+
+	if (effect_data == NULL || data == NULL)
+		return -EINVAL;
+
+	if (EFFECT_COUNT < effect_data->supported_effect)
+		return -ENOMEM;
+
+	for (i = 0; i < effect_data->supported_effect; i++) {
+		memcpy(data->effect[i].name, effect_data->effect[i].name, strlen(effect_data->effect[i].name));
+	}
+	data->effect_cnt = effect_data->supported_effect;
+
+	return data->effect_cnt;
+}
+
+static int lcd_get_supported_mode(struct lcd_mode_data *mode_data, struct hal_panel_data *data)
+{
+	int i;
+
+	if (mode_data == NULL || data == NULL)
+		return -EINVAL;
+
+	if (MODE_COUNT < mode_data->supported_mode)
+		return -ENOMEM;
+
+	for (i = 0; i < mode_data->supported_mode; i++) {
+		memcpy(data->mode[i].name, mode_data->mode[i].name, strlen(mode_data->mode[i].name));
+	}
+	data->mode_cnt = mode_data->supported_mode;
+
+	return data->mode_cnt;
+}
+
+static int lcd_set_mode(struct msm_fb_data_type *mfd, struct panel_effect_data *panel_data, int mode)
+{
+	int ret;
+	struct lcd_mode_data *mode_data = panel_data->mode_data;
+
+	if (mode >= mode_data->supported_mode || mode < 0) {
+		lcd_effect_info("%s mode invalid, max mode is: 0 - %d\n", __func__, mode_data->supported_mode - 1);
+		return -EINVAL;
+	}
+
+	ret = set_mode(mfd, panel_data, mode);
+
+	return ret;
+}
+
+static int lcd_set_effect(struct msm_fb_data_type *mfd, struct panel_effect_data *panel_data, int index, int level)
+{
+	int ret = 0;
+	struct lcd_effect_data *effect_data = panel_data->effect_data;
+
+#ifdef CONFIG_BACKLIGHT_LM36923
+		if(index == 3){
+			ret = lm36923_sunlight_settings(level);
+		}
+#endif
+
+	if (index >= effect_data->supported_effect || index < 0) {
+		lcd_effect_info("%s index invalid, max index is: 0 - %d\n", __func__, effect_data->supported_effect - 1);
+		return -EINVAL;
+	}
+
+	if (level >= effect_data->effect[index].max_level || level < 0) {
+		lcd_effect_info("%s level invalid, max level is: 0 - %d\n", __func__, effect_data->effect[index].max_level - 1);
+		return -EINVAL;
+	}
+
+	ret = set_effect(mfd, panel_data, index, level);
+
+	return ret;
+}
+
+int update_init_code(
+		struct mdss_dsi_ctrl_pdata *ctrl_pdata,
+		struct panel_effect_data *panel_data,
+		void (*mdss_dsi_panel_cmds_send)(struct mdss_dsi_ctrl_pdata *ctrl,struct dsi_panel_cmds *pcmds,u32 flags))
+{
+	struct lcd_cmds lcd_cmd;
+	struct dsi_cmd_desc *temp;
+	struct lcd_cmds *save_cmd = &panel_data->save_cmd;
+	int cnt = 0;
+	int ret = 0;
+	lcd_cmd.cmd = panel_data->buf;
+
+	temp = copy_init_code(panel_data, &cnt);
+
+	temp = copy_used_effect_code(panel_data, temp, &cnt);
+	temp = copy_sleep_out_code(panel_data, temp, &cnt);
+
+	lcd_cmd.cnt = cnt;
+
+#ifdef READ_LCD_PARAM
+	if (read_lcd_file) 
+	{
+		if (!open_lcd_and_get_data()) {
+			ctrl_pdata->on_cmds.cmds = lcd_txt_cmds.cmd;
+			ctrl_pdata->on_cmds.cmd_cnt = lcd_txt_cmds.cnt;
+			lcd_effect_info("%s Use Txt file param\n", __func__);
+		}
+	} else 
+#endif
+	{
+		ctrl_pdata->on_cmds.cmds = lcd_cmd.cmd;
+		ctrl_pdata->on_cmds.cmd_cnt = lcd_cmd.cnt;
+		lcd_effect_info("%s Use system param\n", __func__);
+	}
+
+	mdss_dsi_panel_cmds_send(ctrl_pdata, &ctrl_pdata->on_cmds,CMD_REQ_COMMIT);
+
+	if (is_show_lcd_param)
+		show_lcd_param(ctrl_pdata->on_cmds.cmds, ctrl_pdata->on_cmds.cmd_cnt);
+
+	ctrl_pdata->on_cmds.cmds = save_cmd->cmd;
+	ctrl_pdata->on_cmds.cmd_cnt = save_cmd->cnt;
+#ifdef READ_LCD_PARAM
+	clear_data_and_mem();
+#endif
+	return ret;
+}
+
+
+int handle_lcd_effect_data(
+		struct msm_fb_data_type *mfd, 
+		struct panel_effect_data *panel_data, 
+		struct hal_panel_ctrl_data *ctrl_data)
+{
+	struct lcd_effect_data *effect_data = panel_data->effect_data;
+	struct lcd_mode_data *mode_data = panel_data->mode_data;
+	int mode_index = mode_data->current_mode; 
+	int ret = 0;
+
+	switch(ctrl_data->id) {
+		case GET_EFFECT_NUM:
+			ret = lcd_get_supported_effect(effect_data, &ctrl_data->panel_data);
+			break;
+		case GET_EFFECT_LEVEL:
+			ret = lcd_get_supported_effect_level(effect_data, ctrl_data->index);
+			break;
+		case GET_EFFECT:
+			ret = lcd_get_effect_level(effect_data, ctrl_data->index);
+			break;
+		case GET_MODE_NUM:
+			ret = lcd_get_supported_mode(mode_data, &ctrl_data->panel_data);
+			break;
+		case GET_MODE:
+			ret = lcd_get_mode(mode_data);
+			break;
+		case SET_EFFECT:
+			if (is_custom_mode(mode_data)) {
+			pr_info("%s:SET_EFFECT,index=%d,level=%d\n",__func__,ctrl_data->index,ctrl_data->level);
+				ret = lcd_set_effect(mfd, panel_data, ctrl_data->index, ctrl_data->level);
+			} else {
+				lcd_effect_info("(%s) can't support change effect\n", mode_data->mode[mode_index].name);
+				ret = -EINVAL;
+			}
+			break;
+		case SET_MODE:
+			ret = lcd_set_mode(mfd, panel_data, ctrl_data->mode);
+			break;
+		default:
+			break;
+	}
+
+	return ret;
+}
+
+
+int malloc_lcd_effect_code_buf(struct panel_effect_data *panel_data)
+{
+	struct lcd_cmds *save_cmd = &panel_data->save_cmd;
+	if (panel_data->buf == NULL) {
+		panel_data->buf_size = get_init_code_max_cnt(panel_data, save_cmd);
+		panel_data->buf  = kmalloc(sizeof(struct dsi_cmd_desc) * panel_data->buf_size, GFP_KERNEL);
+		if ( !panel_data->buf)
+			return -ENOMEM;
+		return 0;
+	}
+	return 0;
+}
+#ifdef READ_LCD_PARAM
+static int get_lcd_param_func(const char *val, struct kernel_param *kp)
+{
+	int value;
+	int ret = param_set_int(val, kp); 
+
+	if(ret < 0) 
+	{    
+		pr_info(KERN_ERR"%s Invalid argument\n", __func__);
+		return -EINVAL;
+	}    
+	value = *((int*)kp->arg);
+	if (value) {
+		read_lcd_file = 1;
+		pr_info("prepare to read lcd param...\n");
+	} else {
+		read_lcd_file = 0;
+		pr_info("show lcd param off...\n");
+	}
+	return 0;
+}
+
+module_param_call(read_txt_file, get_lcd_param_func, param_get_int, &read_lcd_file, S_IRUSR | S_IWUSR);
+#endif
+static int show_lcd_param_func(const char *val, struct kernel_param *kp)
+{
+	int value;
+	int ret = param_set_int(val, kp); 
+
+	if(ret < 0) 
+	{    
+		pr_info(KERN_ERR"%s Invalid argument\n", __func__);
+		return -EINVAL;
+	}    
+	value = *((int*)kp->arg);
+	if (value) {
+		is_show_lcd_param = 1;
+		pr_info("show lcd param on...\n");
+	} else {
+		is_show_lcd_param = 0;
+		pr_info("show lcd param off...\n");
+	}
+	return 0;
+}
+
+module_param_call(show_lcd_cmd, show_lcd_param_func, param_get_int, &is_show_lcd_param, S_IRUSR | S_IWUSR);