static int prepare_for_reg_access(struct msm_fb_data_type *mfd)
{
struct mdss_panel_data *pdata;
int ret = 0;
struct mdss_mdp_ctl *ctl;
struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
ctl = mfd_to_ctl(mfd);
if (!ctl)
return -ENODEV;
pdata = dev_get_platdata(&mfd->pdev->dev);
if (!pdata) {
pr_err("%s: no panel connected\n", __func__);
return -ENODEV;
}
ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON, false);
mdss_dsi_cmd_mdp_busy(ctrl_pdata);
mdss_bus_bandwidth_ctrl(1);
mdss_dsi_clk_ctrl(ctrl_pdata, 1);
mdss_dsi_op_mode_config(DSI_CMD_MODE, pdata);
return ret;
}
void mdss_dsi_cmdlist_commit(struct mdss_dsi_ctrl_pdata *ctrl, int from_mdp)
{
struct dcs_cmd_req *req;
u32 data;
mutex_lock(&ctrl->cmd_mutex);
req = mdss_dsi_cmdlist_get(ctrl);
/* make sure dsi_cmd_mdp is idle */
mdss_dsi_cmd_mdp_busy(ctrl);
if (req == NULL)
goto need_lock;
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
mdss_dsi_clk_ctrl(ctrl, 1);
data = MIPI_INP((ctrl->ctrl_base) + 0x0004);
if (data & 0x02) {
/* video mode, make sure video engine is busy
* so dcs command will be sent at start of BLLP
*/
mdss_dsi_wait4video_eng_busy(ctrl);
} else {
/* command mode */
if (!from_mdp) { /* cmdlist_put */
/* make sure dsi_cmd_mdp is idle */
mdss_dsi_cmd_mdp_busy(ctrl);
}
}
if (req->flags & CMD_REQ_RX)
mdss_dsi_cmdlist_rx(ctrl, req);
else
mdss_dsi_cmdlist_tx(ctrl, req);
mdss_dsi_clk_ctrl(ctrl, 0);
need_lock:
if (from_mdp) /* from pipe_commit */
mdss_dsi_cmd_mdp_start(ctrl);
mutex_unlock(&ctrl->cmd_mutex);
}
int mdss_dsi_cmdlist_commit(struct mdss_dsi_ctrl_pdata *ctrl, int from_mdp)
{
struct dcs_cmd_req *req;
int ret = -EINVAL;
int rc = 0;
mutex_lock(&ctrl->cmd_mutex);
req = mdss_dsi_cmdlist_get(ctrl);
/* make sure dsi_cmd_mdp is idle */
mdss_dsi_cmd_mdp_busy(ctrl);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
if (req == NULL)
goto need_lock;
/*
* mdss interrupt is generated in mdp core clock domain
* mdp clock need to be enabled to receive dsi interrupt
* also, axi bus bandwidth need since dsi controller will
* fetch dcs commands from axi bus
*/
mdss_bus_scale_set_quota(MDSS_HW_DSI0, SZ_1M, SZ_1M);
mdss_bus_bandwidth_ctrl(1);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
mdss_dsi_clk_ctrl(ctrl, 1);
rc = mdss_iommu_ctrl(1);
if (IS_ERR_VALUE(rc)) {
pr_err("IOMMU attach failed\n");
mutex_unlock(&ctrl->cmd_mutex);
return rc;
}
if (req->flags & CMD_REQ_HS_MODE)
mdss_dsi_set_tx_power_mode(0, &ctrl->panel_data);
if (req->flags & CMD_REQ_RX)
ret = mdss_dsi_cmdlist_rx(ctrl, req);
else
ret = mdss_dsi_cmdlist_tx(ctrl, req);
if (req->flags & CMD_REQ_HS_MODE)
mdss_dsi_set_tx_power_mode(1, &ctrl->panel_data);
mdss_iommu_ctrl(0);
mdss_dsi_clk_ctrl(ctrl, 0);
mdss_bus_scale_set_quota(MDSS_HW_DSI0, 0, 0);
mdss_bus_bandwidth_ctrl(0);
need_lock:
if (from_mdp) /* from pipe_commit */
mdss_dsi_cmd_mdp_start(ctrl);
mutex_unlock(&ctrl->cmd_mutex);
return ret;
}
int mdss_dsi_cmdlist_commit(struct mdss_dsi_ctrl_pdata *ctrl, int from_mdp)
{
struct dcs_cmd_req *req;
int ret = -EINVAL;
int rc = 0;
mutex_lock(&ctrl->cmd_mutex);
req = mdss_dsi_cmdlist_get(ctrl);
MDSS_XLOG(ctrl->ndx, from_mdp, ctrl->mdp_busy, current->pid,
XLOG_FUNC_ENTRY);
/* make sure dsi_cmd_mdp is idle */
mdss_dsi_cmd_mdp_busy(ctrl);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
if (req == NULL)
goto need_lock;
MDSS_XLOG(ctrl->ndx, req->flags, req->cmds_cnt, from_mdp, current->pid);
/*
* mdss interrupt is generated in mdp core clock domain
* mdp clock need to be enabled to receive dsi interrupt
* also, axi bus bandwidth need since dsi controller will
* fetch dcs commands from axi bus
*/
mdss_bus_bandwidth_ctrl(1);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
mdss_dsi_clk_ctrl(ctrl, DSI_ALL_CLKS, 1);
rc = mdss_iommu_ctrl(1);
if (IS_ERR_VALUE(rc)) {
pr_err("IOMMU attach failed\n");
mutex_unlock(&ctrl->cmd_mutex);
return rc;
}
if (req->flags & CMD_REQ_RX)
ret = mdss_dsi_cmdlist_rx(ctrl, req);
else
ret = mdss_dsi_cmdlist_tx(ctrl, req);
mdss_iommu_ctrl(0);
mdss_dsi_clk_ctrl(ctrl, DSI_ALL_CLKS, 0);
mdss_bus_bandwidth_ctrl(0);
need_lock:
if (from_mdp) /* from pipe_commit */
mdss_dsi_cmd_mdp_start(ctrl);
MDSS_XLOG(ctrl->ndx, from_mdp, ctrl->mdp_busy, current->pid,
XLOG_FUNC_EXIT);
mutex_unlock(&ctrl->cmd_mutex);
return ret;
}
void mdss_dsi_clk_req(struct mdss_dsi_ctrl_pdata *ctrl, int enable)
{
if (enable == 0) {
mutex_lock(&ctrl->cmd_mutex);
mdss_dsi_cmd_mdp_busy(ctrl);
mutex_unlock(&ctrl->cmd_mutex);
}
mdss_dsi_clk_ctrl(ctrl, enable);
}
void mdss_dsi_clk_req(struct mdss_dsi_ctrl_pdata *ctrl, int enable)
{
MDSS_XLOG(ctrl->ndx, enable, ctrl->mdp_busy, current->pid);
if (enable == 0) {
/* need wait before disable */
mutex_lock(&ctrl->cmd_mutex);
mdss_dsi_cmd_mdp_busy(ctrl);
mutex_unlock(&ctrl->cmd_mutex);
}
MDSS_XLOG(ctrl->ndx, enable, ctrl->mdp_busy, current->pid);
mdss_dsi_clk_ctrl(ctrl, enable);
}
int mdss_dsi_cmdlist_commit(struct mdss_dsi_ctrl_pdata *ctrl, int from_mdp)
{
struct dcs_cmd_req *req;
int ret = -EINVAL;
int rc = 0;
mutex_lock(&ctrl->cmd_mutex);
req = mdss_dsi_cmdlist_get(ctrl);
mdss_dsi_cmd_mdp_busy(ctrl);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
if (req == NULL)
goto need_lock;
mdss_bus_scale_set_quota(MDSS_HW_DSI0, SZ_1M, SZ_1M);
mdss_bus_bandwidth_ctrl(1);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
mdss_dsi_clk_ctrl(ctrl, 1);
rc = mdss_iommu_ctrl(1);
if (IS_ERR_VALUE(rc)) {
pr_err("IOMMU attach failed\n");
mutex_unlock(&ctrl->cmd_mutex);
return rc;
}
if (req->flags & CMD_REQ_HS_MODE)
mdss_dsi_set_tx_power_mode(0, &ctrl->panel_data);
if (req->flags & CMD_REQ_RX)
ret = mdss_dsi_cmdlist_rx(ctrl, req);
else
ret = mdss_dsi_cmdlist_tx(ctrl, req);
if (req->flags & CMD_REQ_HS_MODE)
mdss_dsi_set_tx_power_mode(1, &ctrl->panel_data);
mdss_iommu_ctrl(0);
mdss_dsi_clk_ctrl(ctrl, 0);
mdss_bus_scale_set_quota(MDSS_HW_DSI0, 0, 0);
mdss_bus_bandwidth_ctrl(0);
need_lock:
if (from_mdp)
mdss_dsi_cmd_mdp_start(ctrl);
mutex_unlock(&ctrl->cmd_mutex);
return ret;
}
void mdss_dsi_clk_req(struct mdss_dsi_ctrl_pdata *ctrl, int enable)
{
#if defined (CONFIG_FB_MSM_MDSS_DSI_DBG)
xlog(__func__,ctrl->ndx, enable, ctrl->mdp_busy, 0x111, 0, current->pid);
#endif
if (enable == 0) {
/* need wait before disable */
mutex_lock(&ctrl->cmd_mutex);
mdss_dsi_cmd_mdp_busy(ctrl);
mutex_unlock(&ctrl->cmd_mutex);
}
#if defined (CONFIG_FB_MSM_MDSS_DSI_DBG)
xlog(__func__,ctrl->ndx, enable, ctrl->mdp_busy, 0x222, 0, current->pid);
#endif
mdss_dsi_clk_ctrl(ctrl, enable);
}
int mdss_dsi_cmdlist_commit(struct mdss_dsi_ctrl_pdata *ctrl, int from_mdp)
{
struct dcs_cmd_req *req;
int ret = -EINVAL;
mutex_lock(&ctrl->cmd_mutex);
req = mdss_dsi_cmdlist_get(ctrl);
/* make sure dsi_cmd_mdp is idle */
mdss_dsi_cmd_mdp_busy(ctrl);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
if (req == NULL)
goto need_lock;
/*
* mdss interrupt is generated in mdp core clock domain
* mdp clock need to be enabled to receive dsi interrupt
* also, axi bus bandwidth need since dsi controller will
* fetch dcs commands from axi bus
*/
mdss_bus_bandwidth_ctrl(1);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
mdss_dsi_clk_ctrl(ctrl, 1);
if (req->flags & CMD_REQ_RX) {
mdss_dsi_cmdlist_rx(ctrl, req);
ret = ctrl->rx_buf.len;
} else
ret = mdss_dsi_cmdlist_tx(ctrl, req);
mdss_dsi_clk_ctrl(ctrl, 0);
mdss_bus_bandwidth_ctrl(0);
need_lock:
if (from_mdp) /* from pipe_commit */
mdss_dsi_cmd_mdp_start(ctrl);
mutex_unlock(&ctrl->cmd_mutex);
return ret;
}
int mdss_dsi_cmdlist_commit(struct mdss_dsi_ctrl_pdata *ctrl, int from_mdp)
{
struct dcs_cmd_req *req;
struct mdss_panel_info *pinfo;
struct mdss_rect *roi = NULL;
int ret = -EINVAL;
int rc = 0;
if (from_mdp) /* from mdp kickoff */
mutex_lock(&ctrl->cmd_mutex);
req = mdss_dsi_cmdlist_get(ctrl);
MDSS_XLOG(ctrl->ndx, from_mdp, ctrl->mdp_busy, current->pid,
XLOG_FUNC_ENTRY);
/* make sure dsi_cmd_mdp is idle */
mdss_dsi_cmd_mdp_busy(ctrl);
pr_debug("%s: ctrl=%d from_mdp=%d pid=%d\n", __func__,
ctrl->ndx, from_mdp, current->pid);
if (req == NULL)
goto need_lock;
MDSS_XLOG(ctrl->ndx, req->flags, req->cmds_cnt, from_mdp, current->pid);
/*
* mdss interrupt is generated in mdp core clock domain
* mdp clock need to be enabled to receive dsi interrupt
* also, axi bus bandwidth need since dsi controller will
* fetch dcs commands from axi bus
*/
mdss_bus_scale_set_quota(MDSS_HW_DSI0, SZ_1M, SZ_1M);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
mdss_dsi_clk_ctrl(ctrl, DSI_ALL_CLKS, 1);
rc = mdss_iommu_ctrl(1);
if (IS_ERR_VALUE(rc)) {
pr_err("IOMMU attach failed\n");
mutex_unlock(&ctrl->cmd_mutex);
return rc;
}
if (req->flags & CMD_REQ_RX)
ret = mdss_dsi_cmdlist_rx(ctrl, req);
else
ret = mdss_dsi_cmdlist_tx(ctrl, req);
mdss_iommu_ctrl(0);
mdss_dsi_clk_ctrl(ctrl, DSI_ALL_CLKS, 0);
mdss_bus_scale_set_quota(MDSS_HW_DSI0, 0, 0);
need_lock:
MDSS_XLOG(ctrl->ndx, from_mdp, ctrl->mdp_busy, current->pid,
XLOG_FUNC_EXIT);
if (from_mdp) { /* from mdp kickoff */
/*
* when partial update enabled, the roi of pinfo
* is updated before mdp kickoff. Either width or
* height of roi is 0, then it is false kickoff so
* no mdp_busy flag set needed.
* when partial update disabled, mdp_busy flag
* alway set.
*/
pinfo = &ctrl->panel_data.panel_info;
if (pinfo->partial_update_enabled)
roi = &pinfo->roi;
if (!roi || (roi->w != 0 || roi->h != 0))
mdss_dsi_cmd_mdp_start(ctrl);
mutex_unlock(&ctrl->cmd_mutex);
}
return ret;
}
int mdss_dsi_cmdlist_commit(struct mdss_dsi_ctrl_pdata *ctrl, int from_mdp)
{
struct dcs_cmd_req *req;
int ret = -EINVAL;
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OCTA_CMD_FULL_HD_PT_PANEL) || defined (CONFIG_FB_MSM_MIPI_SAMSUNG_OCTA_CMD_WQHD_PT_PANEL)\
|| defined(CONFIG_FB_MSM_MIPI_SAMSUNG_YOUM_CMD_FULL_HD_PT_PANEL)
#ifndef CONFIG_LCD_FORCE_VIDEO_MODE
mdss_mdp_clk_ctrl(1, false);
#endif
#endif
mutex_lock(&ctrl->cmd_mutex);
req = mdss_dsi_cmdlist_get(ctrl);
#if defined (CONFIG_FB_MSM_MDSS_DSI_DBG)
if (req != NULL)
xlog(__func__, req->flags, req->cmds_cnt, ctrl->ndx, from_mdp, ctrl->mdp_busy, current->pid);
#endif
/* make sure dsi_cmd_mdp is idle */
mdss_dsi_cmd_mdp_busy(ctrl);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
if (req == NULL)
goto need_lock;
/*
* mdss interrupt is generated in mdp core clock domain
* mdp clock need to be enabled to receive dsi interrupt
* also, axi bus bandwidth need since dsi controller will
* fetch dcs commands from axi bus
*/
mdss_bus_bandwidth_ctrl(1);
pr_debug("%s: from_mdp=%d pid=%d\n", __func__, from_mdp, current->pid);
mdss_dsi_clk_ctrl(ctrl, 1);
if (req->flags & CMD_REQ_RX)
ret = mdss_dsi_cmdlist_rx(ctrl, req);
else if (req->flags & CMD_REQ_SINGLE_TX)
ret = mdss_dsi_cmds_single_tx(ctrl,req->cmds,req->cmds_cnt);
else
ret = mdss_dsi_cmdlist_tx(ctrl, req);
mdss_dsi_clk_ctrl(ctrl, 0);
mdss_bus_bandwidth_ctrl(0);
need_lock:
if (from_mdp) /* from pipe_commit */
mdss_dsi_cmd_mdp_start(ctrl);
#if defined (CONFIG_FB_MSM_MDSS_DSI_DBG)
xlog(__func__, 0, ctrl->ndx, from_mdp, ctrl->mdp_busy, 0x222, current->pid);
#endif
mutex_unlock(&ctrl->cmd_mutex);
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OCTA_CMD_FULL_HD_PT_PANEL) || defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OCTA_CMD_WQHD_PT_PANEL)\
|| defined(CONFIG_FB_MSM_MIPI_SAMSUNG_YOUM_CMD_FULL_HD_PT_PANEL)
#ifndef CONFIG_LCD_FORCE_VIDEO_MODE
mdss_mdp_clk_ctrl(0, false);
#endif
#endif
pr_debug("%s : -- \n",__func__);
return ret;
}