void mdss_dsi_set_tear_off(struct mdss_dsi_ctrl_pdata *ctrl)
{
struct dcs_cmd_req cmdreq;
cmdreq.cmds = &dsi_tear_off_cmd;
cmdreq.cmds_cnt = 1;
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
}
void htc_set_cabc(struct msm_fb_data_type *mfd)
{
struct mdss_panel_data *pdata;
struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
struct dcs_cmd_req cmdreq;
pdata = dev_get_platdata(&mfd->pdev->dev);
ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
if (htc_attr_status[CABC_INDEX].req_value > 2)
return;
if (!ctrl_pdata->cabc_off_cmds.cmds)
return;
if (!ctrl_pdata->cabc_ui_cmds.cmds)
return;
if (!ctrl_pdata->cabc_video_cmds.cmds)
return;
if (htc_attr_status[CABC_INDEX].req_value == htc_attr_status[CABC_INDEX].cur_value)
return;
memset(&cmdreq, 0, sizeof(cmdreq));
if (htc_attr_status[CABC_INDEX].req_value == 0) {
cmdreq.cmds = ctrl_pdata->cabc_off_cmds.cmds;
cmdreq.cmds_cnt = ctrl_pdata->cabc_off_cmds.cmd_cnt;
} else if (htc_attr_status[CABC_INDEX].req_value == 1) {
cmdreq.cmds = ctrl_pdata->cabc_ui_cmds.cmds;
cmdreq.cmds_cnt = ctrl_pdata->cabc_ui_cmds.cmd_cnt;
} else if (htc_attr_status[CABC_INDEX].req_value == 2) {
cmdreq.cmds = ctrl_pdata->cabc_video_cmds.cmds;
cmdreq.cmds_cnt = ctrl_pdata->cabc_video_cmds.cmd_cnt;
} else {
cmdreq.cmds = ctrl_pdata->cabc_ui_cmds.cmds;
cmdreq.cmds_cnt = ctrl_pdata->cabc_ui_cmds.cmd_cnt;
}
cmdreq.flags = CMD_REQ_COMMIT | CMD_CLK_CTRL;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl_pdata, &cmdreq);
htc_attr_status[CABC_INDEX].cur_value = htc_attr_status[CABC_INDEX].req_value;
PR_DISP_INFO("%s cabc mode=%d\n", __func__, htc_attr_status[CABC_INDEX].cur_value);
return;
}
static void mdss_dsi_panel_cmds_send(struct mdss_dsi_ctrl_pdata *ctrl,
struct dsi_panel_cmds *pcmds)
{
struct dcs_cmd_req cmdreq;
if (get_lcd_attached() == 0)
{
printk("%s: get_lcd_attached(0)!\n",__func__);
return ;
}
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = pcmds->cmds;
cmdreq.cmds_cnt = pcmds->cmd_cnt;
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
if(ctrl->ndx == DSI_CTRL_0)
mdss_dsi_cmdlist_put(left_back_up_data, &cmdreq);
}
static int mdss_dsi_read_status(struct mdss_dsi_ctrl_pdata *ctrl)
{
struct dcs_cmd_req cmdreq;
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = ctrl->status_cmds.cmds;
cmdreq.cmds_cnt = ctrl->status_cmds.cmd_cnt;
cmdreq.flags = CMD_REQ_COMMIT | CMD_CLK_CTRL | CMD_REQ_RX;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
cmdreq.rbuf = ctrl->status_buf.data;
return mdss_dsi_cmdlist_put(ctrl, &cmdreq);
}
static void mdss_dsi_panel_cmds_send(struct mdss_dsi_ctrl_pdata *ctrl,
struct dsi_panel_cmds *pcmds)
{
struct dcs_cmd_req cmdreq;
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = pcmds->cmds;
cmdreq.cmds_cnt = pcmds->cmd_cnt;
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
}
static void mdss_dsi_panel_cmds_send(struct mdss_dsi_ctrl_pdata *ctrl,
struct dsi_panel_cmds *pcmds)
{
struct dcs_cmd_req cmdreq;
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = pcmds->cmds;
cmdreq.cmds_cnt = pcmds->cmd_cnt;
cmdreq.flags = CMD_REQ_COMMIT;
/*Panel ON/Off commands should be sent in DSI Low Power Mode*/
if (pcmds->link_state == DSI_LP_MODE)
cmdreq.flags |= CMD_REQ_LP_MODE;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
}
/***************************************************************
Function: process_mipi_read_table
Description: read the required register and return register value
Parameters:
struct mdss_dsi_ctrl_pdata *ctrl: dsi control parameter struct
struct dsi_cmd_desc* dcs_read_cmd: register required to be read
char *rx_buf: the returned register value will be saved in this buffer
u32 rx_len: the expect number of returned register value
Return:0:success
***************************************************************/
int process_mipi_read_table(struct mdss_dsi_ctrl_pdata *ctrl,struct dsi_cmd_desc* dcs_read_cmd,char *rx_buf, u32 rx_len)
{
struct dcs_cmd_req cmdreq;
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = dcs_read_cmd;
cmdreq.cmds_cnt = 1;
cmdreq.flags = CMD_REQ_RX | CMD_REQ_COMMIT;
cmdreq.rlen = rx_len;
cmdreq.rbuf = rx_buf;
cmdreq.cb = NULL; //call back
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
return 0;
}
static void mdss_dsi_panel_bklt_dcs(struct mdss_dsi_ctrl_pdata *ctrl, int level)
{
struct dcs_cmd_req cmdreq;
pr_debug("%s: level=%d\n", __func__, level);
led_pwm1[1] = (unsigned char)level;
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = &backlight_cmd;
cmdreq.cmds_cnt = 1;
cmdreq.flags = CMD_REQ_COMMIT | CMD_CLK_CTRL;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
}
void mdss_dsi_set_tear_off(struct mdss_dsi_ctrl_pdata *ctrl)
{
struct dcs_cmd_req cmdreq;
struct mdss_panel_info *pinfo;
pinfo = &(ctrl->panel_data.panel_info);
if (pinfo->dcs_cmd_by_left && ctrl->ndx != DSI_CTRL_LEFT)
return;
cmdreq.cmds = &dsi_tear_off_cmd;
cmdreq.cmds_cnt = 1;
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
}
void zte_send_cmd(struct dsi_cmd_desc *cmds,int cmdcount)
{
struct dcs_cmd_req cmdreq;
if((!zte_mdss_dsi_ctrl) || (cmdcount < 1)) {
pr_err("lcd:faild:%s zte_mdss_dsi_ctrl is null\n",__func__);
return;
}
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = cmds;
cmdreq.cmds_cnt = cmdcount;
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(zte_mdss_dsi_ctrl, &cmdreq);
}
static void mdss_dsi_cmds_send(struct mdss_dsi_ctrl_pdata *ctrl,
struct dsi_cmd_desc *cmds, int cnt,int flag)
{
struct dcs_cmd_req cmdreq;
memset(&cmdreq, 0, sizeof(cmdreq));
if (flag & CMD_REQ_SINGLE_TX) {
cmdreq.flags = CMD_REQ_SINGLE_TX | CMD_CLK_CTRL | CMD_REQ_COMMIT;
}else
cmdreq.flags = CMD_REQ_COMMIT | CMD_CLK_CTRL;
cmdreq.cmds = cmds;
cmdreq.cmds_cnt = cnt;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
}
u32 mdss_dsi_dcs_read(struct mdss_dsi_ctrl_pdata *ctrl,
char cmd0, char cmd1)
{
struct dcs_cmd_req cmdreq;
dcs_cmd[0] = cmd0;
dcs_cmd[1] = cmd1;
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = &dcs_read_cmd;
cmdreq.cmds_cnt = 1;
cmdreq.flags = CMD_REQ_RX | CMD_REQ_COMMIT;
cmdreq.rlen = 1;
cmdreq.cb = NULL; /* call back */
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
/*
* blocked here, until call back called
*/
return 0;
}
static void mdss_dsi_panel_cmds_send(struct mdss_dsi_ctrl_pdata *ctrl,
struct dsi_panel_cmds *pcmds)
{
struct dcs_cmd_req cmdreq;
#if defined(CONFIG_FB_MSM8x26_MDSS_CHECK_LCD_CONNECTION)
if (get_samsung_lcd_attached() == 0)
{
printk("%s: LCD not connected!\n",__func__);
return;
}
#endif
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = pcmds->cmds;
cmdreq.cmds_cnt = pcmds->cmd_cnt;
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
}
u32 mdss_dsi_panel_cmd_read(struct mdss_dsi_ctrl_pdata *ctrl, char cmd0,
char cmd1, void (*fxn)(int), char *rbuf, int len)
{
struct dcs_cmd_req cmdreq;
dcs_cmd[0] = cmd0;
dcs_cmd[1] = cmd1;
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = &dcs_read_cmd;
cmdreq.cmds_cnt = 1;
cmdreq.flags = CMD_REQ_RX | CMD_REQ_COMMIT;
cmdreq.rlen = len;
cmdreq.rbuf = rbuf;
cmdreq.cb = fxn; /* call back */
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
/*
* blocked here, until call back called
*/
return 0;
}
static void mdss_dsi_panel_bklt_dcs(struct mdss_dsi_ctrl_pdata *ctrl, int level)
{
struct dcs_cmd_req cmdreq;
pr_debug("%s: level=%d\n", __func__, level);
led_pwm1[1] = (unsigned char)level;
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = &backlight_cmd;
cmdreq.cmds_cnt = 1;
cmdreq.flags = CMD_REQ_COMMIT | CMD_CLK_CTRL;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
//no need to do transfer mode shift
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
#ifdef CONFIG_HUAWEI_LCD
LCD_LOG_DBG("%s: level=%d\n", __func__, level);
#endif
}
static void dimming_do_work(struct work_struct *work)
{
struct mdss_panel_data *pdata;
struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
struct dcs_cmd_req cmdreq;
pdata = dev_get_platdata(&mfd_instance->pdev->dev);
ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = ctrl_pdata->dimming_on_cmds.cmds;
cmdreq.cmds_cnt = ctrl_pdata->dimming_on_cmds.cmd_cnt;
cmdreq.flags = CMD_REQ_COMMIT | CMD_CLK_CTRL;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl_pdata, &cmdreq);
PR_DISP_INFO("dimming on\n");
}
static void mdss_dsi_panel_bklt_dcs(struct mdss_dsi_ctrl_pdata *ctrl, int level)
{
struct dcs_cmd_req cmdreq;
pr_debug("%s: level=%d\n", __func__, level);
#if defined(CONFIG_FB_MSM8x26_MDSS_CHECK_LCD_CONNECTION)
if (get_samsung_lcd_attached() == 0)
{
printk("%s: LCD not connected!\n",__func__);
return;
}
#endif
led_pwm1[1] = mdss_dsi_panel_pwm_scaling(level);
memset(&cmdreq, 0, sizeof(cmdreq));
cmdreq.cmds = &backlight_cmd;
cmdreq.cmds_cnt = 1;
cmdreq.flags = CMD_REQ_COMMIT | CMD_CLK_CTRL;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
}
/**********************************************************************************
*function:process read and write commands for lcd reg debug
*op_type: read or write
*reg: lcd register
*cmd_type: DCS or GEN
*param_num: the count of prameters to tranfer
*param_buf: prameters
*read_value: value from lcd panel
*delay_ms: delay time
*return: 0 - success, negative - fail
**********************************************************************************/
int lcd_dbg_mipi_prcess_ic_reg(int op_type,int reg, int cmd_type, int param_num, char *param_buf,int *read_value, int delay_ms)
{
static struct dcs_cmd_req cmdreq;
static struct dsi_cmd_desc dsi_cmd; // dsi cmd struct
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
#if LCD_MIPI_DEBUG_ON
int i = 0;
#endif
/* check if input legal */
if (is_mipi_input_legal(op_type,reg, cmd_type, param_num,param_buf))
{
LCD_LOG_ERR("%s, input illegal.\n", __func__);
return -1;
}
ctrl = lcd_dbg_get_dsi_ctrl_pdata();
/* translate cmd_type from huawei to qcom's format */
switch (param_num)
{
case 0:
{
if(OPER_READ == op_type)
{
/* DCS MODE */
if (MIPI_DCS_COMMAND == cmd_type)
{
cmd_type = DTYPE_DCS_READ;
}
/* GEN MODE */
else if (MIPI_GEN_COMMAND == cmd_type)
{
cmd_type = DTYPE_GEN_READ;
}
}
else
{
/* DCS MODE */
if (MIPI_DCS_COMMAND == cmd_type)
{
cmd_type = DTYPE_DCS_WRITE;
}
/* GEN MODE */
else if (MIPI_GEN_COMMAND == cmd_type)
{
cmd_type = DTYPE_GEN_WRITE1;
}
}
break;
}
case 1:
{
if(OPER_READ == op_type)
{
/* DCS MODE */
if (MIPI_DCS_COMMAND == cmd_type)
{
LCD_LOG_ERR("%s ,not support this kind of dcs read! \n",__func__);
return -1;
}
/* GEN MODE */
else if (MIPI_GEN_COMMAND == cmd_type)
{
cmd_type = DTYPE_GEN_READ1;
}
}
else
{
/* DCS MODE */
if (MIPI_DCS_COMMAND == cmd_type)
{
cmd_type = DTYPE_DCS_WRITE1;
}
/* GEN MODE */
else if (MIPI_GEN_COMMAND == cmd_type)
{
cmd_type = DTYPE_GEN_WRITE2;
}
}
break;
}
default:
{
if(OPER_READ == op_type)
{
/* DCS MODE */
if (MIPI_DCS_COMMAND == cmd_type)
{
LCD_LOG_ERR("%s ,not support this kind of dcs read! \n",__func__);
return -1;
}
/* GEN MODE */
else if (MIPI_GEN_COMMAND == cmd_type)
{
cmd_type = DTYPE_GEN_READ2;
}
}
else
{
/* DCS MODE */
if (MIPI_DCS_COMMAND == cmd_type)
{
cmd_type = DTYPE_DCS_LWRITE;
}
/* GEN MODE */
else if (MIPI_GEN_COMMAND == cmd_type)
{
cmd_type = DTYPE_GEN_LWRITE;
}
}
break;
}
}
/* insert reg into param_buf's beginning */
memmove(param_buf + 1, param_buf, param_num);
param_buf[0] = reg;
param_num++;
/* debug begin */
#if LCD_MIPI_DEBUG_ON
LCD_LOG_INFO("%s,op_type=%d, reg=0x%02x, cmd_type=0x%02x, param_num=0x%02x, delay_ms=0x%02x\n", __func__, op_type,reg, cmd_type, param_num, delay_ms);
LCD_LOG_INFO("%s, print param_buf begin\n", __func__);
for (i = 0; i < param_num; i++)
{
LCD_LOG_INFO("0x%02x ", param_buf[i]);
}
LCD_LOG_INFO("%s, print param_buf end\n", __func__);
#endif
/* debug end */
dsi_cmd.dchdr.dtype = cmd_type;
dsi_cmd.dchdr.last =1;
dsi_cmd.dchdr.vc = 0;
dsi_cmd.dchdr.dlen = param_num;
dsi_cmd.payload = param_buf;
memset(&cmdreq, 0, sizeof(cmdreq));
switch(op_type)
{
case OPER_READ:
dsi_cmd.dchdr.ack = 1;
dsi_cmd.dchdr.wait = 5;//5 ms
cmdreq.flags = CMD_REQ_RX | CMD_REQ_COMMIT;
cmdreq.rbuf = (char*)read_value;
break;
case OPER_WRITE:
dsi_cmd.dchdr.ack = 0;
dsi_cmd.dchdr.wait = delay_ms;//5 ms
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rbuf = NULL;
break;
}
cmdreq.cmds = &dsi_cmd;
cmdreq.cmds_cnt = 1;
if (ctrl->long_read_flag)
{
cmdreq.rlen = 3;
}else
{
cmdreq.rlen = 1;
}
cmdreq.cb = NULL; /* call back */
mdss_dsi_cmdlist_put(ctrl, &cmdreq);
if( op_type ==OPER_READ )
{
LCD_LOG_INFO("%s, read value is 0x%02x\n", __func__,cmdreq.rbuf[0]);
}
return 0;
}
static ssize_t dsi_cmd_write(
struct file *file,
const char __user *buff,
size_t count,
loff_t *ppos)
{
u32 type, value;
int cnt, i;
struct dcs_cmd_req cmdreq;
char rbuf[4];
if (count >= sizeof(debug_buf) || count < MIN_COUNT)
return -EFAULT;
if (copy_from_user(debug_buf, buff, count))
return -EFAULT;
if (!ctrl_instance)
return count;
debug_buf[count] = 0;
cnt = (count) / 3 - 1;
debug_cmd.dchdr.dlen = cnt;
sscanf(debug_buf, "%x", &type);
if (type == DTYPE_DCS_LWRITE)
debug_cmd.dchdr.dtype = DTYPE_DCS_LWRITE;
else if (type == DTYPE_GEN_LWRITE)
debug_cmd.dchdr.dtype = DTYPE_GEN_LWRITE;
else if (type == DTYPE_DCS_READ)
debug_cmd.dchdr.dtype = DTYPE_DCS_READ;
else
return -EFAULT;
PR_DISP_INFO("%s: cnt=%d, type=0x%x\n", __func__, cnt, type);
for (i = 0; i < cnt; i++) {
if (i >= DCS_MAX_CNT) {
PR_DISP_INFO("%s: DCS command count over DCS_MAX_CNT, Skip these commands.\n", __func__);
break;
}
tmp = debug_buf + (3 * (i + 1));
sscanf(tmp, "%x", &value);
dcs_cmds[i] = value;
PR_DISP_INFO("%s: value=0x%x\n", __func__, dcs_cmds[i]);
}
memset(&cmdreq, 0, sizeof(cmdreq));
if (type == DTYPE_DCS_READ){
cmdreq.cmds = &debug_cmd;
cmdreq.cmds_cnt = 1;
cmdreq.flags = CMD_REQ_COMMIT | CMD_REQ_RX;
cmdreq.rlen = 4;
cmdreq.rbuf = rbuf;
mdss_dsi_read_commit(ctrl_instance, &cmdreq);
PR_DISP_INFO("%s: Read 0x%x = 0x%x, count=%d\n", __func__, dcs_cmds[0], rbuf[0], count);
} else {
cmdreq.cmds = &debug_cmd;
cmdreq.cmds_cnt = 1;
cmdreq.flags = CMD_REQ_COMMIT | CMD_CLK_CTRL;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mdss_dsi_cmdlist_put(ctrl_instance, &cmdreq);
PR_DISP_INFO("%s %d\n", __func__, count);
}
return count;
}
