void mdp4_dsi_cmd_kickoff_video(struct msm_fb_data_type *mfd,
struct mdp4_overlay_pipe *pipe)
{
/*
* a video kickoff may happen before UI kickoff after
* blt enabled. mdp4_overlay_update_dsi_cmd() need
* to be called before kickoff.
* vice versa for blt disabled.
*/
#ifdef FACTORY_TEST
if (!is_lcd_connected)
return;
#endif
if (dsi_pipe->blt_addr && dsi_pipe->blt_cnt == 0)
mdp4_overlay_update_dsi_cmd(mfd); /* first time */
else if (dsi_pipe->blt_addr == 0 && dsi_pipe->blt_cnt) {
mdp4_overlay_update_dsi_cmd(mfd); /* last time */
dsi_pipe->blt_cnt = 0;
}
pr_debug("%s: blt_addr=%d blt_cnt=%d\n",
__func__, (int)dsi_pipe->blt_addr, dsi_pipe->blt_cnt);
if (dsi_pipe->blt_addr)
mdp4_dsi_blt_dmap_busy_wait(dsi_mfd);
mdp4_dsi_cmd_overlay_kickoff(mfd, pipe);
}
int mdp4_dsi_cmd_on(struct platform_device *pdev)
{
int ret = 0;
int cndx = 0;
struct msm_fb_data_type *mfd;
struct vsycn_ctrl *vctrl;
pr_debug("%s+: pid=%d\n", __func__, current->pid);
mfd = (struct msm_fb_data_type *)platform_get_drvdata(pdev);
mfd->cont_splash_done = 1;
mutex_lock(&mfd->dma->ov_mutex);
vctrl = &vsync_ctrl_db[cndx];
vctrl->mfd = mfd;
vctrl->dev = mfd->fbi->dev;
vctrl->vsync_enabled = 0;
mdp_clk_ctrl(1);
mdp4_overlay_update_dsi_cmd(mfd);
mdp_clk_ctrl(0);
mdp4_iommu_attach();
atomic_set(&vctrl->suspend, 0);
mutex_unlock(&mfd->dma->ov_mutex);
pr_debug("%s-:\n", __func__);
return ret;
}
void mdp4_dsi_cmd_overlay(struct msm_fb_data_type *mfd)
{
if(dsi_pipe && dsi_pipe->is_3d) {
mdp4_overlay_handle_padding(mfd, true);
}
mutex_lock(&mfd->dma->ov_mutex);
if (mfd && mfd->panel_power_on) {
mdp4_dsi_cmd_dma_busy_wait(mfd, dsi_pipe);
if (dsi_pipe && dsi_pipe->blt_addr)
mdp4_dsi_blt_dmap_busy_wait(mfd);
mdp4_overlay_update_dsi_cmd(mfd);
if (mfd->esd_fixup) {
mutex_unlock(&mfd->dma->ov_mutex);
mfd->esd_fixup((uint32_t)mfd);
mutex_lock(&mfd->dma->ov_mutex);
}
mdp4_dsi_cmd_kickoff_ui(mfd, dsi_pipe);
mdp4_stat.kickoff_dsi++;
/* signal if pan function is waiting for the update completion */
if (mfd->pan_waiting) {
mfd->pan_waiting = FALSE;
complete(&mfd->pan_comp);
}
}
/* mask to work-around to fix camera preview issue */
mdp4_overlay_resource_release();
mutex_unlock(&mfd->dma->ov_mutex);
}
void mdp4_dsi_cmd_overlay(struct msm_fb_data_type *mfd)
{
mutex_lock(&mfd->dma->ov_mutex);
if (mfd && mfd->panel_power_on) {
mdp4_dsi_cmd_dma_busy_wait(mfd);
if (dsi_pipe && dsi_pipe->blt_addr)
mdp4_dsi_blt_dmap_busy_wait(mfd);
mdp4_overlay_update_dsi_cmd(mfd);
mdp4_dsi_cmd_kickoff_ui(mfd, dsi_pipe);
mdp4_stat.kickoff_dsi++;
/* signal if pan function is waiting for the update completion */
if (mfd->pan_waiting) {
mfd->pan_waiting = FALSE;
complete(&mfd->pan_comp);
}
}
mdp4_overlay_resource_release();
mutex_unlock(&mfd->dma->ov_mutex);
}
int mdp4_dsi_cmd_on(struct platform_device *pdev)
{
int ret = 0;
int cndx = 0;
struct msm_fb_data_type *mfd;
struct vsycn_ctrl *vctrl;
pr_info("%s+:\n", __func__);
mfd = (struct msm_fb_data_type *)platform_get_drvdata(pdev);
vctrl = &vsync_ctrl_db[cndx];
vctrl->dev = mfd->fbi->dev;
mdp_clk_ctrl(1);
if (vctrl->base_pipe == NULL)
mdp4_overlay_update_dsi_cmd(mfd);
mdp4_iommu_attach();
atomic_set(&vctrl->suspend, 0);
pr_info("%s-:\n", __func__);
return ret;
}
void mdp4_dsi_cmd_kickoff_video(struct msm_fb_data_type *mfd,
struct mdp4_overlay_pipe *pipe)
{
if (dsi_pipe->blt_addr && dsi_pipe->blt_cnt == 0)
mdp4_overlay_update_dsi_cmd(mfd);
mdp4_dsi_cmd_overlay_kickoff(mfd, pipe);
}
void mdp4_dsi_cmd_kickoff_video(struct msm_fb_data_type *mfd,
struct mdp4_overlay_pipe *pipe)
{
if (dsi_pipe->blt_addr && dsi_pipe->blt_cnt == 0)
mdp4_overlay_update_dsi_cmd(mfd);
pr_debug("%s: pid=%d\n", __func__, current->pid);
mdp4_dsi_cmd_overlay_kickoff(mfd, pipe);
}
void mdp4_dsi_cmd_vsync_ctrl(struct fb_info *info, int enable)
{
#ifdef CONFIG_HUAWEI_KERNEL
struct msm_fb_data_type *mfd = (struct msm_fb_data_type *) info->par;
static int old_imgType = -1;
#endif
struct vsycn_ctrl *vctrl;
unsigned long flags;
int cndx = 0;
int clk_set_on = 0;
vctrl = &vsync_ctrl_db[cndx];
mutex_lock(&vctrl->update_lock);
pr_debug("%s: clk_enabled=%d vsync_enabled=%d req=%d\n", __func__,
vctrl->clk_enabled, vctrl->vsync_enabled, enable);
if (vctrl->vsync_enabled == enable) {
mutex_unlock(&vctrl->update_lock);
return;
}
vctrl->vsync_enabled = enable;
if (enable) {
spin_lock_irqsave(&vctrl->spin_lock, flags);
vctrl->clk_control = 0;
vctrl->expire_tick = 0;
spin_unlock_irqrestore(&vctrl->spin_lock, flags);
if (vctrl->clk_enabled == 0) {
pr_debug("%s: SET_CLK_ON\n", __func__);
mipi_dsi_clk_cfg(1);
mdp_clk_ctrl(1);
vctrl->clk_enabled = 1;
vctrl->new_update = 1;
clk_set_on = 1;
}
if (clk_set_on) {
vsync_irq_enable(INTR_PRIMARY_RDPTR,
MDP_PRIM_RDPTR_TERM);
}
/*baseline 1.5 to 1.7 be deleted,we believe it's Qual's bug*/
#ifdef CONFIG_HUAWEI_KERNEL
if( mfd->fb_imgType != old_imgType)
{
old_imgType = mfd->fb_imgType;
mdp4_overlay_update_dsi_cmd(mfd);
}
#endif
} else {
spin_lock_irqsave(&vctrl->spin_lock, flags);
vctrl->expire_tick = VSYNC_EXPIRE_TICK;
spin_unlock_irqrestore(&vctrl->spin_lock, flags);
}
mutex_unlock(&vctrl->update_lock);
}
void mdp4_dsi_cmd_overlay_restore(void)
{
/* mutex holded by caller */
if (dsi_mfd && dsi_pipe) {
mdp4_dsi_cmd_dma_busy_wait(dsi_mfd);
mipi_dsi_mdp_busy_wait(dsi_mfd);
mdp4_overlay_update_dsi_cmd(dsi_mfd);
mdp4_dsi_cmd_overlay_kickoff(dsi_mfd, dsi_pipe);
}
}
void mdp4_dsi_cmd_kickoff_video(struct msm_fb_data_type *mfd,
struct mdp4_overlay_pipe *pipe)
{
/*
* a video kickoff may happen before UI kickoff after
* blt enabled. mdp4_overlay_update_dsi_cmd() need
* to be called before kickoff.
* vice versa for blt disabled.
*/
if (dsi_pipe->ov_blt_addr && dsi_pipe->blt_cnt == 0)
mdp4_overlay_update_dsi_cmd(mfd); /* first time */
else if (dsi_pipe->ov_blt_addr == 0 && dsi_pipe->blt_cnt) {
mdp4_overlay_update_dsi_cmd(mfd); /* last time */
dsi_pipe->blt_cnt = 0;
}
pr_debug("%s: ov_blt_addr=%d blt_cnt=%d\n",
__func__, (int)dsi_pipe->ov_blt_addr, dsi_pipe->blt_cnt);
mdp4_dsi_cmd_overlay_kickoff(mfd, pipe);
}
void mdp4_dsi_cmd_kickoff_video(struct msm_fb_data_type *mfd,
struct mdp4_overlay_pipe *pipe)
{
#ifdef OVDEBUG
printk(KERN_INFO "%s: pid=%d\n", __func__, current->pid);
#endif
if (dsi_pipe->blt_addr && dsi_pipe->blt_cnt == 0)
mdp4_overlay_update_dsi_cmd(mfd);
if (dsi_pipe->blt_addr)
mdp4_dsi_blt_dmap_busy_wait(dsi_mfd);
mdp4_dsi_cmd_overlay_kickoff(mfd, pipe);
}
void mdp4_dsi_cmd_overlay_restore(void)
{
#ifdef OVDEBUG
printk("%s: start, pid=%d\n", __func__, current->pid);
#endif
/* mutex holded by caller */
if (dsi_mfd && dsi_pipe) {
mdp4_dsi_cmd_dma_busy_wait(dsi_mfd, dsi_pipe);
mdp4_overlay_update_dsi_cmd(dsi_mfd);
if (dsi_pipe->blt_addr)
mdp4_dsi_blt_dmap_busy_wait(dsi_mfd);
mdp4_dsi_cmd_overlay_kickoff(dsi_mfd, dsi_pipe);
}
}
void mdp4_dsi_cmd_overlay_restore(void)
{
#ifdef OVDEBUG
printk(KERN_INFO "%s: start, pid=%d\n", __func__, current->pid);
#endif
/* mutex holded by caller */
if (dsi_mfd && dsi_pipe) {
mdp4_dsi_cmd_dma_busy_wait(dsi_mfd, dsi_pipe);
mdp4_overlay_update_dsi_cmd(dsi_mfd);
/* FIXME: check blt_end flag is needed or not */
if (dsi_pipe->blt_addr && dsi_pipe->blt_end == 0)
mdp4_dsi_blt_dmap_busy_wait(dsi_mfd);
mdp4_dsi_cmd_overlay_kickoff(dsi_mfd, dsi_pipe);
}
}
void mdp4_dsi_cmd_overlay_restore(void)
{
#ifdef FACTORY_TEST
if (!is_lcd_connected)
return;
#endif
/* mutex holded by caller */
if (dsi_mfd && dsi_pipe) {
mdp4_dsi_cmd_dma_busy_wait(dsi_mfd);
mipi_dsi_mdp_busy_wait(dsi_mfd);
mdp4_overlay_update_dsi_cmd(dsi_mfd);
if (dsi_pipe->blt_addr)
mdp4_dsi_blt_dmap_busy_wait(dsi_mfd);
mdp4_dsi_cmd_overlay_kickoff(dsi_mfd, dsi_pipe);
}
}
void mdp4_dsi_cmd_overlay(struct msm_fb_data_type *mfd)
{
if (atomic_read(&ov_unset)) {
PR_DISP_INFO("%s(%d)found ov unset is called, skip frame update\n", __func__, __LINE__);
return;
}
if (dsi_pipe && dsi_pipe->is_3d) {
atomic_set(&ov_play, 1);
if (mfd && mfd->enable_uipadding == PADDING_ENABLE)
mdp4_overlay_handle_padding(mfd, true);
}
if (mfd->esd_fixup)
mfd->esd_fixup((uint32_t)mfd);
mutex_lock(&mfd->dma->ov_mutex);
if (mfd && mfd->panel_power_on) {
mdp4_dsi_cmd_dma_busy_wait(mfd, dsi_pipe);
if (dsi_pipe && dsi_pipe->blt_addr)
mdp4_dsi_blt_dmap_busy_wait(mfd);
mdp4_overlay_update_dsi_cmd(mfd);
mdp4_dsi_cmd_kickoff_ui(mfd, dsi_pipe);
mdp4_stat.kickoff_dsi++;
/* signal if pan function is waiting for the update completion */
if (mfd->pan_waiting) {
mfd->pan_waiting = FALSE;
complete(&mfd->pan_comp);
}
}
/* mask to work-around to fix camera preview issue */
mdp4_overlay_resource_release();
mutex_unlock(&mfd->dma->ov_mutex);
if (dsi_pipe && dsi_pipe->is_3d) {
atomic_set(&ov_play, 0);
if (atomic_read(&ov_unset)) {
PR_DISP_INFO("%s(%d) ov play finished completion ov_comp\n", __func__, __LINE__);
complete(&ov_comp);
}
}
}
int mdp4_dsi_cmd_on(struct platform_device *pdev)
{
int ret = 0;
int cndx = 0;
struct msm_fb_data_type *mfd;
struct vsycn_ctrl *vctrl;
pr_debug("%s+: pid=%d\n", __func__, current->pid);
mfd = (struct msm_fb_data_type *)platform_get_drvdata(pdev);
mfd->cont_splash_done = 1;
vctrl = &vsync_ctrl_db[cndx];
vctrl->mfd = mfd;
vctrl->dev = mfd->fbi->dev;
mdp_clk_ctrl(1);
mdp4_overlay_update_dsi_cmd(mfd);
mdp_clk_ctrl(0);
mdp4_iommu_attach();
atomic_set(&vctrl->suspend, 0);
if (!vctrl->sysfs_created) {
ret = sysfs_create_group(&vctrl->dev->kobj,
&vsync_fs_attr_group);
if (ret) {
pr_err("%s: sysfs group creation failed, ret=%d\n",
__func__, ret);
return ret;
}
kobject_uevent(&vctrl->dev->kobj, KOBJ_ADD);
pr_debug("%s: kobject_uevent(KOBJ_ADD)\n", __func__);
vctrl->sysfs_created = 1;
}
pr_debug("%s-:\n", __func__);
return ret;
}
void mdp4_dsi_cmd_overlay(struct msm_fb_data_type *mfd)
{
mutex_lock(&mfd->dma->ov_mutex);
if ((mfd) && (!mfd->dma->busy) && (mfd->panel_power_on)) {
mdp4_overlay_update_dsi_cmd(mfd);
mdp4_dsi_cmd_overlay_kickoff(mfd, dsi_pipe);
mdp4_stat.kickoff_dsi++;
/* signal if pan function is waiting for the update completion */
if (mfd->pan_waiting) {
mfd->pan_waiting = FALSE;
complete(&mfd->pan_comp);
}
}
mutex_unlock(&mfd->dma->ov_mutex);
}
void mdp4_dsi_cmd_overlay(struct msm_fb_data_type *mfd)
{
if (!mfd)
return;
mutex_lock(&mfd->dma->ov_mutex);
if (mfd->panel_power_on) {
mdp4_dsi_cmd_dma_busy_wait(mfd);
mdp4_overlay_update_dsi_cmd(mfd);
mdp4_dsi_cmd_kickoff_ui(mfd, dsi_pipe);
mdp4_iommu_unmap(dsi_pipe);
/* signal if pan function is waiting for the update completion */
if (mfd->pan_waiting) {
mfd->pan_waiting = FALSE;
complete(&mfd->pan_comp);
}
}
mutex_unlock(&mfd->dma->ov_mutex);
}
int mdp4_dsi_cmd_on(struct platform_device *pdev)
{
int ret = 0;
int cndx = 0;
struct msm_fb_data_type *mfd;
struct vsycn_ctrl *vctrl;
pr_debug("%s+: pid=%d\n", __func__, current->pid);
mfd = (struct msm_fb_data_type *)platform_get_drvdata(pdev);
#ifdef CONFIG_F_SKYDISP_QCBUGFIX_CONTINUOUS_SPLASH_SCREEN // 20121217, kkcho, for sleep_current
if (!(mfd->cont_splash_done)) {
mfd->cont_splash_done = 1;
/* Clks are enabled in probe.
Disabling clocks now */
mdp_clk_ctrl(0);
}
#else
mfd->cont_splash_done = 1;
#endif
vctrl = &vsync_ctrl_db[cndx];
vctrl->mfd = mfd;
vctrl->dev = mfd->fbi->dev;
mdp_clk_ctrl(1);
mdp4_overlay_update_dsi_cmd(mfd);
mdp_clk_ctrl(0);
mdp4_iommu_attach();
atomic_set(&vctrl->suspend, 0);
pr_debug("%s-:\n", __func__);
return ret;
}
