/* EMC workaround for LCM hang after ESD test */
void mipi_novatek_set_prevent_esd(struct msm_fb_data_type *mfd)
{
htc_mdp_sem_down(current, &mfd->dma->mutex);
mipi_dsi_op_mode_config(DSI_CMD_MODE);
mipi_dsi_cmds_tx(&novatek_tx_buf, prevent_esd_cmds,
ARRAY_SIZE(prevent_esd_cmds));
htc_mdp_sem_up(&mfd->dma->mutex);
}
static void mipi_sony_display_on(struct msm_fb_data_type *mfd)
{
PR_DISP_DEBUG("%s+\n", __func__);
htc_mdp_sem_down(current, &mfd->dma->mutex);
mipi_dsi_op_mode_config(DSI_CMD_MODE);
mipi_dsi_cmds_tx(mfd, &sony_tx_buf, sony_display_on_cmds,
ARRAY_SIZE(sony_display_on_cmds));
htc_mdp_sem_up(&mfd->dma->mutex);
}
static int mipi_dsi_set_backlight(struct msm_fb_data_type *mfd)
{
struct mipi_panel_info *mipi;
mipi = &mfd->panel_info.mipi;
if (mipi_status == 0 || bl_level_prevset == mfd->bl_level) {
PR_DISP_DEBUG("Skip the backlight setting > mipi_status : %d, bl_level_prevset : %d, bl_level : %d\n",
mipi_status, bl_level_prevset, mfd->bl_level);
goto end;
}
led_pwm1[1] = protou_shrink_pwm(mfd->bl_level);
if (mfd->bl_level == 0 || board_mfg_mode() == 4 ||
(board_mfg_mode() == 5 && !(htc_battery_get_zcharge_mode() % 2))) {
led_pwm1[1] = 0;
}
htc_mdp_sem_down(current, &mfd->dma->mutex);
if (mipi->mode == DSI_VIDEO_MODE) {
if (panel_type == PANEL_ID_PROTOU_LG) {
/* This is added for LG panel which is needed to use BTA to clear the error happened in driverIC */
MIPI_OUTP(MIPI_DSI_BASE + 0xA8, 0x10000000);
mipi_dsi_cmd_bta_sw_trigger();
/* Need to send blk disable cmd to turn off backlight, or it will change to dim brightness even sending 0 brightness */
if (led_pwm1[1] == 0)
mipi_dsi_cmds_tx(mfd, &protou_panel_tx_buf, lg_bkl_disable_cmds,
ARRAY_SIZE(lg_bkl_disable_cmds));
else if (bl_level_prevset == 0)
mipi_dsi_cmds_tx(mfd, &protou_panel_tx_buf, lg_bkl_enable_cmds,
ARRAY_SIZE(lg_bkl_enable_cmds));
}
mipi_dsi_cmds_tx(mfd, &protou_panel_tx_buf, backlight_cmds,
ARRAY_SIZE(backlight_cmds));
} else {
mipi_dsi_op_mode_config(DSI_CMD_MODE);
mipi_dsi_cmds_tx(mfd, &protou_panel_tx_buf, backlight_cmds,
ARRAY_SIZE(backlight_cmds));
}
htc_mdp_sem_up(&mfd->dma->mutex);
bl_level_prevset = mfd->bl_level;
/* Record the last value which was not zero for resume use */
if (mfd->bl_level >= BRI_SETTING_MIN)
last_brightness = mfd->bl_level;
PR_DISP_INFO("mipi_dsi_set_backlight > set brightness to %d(%d)\n", led_pwm1[1], mfd->bl_level);
end:
return 0;
}
static void protou_display_on(struct msm_fb_data_type *mfd)
{
PR_DISP_INFO("%s+\n", __func__);
#if 0 /* Skip the display_on cmd transfer for LG panel only */
htc_mdp_sem_down(current, &mfd->dma->mutex);
if (mfd->panel_info.type == MIPI_CMD_PANEL) {
mipi_dsi_op_mode_config(DSI_CMD_MODE);
}
mipi_dsi_cmds_tx(mfd, &protou_panel_tx_buf, lg_display_on_cmds,
ARRAY_SIZE(lg_display_on_cmds));
htc_mdp_sem_up(&mfd->dma->mutex);
#endif
}
static int mipi_novatek_lcd_on(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
struct msm_fb_panel_data *pdata = NULL;
struct msm_panel_info *pinfo;
mfd = platform_get_drvdata(pdev);
if (!mfd)
return -ENODEV;
pdata = (struct msm_fb_panel_data *)mfd->pdev->dev.platform_data;
if (mfd->key != MFD_KEY)
return -EINVAL;
pinfo = &mfd->panel_info;
if (pinfo->is_3d_panel)
support_3d = TRUE;
if (mfd->init_mipi_lcd == 0) {
PR_DISP_DEBUG("Display On - 1st time\n");
if (pdata && pdata->panel_type_detect)
pdata->panel_type_detect(&pinfo->mipi);
mfd->init_mipi_lcd = 1;
} else {
PR_DISP_DEBUG("Display On \n");
if (panel_type != PANEL_ID_NONE) {
PR_DISP_INFO("%s\n", ptype);
htc_mdp_sem_down(current, &mfd->dma->mutex);
mipi_dsi_cmds_tx(&novatek_tx_buf, mipi_power_on_cmd,
mipi_power_on_cmd_size);
htc_mdp_sem_up(&mfd->dma->mutex);
#if 0 /* mipi read command verify */
/* clean up ack_err_status */
mipi_dsi_cmd_bta_sw_trigger();
mipi_novatek_manufacture_id(mfd);
#endif
} else {
printk(KERN_ERR "panel_type=0x%x not support at power on\n", panel_type);
return -EINVAL;
}
}
PR_DISP_DEBUG("Init done!\n");
return 0;
}
static int protou_lcd_on(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
struct msm_fb_panel_data *pdata = NULL;
struct mipi_panel_info *mipi;
mfd = platform_get_drvdata(pdev);
if (!mfd)
return -ENODEV;
pdata = (struct msm_fb_panel_data *)mfd->pdev->dev.platform_data;
if (mfd->key != MFD_KEY)
return -EINVAL;
mipi = &mfd->panel_info.mipi;
if (mfd->init_mipi_lcd == 0) {
PR_DISP_INFO("Display On - 1st time\n");
if (panel_type == PANEL_ID_PROTOU_SHARP || panel_type == PANEL_ID_PROTOU_SHARP_C1)
mipi_dsi_cmds_tx(mfd, &protou_panel_tx_buf, protou_power_on_cmd,
protou_power_on_cmd_size);
mfd->init_mipi_lcd = 1;
} else {
PR_DISP_INFO("Display On \n");
if (panel_type != PANEL_ID_NONE) {
PR_DISP_INFO("%s\n", ptype);
htc_mdp_sem_down(current, &mfd->dma->mutex);
mipi_dsi_cmds_tx(mfd, &protou_panel_tx_buf, protou_power_on_cmd,
protou_power_on_cmd_size);
htc_mdp_sem_up(&mfd->dma->mutex);
#if 0 /* mipi read command verify */
/* clean up ack_err_status */
mdelay(1000);
mipi_dsi_cmd_bta_sw_trigger();
protou_manufacture_id(mfd);
#endif
} else {
printk(KERN_ERR "panel_type=0x%x not support at power on\n", panel_type);
return -EINVAL;
}
}
PR_DISP_DEBUG("Init done!\n");
return 0;
}
static void mipi_sony_bkl_ctrl(struct msm_fb_data_type *mfd, bool on)
{
PR_DISP_INFO("mipi_novatek_bkl_ctrl > on = %x\n", on);
htc_mdp_sem_down(current, &mfd->dma->mutex);
if (on) {
mipi_dsi_op_mode_config(DSI_CMD_MODE);
mipi_dsi_cmds_tx(mfd, &sony_tx_buf, sony_bkl_enable_cmds,
ARRAY_SIZE(sony_bkl_enable_cmds));
} else {
mipi_dsi_op_mode_config(DSI_CMD_MODE);
mipi_dsi_cmds_tx(mfd, &sony_tx_buf, sony_bkl_disable_cmds,
ARRAY_SIZE(sony_bkl_disable_cmds));
}
htc_mdp_sem_up(&mfd->dma->mutex);
}
static int mipi_dsi_set_backlight(struct msm_fb_data_type *mfd)
{
struct mipi_panel_info *mipi;
mipi = &mfd->panel_info.mipi;
if (mipi_status == 0)
goto end;
if (mipi_sony_pdata && mipi_sony_pdata->shrink_pwm)
led_pwm1[1] = mipi_sony_pdata->shrink_pwm(mfd->bl_level);
else
led_pwm1[1] = (unsigned char)(mfd->bl_level);
if (mfd->bl_level == 0 || board_mfg_mode() == 4 ||
(board_mfg_mode() == 5 && !(htc_battery_get_zcharge_mode() % 2))) {
led_pwm1[1] = 0;
}
htc_mdp_sem_down(current, &mfd->dma->mutex);
if (mipi->mode == DSI_VIDEO_MODE) {
mipi_dsi_cmd_mode_ctrl(1); /* enable cmd mode */
mipi_dsi_cmds_tx(mfd, &sony_tx_buf, sony_cmd_backlight_cmds,
ARRAY_SIZE(sony_cmd_backlight_cmds));
mipi_dsi_cmd_mode_ctrl(0); /* disable cmd mode */
} else {
mipi_dsi_op_mode_config(DSI_CMD_MODE);
mipi_dsi_cmds_tx(mfd, &sony_tx_buf, sony_cmd_backlight_cmds,
ARRAY_SIZE(sony_cmd_backlight_cmds));
}
htc_mdp_sem_up(&mfd->dma->mutex);
if (led_pwm1[1] != 0)
bl_level_prevset = mfd->bl_level;
PR_DISP_DEBUG("mipi_dsi_set_backlight > set brightness to %d\n", led_pwm1[1]);
end:
return 0;
}
void mdp_dsi_video_update(struct msm_fb_data_type *mfd)
{
struct fb_info *fbi = mfd->fbi;
uint8 *buf;
int bpp;
unsigned long flag;
int irq_block = MDP_DMA2_TERM;
if (!mfd->panel_power_on)
return;
htc_mdp_sem_down(current, &mfd->dma->mutex);
bpp = fbi->var.bits_per_pixel / 8;
buf = (uint8 *) fbi->fix.smem_start;
buf += calc_fb_offset(mfd, fbi, bpp);
MDP_OUTP(MDP_BASE + DMA_P_BASE + 0x8, (uint32) buf);
spin_lock_irqsave(&mdp_spin_lock, flag);
mdp_enable_irq(irq_block);
INIT_COMPLETION(mfd->dma->comp);
mfd->dma->waiting = TRUE;
outp32(MDP_INTR_CLEAR, LCDC_FRAME_START);
mdp_intr_mask |= LCDC_FRAME_START;
outp32(MDP_INTR_ENABLE, mdp_intr_mask);
spin_unlock_irqrestore(&mdp_spin_lock, flag);
wait_for_completion_killable(&mfd->dma->comp);
mdp_disable_irq(irq_block);
htc_mdp_sem_up(&mfd->dma->mutex);
}
static int mipi_dsi_off(struct platform_device *pdev)
{
int ret = 0;
struct msm_fb_data_type *mfd;
struct msm_panel_info *pinfo;
PR_DISP_DEBUG(" %s\n", __func__);
mfd = platform_get_drvdata(pdev);
pinfo = &mfd->panel_info;
if (mdp_rev >= MDP_REV_41)
mutex_lock(&mfd->dma->ov_mutex);
else
htc_mdp_sem_down(current, &mfd->dma->mutex);
mdp4_overlay_dsi_state_set(ST_DSI_SUSPEND);
/*
* Description: dsi clock is need to perform shutdown.
* mdp4_dsi_cmd_dma_busy_wait() will enable dsi clock if disabled.
* also, wait until dma (overlay and dmap) finish.
*/
if (mfd->panel_info.type == MIPI_CMD_PANEL) {
if (mdp_rev >= MDP_REV_41) {
mdp4_dsi_cmd_dma_busy_wait(mfd);
mdp4_dsi_blt_dmap_busy_wait(mfd);
mipi_dsi_mdp_busy_wait(mfd);
} else {
mdp3_dsi_cmd_dma_busy_wait(mfd);
}
}
/*
* Desctiption: change to DSI_CMD_MODE since it needed to
* tx DCS dsiplay off comamnd to panel
*/
mipi_dsi_op_mode_config(DSI_CMD_MODE);
if (mfd->panel_info.type == MIPI_CMD_PANEL) {
if (pinfo->lcd.vsync_enable) {
if (pinfo->lcd.hw_vsync_mode && vsync_gpio >= 0) {
if (MDP_REV_303 != mdp_rev)
gpio_free(vsync_gpio);
}
mipi_dsi_set_tear_off(mfd);
}
}
ret = panel_next_off(pdev);
#ifdef CONFIG_MSM_BUS_SCALING
mdp_bus_scale_update_request(0);
#endif
local_bh_disable();
mipi_dsi_clk_disable();
local_bh_enable();
/* disbale dsi engine */
MIPI_OUTP(MIPI_DSI_BASE + 0x0000, 0);
mipi_dsi_phy_ctrl(0);
local_bh_disable();
mipi_dsi_ahb_ctrl(0);
local_bh_enable();
if (mipi_dsi_pdata && mipi_dsi_pdata->dsi_power_save)
mipi_dsi_pdata->dsi_power_save(0);
if (mdp_rev >= MDP_REV_41)
mutex_unlock(&mfd->dma->ov_mutex);
else
htc_mdp_sem_up(&mfd->dma->mutex);
return ret;
}
static int mipi_dsi_off(struct platform_device *pdev)
{
int ret = 0;
struct msm_fb_data_type *mfd;
struct msm_panel_info *pinfo;
mfd = platform_get_drvdata(pdev);
pinfo = &mfd->panel_info;
if (mdp_rev >= MDP_REV_41)
mutex_lock(&mfd->dma->ov_mutex);
else
htc_mdp_sem_down(current, &mfd->dma->mutex);
mdp4_overlay_dsi_state_set(ST_DSI_SUSPEND);
mipi_dsi_clk_cfg(1);
mipi_dsi_cmd_mdp_busy();
mipi_dsi_op_mode_config(DSI_CMD_MODE);
if (mfd->panel_info.type == MIPI_CMD_PANEL) {
if (pinfo->lcd.vsync_enable) {
if (pinfo->lcd.hw_vsync_mode && vsync_gpio >= 0) {
if (MDP_REV_303 != mdp_rev)
gpio_free(vsync_gpio);
}
mipi_dsi_set_tear_off(mfd);
}
}
if (panel_type != PANEL_ID_PROTOU_LG && panel_type != PANEL_ID_PROTODCG_LG)
ret = panel_next_off(pdev);
#ifdef CONFIG_MSM_BUS_SCALING
mdp_bus_scale_update_request(0);
#endif
spin_lock_bh(&dsi_clk_lock);
mipi_dsi_clk_disable();
MIPI_OUTP(MIPI_DSI_BASE + 0x0000, 0);
mipi_dsi_phy_ctrl(0);
mipi_dsi_ahb_ctrl(0);
spin_unlock_bh(&dsi_clk_lock);
mipi_dsi_unprepare_clocks();
if (mipi_dsi_pdata && mipi_dsi_pdata->dsi_power_save)
mipi_dsi_pdata->dsi_power_save(0);
if (mdp_rev >= MDP_REV_41)
mutex_unlock(&mfd->dma->ov_mutex);
else
htc_mdp_sem_up(&mfd->dma->mutex);
pr_debug("%s-:\n", __func__);
return ret;
}
