static int mdss_dsi_panel_off(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
pr_debug("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
mipi = &pdata->panel_info.mipi;
mdss_dsi_cmds_tx(pdata, &dsi_panel_tx_buf,
&dsi_tear_off_cmd, 1);
if (ctrl->off_cmds->size)
mdss_dsi_cmds_tx(pdata, &dsi_panel_tx_buf,
ctrl->off_cmds->buf,
ctrl->off_cmds->size);
return 0;
}
int mdss_dsi_panel_initialize(struct mipi_panel_info *mipi, uint32_t
broadcast)
{
int status = 0;
uint32_t ctrl_mode = 0;
#if (DISPLAY_TYPE_MDSS == 1)
if (!mipi->panel_on_cmds)
goto end;
ctrl_mode = readl(mipi->ctl_base + CTRL);
/* Enable command mode before sending the commands. */
writel(ctrl_mode | 0x04, mipi->ctl_base + CTRL);
if (broadcast)
writel(ctrl_mode | 0x04, mipi->sctl_base + CTRL);
status = mdss_dsi_cmds_tx(mipi, mipi->panel_on_cmds,
mipi->num_of_panel_on_cmds, broadcast);
writel(ctrl_mode, mipi->ctl_base + CTRL);
if (broadcast)
writel(ctrl_mode, mipi->sctl_base + CTRL);
if (!broadcast && !status && target_panel_auto_detect_enabled())
status = mdss_dsi_read_panel_signature(mipi);
end:
#endif
return status;
}
static uint32_t mdss_dsi_read_panel_signature(struct mipi_panel_info *mipi)
{
uint32_t rec_buf[1];
uint32_t *lp = rec_buf, data;
uint32_t ret = response_value;
uint32_t panel_signature = mipi->signature;
#if (DISPLAY_TYPE_MDSS == 1)
if (ret && ret != panel_signature)
goto exit_read_signature;
ret = mdss_dsi_cmds_tx(mipi, &read_ddb_start_cmd, 1, 0);
if (ret)
goto exit_read_signature;
if (!mdss_dsi_cmds_rx(mipi, &lp, 1, 1))
goto exit_read_signature;
data = ntohl(*lp);
data = data >> 8;
response_value = data;
if (response_value != panel_signature)
ret = response_value;
exit_read_signature:
/* Keep the non detectable panel at the end and set panel signature 0xFFFF */
if ((panel_signature == 0) || (panel_signature == 0xFFFF))
ret = 0;
#endif
return ret;
}
void mdss_dsi_cmdlist_tx(struct mdss_dsi_ctrl_pdata *ctrl,
struct dcs_cmd_req *req)
{
int ret;
ret = mdss_dsi_cmds_tx(ctrl, req->cmds, req->cmds_cnt);
if (req->cb)
req->cb(ret);
}
int mdss_dsi_cmdlist_tx(struct mdss_dsi_ctrl_pdata *ctrl,
struct dcs_cmd_req *req)
{
int ret, ret_val = -EINVAL;
ret = mdss_dsi_cmds_tx(ctrl, req->cmds, req->cmds_cnt);
if (!IS_ERR_VALUE(ret))
ret_val = 0;
if (req->cb)
req->cb(ret);
return ret_val;
}
void mdss_dsi_panel_shutdown(struct msm_panel_info *pinfo)
{
#if (DISPLAY_TYPE_MDSS == 1)
unsigned long read_val = 0;
uint32_t ctl_base = pinfo->mipi.ctl_base;
uint32_t sctl_base = pinfo->mipi.sctl_base;
if (pinfo->mipi.panel_off_cmds) {
/*
* Once MDP TG is disabled, reset of DSI controller is
* needed before we send panel OFF commands.
*/
if (pinfo->type == MIPI_VIDEO_PANEL) {
read_val = readl(ctl_base + CTRL);
writel((read_val & ~BIT(0)), ctl_base + CTRL);
writel(0x0001, ctl_base + SOFT_RESET);
dsb();
writel(0x0000, ctl_base + SOFT_RESET);
dsb();
/* Enable cmd mode only */
writel(((read_val & ~BIT(1)) | BIT(2)),
ctl_base + CTRL);
}
if (pinfo->mipi.broadcast) {
if (pinfo->type == MIPI_VIDEO_PANEL) {
read_val = readl(sctl_base + CTRL);
writel((read_val & ~BIT(0)),
sctl_base + CTRL);
writel(0x0001, sctl_base + SOFT_RESET);
dsb();
writel(0x0000, sctl_base + SOFT_RESET);
dsb();
writel(((read_val & ~BIT(1)) | BIT(2)),
sctl_base + CTRL);
}
}
mdss_dsi_cmds_tx(&pinfo->mipi, pinfo->mipi.panel_off_cmds,
pinfo->mipi.num_of_panel_off_cmds,
pinfo->mipi.broadcast);
}
#endif
}
static int mdss_dsi_panel_on(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
#if defined(CONFIG_MACH_LGE)
if(pdata_base == NULL)
pdata_base = pdata;
#endif
mipi = &pdata->panel_info.mipi;
#ifdef CONFIG_LGE_SUPPORT_LCD_MAKER_ID
pr_info("%s: ctrl=%p ndx=%d maker=%d\n", __func__, ctrl, ctrl->ndx, get_panel_maker_id());
#else
pr_info("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
#endif
if (ctrl->on_cmds.cmd_cnt)
#ifdef CONFIG_LGE_LCD_TUNING
/* LGE_CHANGE
* Implement for LCD init sequence tuning
* 2013-01-25, [email protected]
*/
mdss_dsi_cmds_tx(pdata, &dsi_panel_tx_buf,
tun_dsi_panel_on_cmds,
num_of_on_cmds);
#else
mdss_dsi_panel_cmds_send(ctrl, &ctrl->on_cmds);
#ifdef CONFIG_OLED_SUPPORT
mdss_dsi_panel_img_tune_apply(IMG_TUNE_COUNT);
pr_info("[Zee][OLED] %s success\n", __func__);
#endif
#endif
pr_debug("%s:-\n", __func__);
return 0;
}
int mdss_dsi_cmdlist_tx(struct mdss_dsi_ctrl_pdata *ctrl,
struct dcs_cmd_req *req)
{
int ret, ret_val = -EINVAL;
ret = mdss_dsi_cmds_tx(ctrl, req->cmds, req->cmds_cnt);
if (!IS_ERR_VALUE(ret))
ret_val = 0;
if (req->cb)
#ifdef CONFIG_F_SKYDISP_SMARTDIMMING
req->cb(ret,NULL);
#else
req->cb(ret);
#endif
return ret_val;
}
int mdss_dsi_cmdlist_tx(struct mdss_dsi_ctrl_pdata *ctrl,
struct dcs_cmd_req *req)
{
int ret, ret_val = -EINVAL;
if (mdss_dsi_sync_wait_enable(ctrl)) {
ctrl->do_unicast = false;
if (!ctrl->cmd_sync_wait_trigger &&
req->flags & CMD_REQ_UNICAST)
ctrl->do_unicast = true;
}
ret = mdss_dsi_cmds_tx(ctrl, req->cmds, req->cmds_cnt);
if (!IS_ERR_VALUE(ret))
ret_val = 0;
if (req->cb)
req->cb(ret);
return ret_val;
}
static ssize_t reg_write(struct file *file, const char __user *ubuf,
size_t count, loff_t *ppos)
{
struct seq_file *s = file->private_data;
struct msm_fb_data_type *mfd = s->private;
struct mdss_panel_data *pdata;
struct mdss_mdp_ctl *ctl;
char *buf;
const char *p;
enum dbg_cmd_type cmd;
u8 data[MAX_WRITE_DATA];
int i = 0;
int j;
int ret;
struct dsi_cmd_desc dsi;
struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
if (!mfd->panel_power_on) {
pr_err("%s: panel is NOT on\n", __func__);
goto exit;
}
ctl = mfd_to_ctl(mfd);
if (!ctl)
goto exit;
if (mutex_lock_interruptible(&ctl->lock))
goto exit;
pdata = dev_get_platdata(&mfd->pdev->dev);
if (!pdata) {
pr_err("%s: no panel connected\n", __func__);
goto exit;
}
ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
if (!ctrl_pdata) {
pr_err("%s: Invalid input data\n", __func__);
goto exit;
}
pr_err("%s\n", __func__);
ret = setup_reg_access(&buf, ubuf, count);
if (ret)
goto exit;
ret = get_cmd_type(buf, &cmd);
if (ret) {
update_res_buf("Write - unknown type\n");
goto fail_free_all;
}
p = buf;
p = p+4;
/* Get first param, Register */
if (sscanf(p, "%4hhx", &data[0]) != 1) {
update_res_buf("Write - parameter error\n");
ret = -EINVAL;
goto fail_free_all;
}
i++;
while (isxdigit(*p) || (*p == 'x'))
p++;
ret = get_parameters(p, data, ARRAY_SIZE(data) - 1, &i);
if (ret)
goto fail_free_all;
ret = prepare_for_reg_access(mfd);
if (ret)
goto fail_free_all;
if (cmd == DCS) {
if (i == 1) { /* 0 parameters */
dsi.dchdr.dtype = DTYPE_DCS_WRITE;
} else if (i == 2) { /* 1 parameter */
dsi.dchdr.dtype = DTYPE_DCS_WRITE1;
} else { /* Many parameters */
dsi.dchdr.dtype = DTYPE_DCS_LWRITE;
}
} else {
if (i == 1) { /* 0 parameters */
dsi.dchdr.dtype = DTYPE_GEN_WRITE;
} else if (i == 2) { /* 1 parameter */
dsi.dchdr.dtype = DTYPE_GEN_WRITE1;
} else if (i == 3) { /* 2 parameters */
dsi.dchdr.dtype = DTYPE_GEN_WRITE2;
} else { /* Many parameters */
dsi.dchdr.dtype = DTYPE_GEN_LWRITE;
}
}
dsi.dchdr.last = 1;
dsi.dchdr.vc = 0;
dsi.dchdr.ack = 0;
dsi.dchdr.wait = 0;
dsi.dchdr.dlen = i;
dsi.payload = data;
pr_err("%s: last = %d, vc = %d, ack = %d, wait = %d, dlen = %d\n",
__func__,
dsi.dchdr.last, dsi.dchdr.vc, dsi.dchdr.ack, dsi.dchdr.wait,
dsi.dchdr.dlen);
for (j = 0; j < i; j++)
pr_err("%s: payload[%d] = 0x%x\n",
__func__, j, dsi.payload[j]);
mdss_dsi_cmds_tx(ctrl_pdata, &dsi, 1);
ret = post_reg_access(mfd);
if (ret)
goto fail_free_all;
print_params(dsi.dchdr.dtype, data[0], i, dsi.payload);
mutex_unlock(&ctl->lock);
fail_free_all:
kfree(buf);
exit:
return count;
}
