static uint32 mipi_himax_manufacture_id(void)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
uint32 *lp;
int i;
char *cp;
tp = &himax_tx_buf;
rp = &himax_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &himax_manufacture_id_cmd;
mipi_dsi_cmds_rx(tp, rp, cmd, 3);
cp = (char *)rp->data;
PR_DISP_DEBUG("rx-data: ");
for (i = 0; i < rp->len; i++, cp++)
PR_DISP_DEBUG("%x ", *cp);
PR_DISP_DEBUG("\n");
lp = (uint32 *)rp->data;
PR_DISP_DEBUG("%s: manu_id=%x", __func__, *lp);
return *lp;
}
static int k2_lcd_on(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
struct mipi_panel_info *mipi;
struct msm_panel_info *pinfo;
mfd = platform_get_drvdata(pdev);
if (!mfd)
return -ENODEV;
if (mfd->key != MFD_KEY)
return -EINVAL;
pinfo = &mfd->panel_info;
mipi = &mfd->panel_info.mipi;
if (mfd->init_mipi_lcd == 0) {
PR_DISP_DEBUG("Display On - 1st time\n");
mfd->init_mipi_lcd = 1;
return 0;
}
PR_DISP_INFO("Display On.\n");
mipi_dsi_cmds_tx(&k2_panel_tx_buf, init_on_cmds,
init_on_cmds_count);
atomic_set(&lcd_power_state, 1);
PR_DISP_DEBUG("Init done!\n");
return 0;
}
static int icm_thread(void *data)
{
struct mdp_lcdc_info *lcdc;
struct msm_lcdc_panel_ops *panel_ops;
int rc;
unsigned long irq_flags = 0;
lcdc = data;
panel_ops = lcdc->pdata->panel_ops;
while (1) {
rc = wait_event_timeout(panel_update_wait_queue, icm_check_panel_update() == 1, PANEL_ENTER_IDLE_TIMEOUT);
ICM_DBG("ICM Thread:wake up rc=%d \n", rc);
mutex_lock(&panel_icm->icm_lock);
if (rc == 0 && icm_check_panel_update() != 1) {/* wait_timeout */
ICM_DBG("EnterICM: icm_mode=%d icm_doable=%d \n", panel_icm->icm_mode, panel_icm->icm_doable);
if (panel_icm->icm_mode == false && panel_icm->icm_doable == true) {
if (panel_ops->refresh_enable)
panel_ops->refresh_enable(panel_ops);
panel_icm->icm_mode = true;
msleep(PANEL_IDLE_STABLE_TIMEOUT);
mdp_writel(lcdc->mdp, 0, MDP_LCDC_EN);
clk_disable(lcdc->pad_pclk);
clk_disable(lcdc->pclk);
clk_disable(lcdc->mdp_clk);
panel_icm->clock_enabled = false;
PR_DISP_DEBUG("EnterICM: enter ICM MODE done!!!\n");
}
} else {/* get update event, no timeout */
ICM_DBG("Leave ICM: icm_mode=%d icm_doable=%d \n", panel_icm->icm_mode, panel_icm->icm_doable);
if (panel_icm->icm_mode == true && panel_icm->icm_doable == true) {
clk_enable(lcdc->mdp_clk);
clk_enable(lcdc->pclk);
clk_enable(lcdc->pad_pclk);
mdp_writel(lcdc->mdp, 1, MDP_LCDC_EN);
panel_icm->clock_enabled = true;
if (panel_ops->refresh_disable)
panel_ops->refresh_disable(panel_ops);
panel_icm->icm_mode = false;
PR_DISP_DEBUG("LeaveICM: leave ICM MODE done !!!\n");
}
spin_lock_irqsave(&panel_icm->lock, irq_flags);
panel_icm->panel_update = 0;
spin_unlock_irqrestore(&panel_icm->lock, irq_flags);
}
mutex_unlock(&panel_icm->icm_lock);
} /* end while */
return 0;
}
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 void k2_dim_on(struct msm_fb_data_type *mfd)
{
if (atomic_read(&lcd_backlight_off)) {
PR_DISP_DEBUG("%s: backlight is off. Skip dimming setting\n", __func__);
return;
}
PR_DISP_DEBUG("%s\n", __FUNCTION__);
cmdreq.cmds = novatek_dim_on_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(novatek_dim_on_cmds);
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq);
}
static int
cabc_bl_handle(struct platform_device *pdev, int brightness)
{
struct cabc *cabc = platform_get_drvdata(pdev);
struct led_classdev *lcd_cdev;
if (unlikely(cabc == NULL)) {
PR_DISP_ERR("%s: do not have cabc data\n", __func__);
return -ENOENT;
}
PR_DISP_DEBUG("turn %s backlight.\n",
brightness == LED_FULL ? "on" : "off");
lcd_cdev = &cabc->lcd_backlight;
wake_lock(&cabc->wakelock);
if (brightness != LED_FULL) {
/* enter screen off */
} else {
__set_brightness(cabc, (g_brightness >= 0 && g_brightness <= LED_FULL)?
g_brightness : LED_FULL, 0);
}
wake_unlock(&cabc->wakelock);
return 0;
}
static int
himax_change_cabcmode(struct msm_mddi_client_data *client_data,
int mode, u8 dimming)
{
PR_DISP_DEBUG("+%s, mode=%d, dimming=%d\n", __func__, mode, dimming);
return 0;
}
static int mipi_orise_lcd_on(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
struct mipi_panel_info *mipi;
struct msm_panel_info *pinfo;
mfd = platform_get_drvdata(pdev);
if (!mfd)
return -ENODEV;
if (mfd->key != MFD_KEY)
return -EINVAL;
pinfo = &mfd->panel_info;
mipi = &mfd->panel_info.mipi;
if (mfd->init_mipi_lcd == 0) {
mfd->init_mipi_lcd = 1;
return 0;
}
PR_DISP_DEBUG("Display On \n");
if (mipi->mode == DSI_VIDEO_MODE) {
mipi_dsi_cmds_tx(&orise_tx_buf, orise_video_on_cmds,
ARRAY_SIZE(orise_video_on_cmds));
} else {
mipi_dsi_cmds_tx(&orise_tx_buf, orise_cmd_on_cmds,
ARRAY_SIZE(orise_cmd_on_cmds));
}
atomic_set(&lcd_power_state, 1);
return 0;
}
static inline void ville_mipi_dsi_set_backlight(struct msm_fb_data_type *mfd)
{
struct mipi_panel_info *mipi;
mipi = &mfd->panel_info.mipi;
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2)
ville_shrink_pwm_c2(mfd->bl_level);
else if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG)
ville_shrink_pwm(mfd->bl_level);
#if 0
if (mdp4_overlay_dsi_state_get() <= ST_DSI_SUSPEND) {
mutex_unlock(&mfd->dma->ov_mutex);
return;
}
#endif
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG || panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2) {
cmdreq.cmds = samsung_cmd_backlight_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(samsung_cmd_backlight_cmds);
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq);
}
PR_DISP_DEBUG("%s+ bl_level=%d\n", __func__, mfd->bl_level);
return;
}
/*----------------------------------------------------------------------------*/
static int express_adjust_backlight(enum led_brightness val)
{
uint8_t shrink_br = 0;
uint8_t data[4] = { /* PWM setting of microp, see p.8 */
0x05, /* Fading time; suggested: 5/10/15/20/25 */
val, /* Duty Cycle */
0x00, /* Channel H byte */
0x20, /* Channel L byte */
};
if(val == 0)
data[0] = 0;
mutex_lock(&panel_lock);
shrink_br = express_shrink_pwm(val, PWM_USER_DEF,
PWM_USER_MIN, PWM_USER_MAX, PWM_SAM_DEF,
PWM_SAM_MIN, PWM_SAM_MAX);
data[1] = shrink_br;
PR_DISP_DEBUG("[lcm](%d), shrink_br=%d\n", val, shrink_br);
microp_i2c_write(0x25, data, sizeof(data));
last_val = shrink_br ? shrink_br: last_val;
mutex_unlock(&panel_lock);
#if 0
return shrink_br;
#else
return val;
#endif
}
void mdp4_lcdc_overlay_blt(struct msm_fb_data_type *mfd,
struct msmfb_overlay_blt *req)
{
unsigned long flag;
int change = 0;
spin_lock_irqsave(&mdp_spin_lock, flag);
if (req->enable && lcdc_pipe->blt_addr == 0) {
lcdc_pipe->blt_addr = lcdc_pipe->blt_base;
change++;
} else if (req->enable == 0 && lcdc_pipe->blt_addr) {
lcdc_pipe->blt_addr = 0;
change++;
}
PR_DISP_DEBUG("%s: blt_addr=%x\n", __func__, (int)lcdc_pipe->blt_addr);
lcdc_pipe->blt_cnt = 0;
spin_unlock_irqrestore(&mdp_spin_lock, flag);
if (!change)
return;
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
MDP_OUTP(MDP_BASE + LCDC_BASE, 0); /* stop lcdc */
msleep(50);
mdp4_overlayproc_cfg(lcdc_pipe);
mdp4_overlay_dmap_xy(lcdc_pipe);
MDP_OUTP(MDP_BASE + LCDC_BASE, 1); /* start lcdc */
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
}
static inline void mipi_dsi_set_backlight(struct msm_fb_data_type *mfd)
{
struct mipi_panel_info *mipi;
mipi = &mfd->panel_info.mipi;
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2)
ville_shrink_pwm_c2(mfd->bl_level);
else if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG)
ville_shrink_pwm(mfd->bl_level);
mutex_lock(&mfd->dma->ov_mutex);
/* Remove the check first for impact MFG test. Command by adb to set backlight not work */
#if 0
if (mdp4_overlay_dsi_state_get() <= ST_DSI_SUSPEND) {
mutex_unlock(&mfd->dma->ov_mutex);
return;
}
#endif
if (mfd->panel_info.type == MIPI_CMD_PANEL) {
mdp4_dsi_cmd_dma_busy_wait(mfd);
mdp4_dsi_blt_dmap_busy_wait(mfd);
mipi_dsi_mdp_busy_wait(mfd);
}
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG || panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2)
mipi_dsi_cmds_tx(mfd, &ville_panel_tx_buf, samsung_cmd_backlight_cmds,
ARRAY_SIZE(samsung_cmd_backlight_cmds));
PR_DISP_DEBUG("%s+ bl_level=%d\n", __func__, mfd->bl_level);
mutex_unlock(&mfd->dma->ov_mutex);
return;
}
static inline void ville_mipi_dsi_set_backlight(struct msm_fb_data_type *mfd)
{
struct mipi_panel_info *mipi;
mipi = &mfd->panel_info.mipi;
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2)
ville_shrink_pwm_c2(mfd->bl_level);
else if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG)
ville_shrink_pwm(mfd->bl_level);
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG || panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2) {
cmdreq.cmds = samsung_cmd_backlight_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(samsung_cmd_backlight_cmds);
cmdreq.flags = CMD_REQ_COMMIT| CMD_CLK_CTRL;
if (mfd && mfd->panel_info.type == MIPI_CMD_PANEL)
cmdreq.flags |= CMD_CLK_CTRL;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq);
}
PR_DISP_DEBUG("%s+ bl_level=%d\n", __func__, mfd->bl_level);
return;
}
static unsigned char shooter_shrink_pwm(int val)
{
if (val <= 0) {
shrink_br = 0;
} else if (val > 0 && (val < BRI_SETTING_MIN)) {
shrink_br = PWM_MIN;
} else if ((val >= BRI_SETTING_MIN) && (val <= BRI_SETTING_DEF)) {
shrink_br = (val - BRI_SETTING_MIN) * (PWM_DEFAULT - PWM_MIN) /
(BRI_SETTING_DEF - BRI_SETTING_MIN) + PWM_MIN;
} else if (val > BRI_SETTING_DEF && val <= BRI_SETTING_MAX) {
shrink_br = (val - BRI_SETTING_DEF) * (PWM_MAX - PWM_DEFAULT) /
(BRI_SETTING_MAX - BRI_SETTING_DEF) + PWM_DEFAULT;
} else if (val > BRI_SETTING_MAX)
shrink_br = PWM_MAX;
if (atomic_read(&g_3D_mode) != BARRIER_OFF && shrink_br != 0)
shrink_br = 255;
else
last_br_2d = val;
PR_DISP_DEBUG("brightness orig=%d, transformed=%d\n", val, shrink_br);
return shrink_br;
}
static void zara_set_backlight(struct msm_fb_data_type *mfd)
{
led_pwm[1] = zara_shrink_pwm((unsigned char)(mfd->bl_level));
if (atomic_read(&lcd_power_state) == 0) {
PR_DISP_DEBUG("%s: LCD is off. Skip backlight setting\n", __func__);
return;
}
if (led_pwm[1] == 0) {
cmdreq.cmds = novatek_dim_off_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(novatek_dim_off_cmds);
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq);
}
cmdreq.cmds = lg_novatek_cmd_backlight_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(lg_novatek_cmd_backlight_cmds);
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq);
return;
}
static int mipi_himax_lcd_off(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
mfd = platform_get_drvdata(pdev);
PR_DISP_DEBUG("%s\n", __func__);
if (!mfd)
return -ENODEV;
if (mfd->key != MFD_KEY)
return -EINVAL;
mutex_lock(&cmdlock);
#if defined CONFIG_FB_MSM_SELF_REFRESH
#ifdef CONFIG_PERFLOCK
if (!is_perf_lock_active(&himax_perf_lock))
perf_lock(&himax_perf_lock);
#endif
#endif
mipi_dsi_cmds_tx(&himax_tx_buf, himax_display_off_cmd1,
ARRAY_SIZE(himax_display_off_cmd1));
mipi_dsi_cmds_tx(&himax_tx_buf, himax_display_off_cmd2,
ARRAY_SIZE(himax_display_off_cmd2));
#if defined CONFIG_FB_MSM_SELF_REFRESH
#ifdef CONFIG_PERFLOCK
if (is_perf_lock_active(&himax_perf_lock))
perf_unlock(&himax_perf_lock);
#endif
#endif
mutex_unlock(&cmdlock);
return 0;
}
static unsigned char shooter_u_shrink_pwm(int val)
{
if (val <= 0) {
shrink_br = 0;
} else if (val > 0 && (val < BRI_SETTING_MIN)) {
shrink_br = PWM_MIN;
} else if ((val >= BRI_SETTING_MIN) && (val <= BRI_SETTING_DEF)) {
shrink_br = (val - BRI_SETTING_MIN) * (PWM_DEFAULT - PWM_MIN) /
(BRI_SETTING_DEF - BRI_SETTING_MIN) + PWM_MIN;
} else if (val > BRI_SETTING_DEF && val <= BRI_SETTING_MAX) {
shrink_br = (val - BRI_SETTING_DEF) * (PWM_MAX - PWM_DEFAULT) /
(BRI_SETTING_MAX - BRI_SETTING_DEF) + PWM_DEFAULT;
} else if (val > BRI_SETTING_MAX)
shrink_br = PWM_MAX;
if (atomic_read(&g_3D_mode) != OFF_3D) {
shrink_br = 254;
//always refresh brightness value from AP if have but skip 254 which is trigger by 3Dpanel_on func
if(val != 254)
last_br_2d = val;
}
else if(val && atomic_read(&g_3D_mode) == OFF_3D)
last_br_2d = val;
PR_DISP_DEBUG("brightness orig=%d, transformed=%d last_2d %d\n", val, shrink_br, last_br_2d);
return shrink_br;
}
static unsigned char shooter_u_shrink_pwm(int val)
{
if (val <= 0) {
shrink_br = 0;
} else if (val > 0 && (val <= BRI_SETTING_MIN)) {
shrink_br = PWM_MIN + 8/10 ; /* 1 and 2 */
} else if ((val > BRI_SETTING_MIN) && (val <= BRI_SETTING_DEF)) {
shrink_br = (val - BRI_SETTING_MIN) * (PWM_DEFAULT - PWM_MIN) /
(BRI_SETTING_DEF - BRI_SETTING_MIN) + PWM_MIN ;
/* from 3 to 90 (3-2)x(75-7)/(92-2)+7 1*68/90+7 => must be over 7.5 */
} else if (val > BRI_SETTING_DEF && val < BRI_SETTING_MAX) {
shrink_br = (val - BRI_SETTING_DEF) * (PWM_MAX - PWM_DEFAULT) /
(BRI_SETTING_MAX - BRI_SETTING_DEF) + PWM_DEFAULT;
/* (254-92)x(232-75)/(255-92)+7 192*157/193+7 => 163 starts from 7.8 max at 163*/
} else if (val >= BRI_SETTING_MAX)
shrink_br = 148;
/* we wont come in here */
if (atomic_read(&g_3D_mode) != BARRIER_OFF && shrink_br != 0)
shrink_br = 255;
else
last_br_2d = val;
PR_DISP_DEBUG("brightness orig=%d, transformed=%d last_2d %d\n", val, shrink_br, last_br_2d);
return shrink_br;
}
static void himax_self_refresh_switch(int on)
{
int vsync_timeout;
mutex_lock(&cmdlock);
wake_lock(&himax_idle_wake_lock);
#ifdef CONFIG_PERFLOCK
if (!is_perf_lock_active(&himax_perf_lock))
perf_lock(&himax_perf_lock);
#endif
if (on) {
mipi_set_tx_power_mode(0);
mipi_dsi_cmds_tx(&himax_tx_buf, video_to_cmd,
ARRAY_SIZE(video_to_cmd));
mipi_set_tx_power_mode(1);
disable_video_mode_clk();
} else {
mipi_set_tx_power_mode(0);
enable_irq(vsync_irq);
mipi_dsi_cmds_tx(&himax_tx_buf, cmd_to_video,
ARRAY_SIZE(cmd_to_video));
wait_vsync = 1;
udelay(300);
vsync_timeout = wait_event_timeout(himax_vsync_wait, himax_vsync_gpio ||
gpio_get_value(28), HZ/2);
if (vsync_timeout == 0)
PR_DISP_DEBUG("Lost vsync!\n");
disable_irq(vsync_irq);
wait_vsync = 0;
himax_vsync_gpio = 0;
udelay(300);
mipi_dsi_cmds_tx(&himax_tx_buf, vsync_hsync_cmds,
ARRAY_SIZE(vsync_hsync_cmds));
enable_video_mode_clk();
if (vsync_timeout == 0)
mipi_himax_panel_recover();
}
#ifdef CONFIG_PERFLOCK
if (is_perf_lock_active(&himax_perf_lock))
perf_unlock(&himax_perf_lock);
#endif
wake_unlock(&himax_idle_wake_lock);
PR_DISP_DEBUG("[SR] %d\n", on);
mutex_unlock(&cmdlock);
}
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 irqreturn_t himax_vsync_interrupt(int irq, void *data)
{
if (wait_vsync) {
PR_DISP_DEBUG("WV\n");
himax_vsync_gpio = 1;
wake_up(&himax_vsync_wait);
}
return IRQ_HANDLED;
}
int mdp4_dsi_clock_off(void)
{
int ret;
if (dsi_pipe == NULL) {
PR_DISP_DEBUG("dsi_clock_timer not initialize\n");
return 0;
}
ret = del_timer_sync(&dsi_clock_timer);
PR_DISP_DEBUG("%s ret:%d mipi_dsi_clk_on:%d\n",
__func__, ret, mipi_dsi_clk_on);
if (ret && mipi_dsi_clk_on) {
mipi_dsi_turn_off_clks();
mdp4_overlay_dsi_state_set(ST_DSI_CLK_OFF);
}
return ret;
}
static void cp5_wl_dim_on(struct msm_fb_data_type *mfd)
{
PR_DISP_DEBUG("%s\n", __FUNCTION__);
cmdreq.cmds = novatek_dim_on_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(novatek_dim_on_cmds);
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq);
}
static void villec2_set_backlight(struct msm_fb_data_type *mfd)
{
if (!mfd->panel_power_on || cur_bl_level == mfd->bl_level) {
return;
}
villec2_mipi_dsi_set_backlight(mfd);
cur_bl_level = mfd->bl_level;
PR_DISP_DEBUG("%s- bl_level=%d\n", __func__, mfd->bl_level);
}
/*
* mipi_dsi_disale_irq_nosync() should be called
* from interrupt context
*/
void mipi_dsi_disable_irq_nosync(void)
{
spin_lock(&dsi_lock);
if (dsi_irq_enabled == 0) {
PR_DISP_DEBUG("%s: IRQ cannot be disabled\n", __func__);
return;
}
dsi_irq_enabled = 0;
disable_irq_nosync(DSI_IRQ);
spin_unlock(&dsi_lock);
}
static void k2_set_backlight(struct msm_fb_data_type *mfd)
{
struct mipi_panel_info *mipi;
led_pwm1[1] = k2_shrink_pwm((unsigned char)(mfd->bl_level));
if (mipi_k2_pdata && (mipi_k2_pdata->enable_wled_bl_ctrl)
&& (wled_trigger_initialized)) {
led_trigger_event(bkl_led_trigger, led_pwm1[1]);
return;
}
mipi = &mfd->panel_info.mipi;
if (atomic_read(&lcd_power_state) == 0) {
PR_DISP_DEBUG("%s: LCD is off. Skip backlight setting\n", __func__);
return;
}
if (mdp4_overlay_dsi_state_get() <= ST_DSI_SUSPEND) {
return;
}
#ifdef NOVATEK_CABC
if (led_pwm1[1] == 0) {
atomic_set(&lcd_backlight_off, 1);
cmdreq.cmds = novatek_dim_off_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(novatek_dim_off_cmds);
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq);
} else
atomic_set(&lcd_backlight_off, 0);
#endif
cmdreq.cmds = novatek_cmd_backlight_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(novatek_cmd_backlight_cmds);
cmdreq.flags = CMD_REQ_COMMIT;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq);
#ifdef CONFIG_BACKLIGHT_WLED_CABC
if (wled_trigger_initialized) {
led_trigger_event(bkl_led_trigger, mfd->bl_level);
}
#endif
return;
}
static void mipi_himax_set_backlight(struct msm_fb_data_type *mfd)
{
struct mipi_panel_info *mipi;
if (bl_off) {
mfd->bl_level = 0;
bl_off = 0;
}
if (mipi_himax_pdata && mipi_himax_pdata->shrink_pwm)
led_pwm1[1] = mipi_himax_pdata->shrink_pwm(mfd->bl_level);
else
led_pwm1[1] = (unsigned char)(mfd->bl_level);
if (mipi_himax_pdata && (mipi_himax_pdata->enable_wled_bl_ctrl)
&& (wled_trigger_initialized)) {
led_trigger_event(bkl_led_trigger, led_pwm1[1]);
return;
}
mipi = &mfd->panel_info.mipi;
pr_debug("%s+:bl=%d \n", __func__, mfd->bl_level);
if (atomic_read(&lcd_power_state) == 0) {
PR_DISP_DEBUG("%s: LCD is off. Skip backlight setting\n", __func__);
return;
}
if (mipi->mode == DSI_VIDEO_MODE && mdp4_overlay_dsi_state_get() <= ST_DSI_SUSPEND) {
return;
}
if (mipi->mode == DSI_CMD_MODE) {
mipi_dsi_op_mode_config(DSI_CMD_MODE);
}
cmdreq_himax.cmds = himax_cmd_backlight_cmds;
cmdreq_himax.cmds_cnt = ARRAY_SIZE(himax_cmd_backlight_cmds);
cmdreq_himax.flags = CMD_REQ_COMMIT;
cmdreq_himax.rlen = 0;
cmdreq_himax.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq_himax);
#ifdef CONFIG_BACKLIGHT_WLED_CABC
if (wled_trigger_initialized) {
led_trigger_event(bkl_led_trigger, mfd->bl_level);
}
#endif
return;
}
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 mipi_himax_panel_recover(void)
{
mipi_dsi_sw_reset();
if (panel_type == PANEL_ID_VIG_CHIMEI_HX) {
PR_DISP_DEBUG("Panel type = PANEL_ID_VIG_CHIMEI_HX\n");
mipi_dsi_cmds_tx(&himax_tx_buf, himax_CMI_video_on_cmds,
ARRAY_SIZE(himax_CMI_video_on_cmds));
mipi_dsi_cmds_tx(&himax_tx_buf, himax_CMI_display_on_cmds,
ARRAY_SIZE(himax_CMI_display_on_cmds));
} else if (panel_type == PANEL_ID_VIG_CHIMEI_HX_C25) {
PR_DISP_DEBUG("Panel type = PANEL_ID_VIG_CHIMEI_HX_C25\n");
mipi_dsi_cmds_tx(&himax_tx_buf, himax_CMI_video_on_c25_cmds,
ARRAY_SIZE(himax_CMI_video_on_c25_cmds));
mipi_dsi_cmds_tx(&himax_tx_buf, himax_CMI_display_on_cmds,
ARRAY_SIZE(himax_CMI_display_on_cmds));
} else if (panel_type == PANEL_ID_VIG_CHIMEI_HX_C3) {
PR_DISP_DEBUG("Panel type = PANEL_ID_VIG_CHIMEI_HX_C3\n");
mipi_dsi_cmds_tx(&himax_tx_buf, himax_CMI_video_on_c3_cmds,
ARRAY_SIZE(himax_CMI_video_on_c3_cmds));
mipi_dsi_cmds_tx(&himax_tx_buf, himax_CMI_display_on_cmds,
ARRAY_SIZE(himax_CMI_display_on_cmds));
} else if (panel_type == PANEL_ID_VIG_SHARP_HX_C3) {
PR_DISP_DEBUG("Panel type = PANEL_ID_VIG_SHARP_HX_C3\n");
mipi_dsi_cmds_tx(&himax_tx_buf, himax_video_on_c3_cmds,
ARRAY_SIZE(himax_video_on_c3_cmds));
mipi_dsi_cmds_tx(&himax_tx_buf, himax_display_on_cmds,
ARRAY_SIZE(himax_display_on_cmds));
} else if (panel_type == PANEL_ID_VIG_SHARP_HX_C25) {
PR_DISP_DEBUG("Panel type = PANEL_ID_VIG_SHARP_HX_C25\n");
mipi_dsi_cmds_tx(&himax_tx_buf, himax_video_on_c2_cmds,
ARRAY_SIZE(himax_video_on_c2_cmds));
mipi_dsi_cmds_tx(&himax_tx_buf, himax_display_on_cmds,
ARRAY_SIZE(himax_display_on_cmds));
} else if (panel_type == PANEL_ID_VIG_SHARP_HX_C2) {
PR_DISP_DEBUG("Panel type = PANEL_ID_VIG_SHARP_HX_C2\n");
mipi_dsi_cmds_tx(&himax_tx_buf, himax_video_on_c2_cmds,
ARRAY_SIZE(himax_video_on_c2_cmds));
mipi_dsi_cmds_tx(&himax_tx_buf, himax_display_on_cmds,
ARRAY_SIZE(himax_display_on_cmds));
} else {
PR_DISP_DEBUG("Panel type = PANEL_ID_VIG_SHARP_HX\n");
mipi_dsi_cmds_tx(&himax_tx_buf, himax_video_on_cmds,
ARRAY_SIZE(himax_video_on_cmds));
mipi_dsi_cmds_tx(&himax_tx_buf, himax_display_on_cmds,
ARRAY_SIZE(himax_display_on_cmds));
}
if (mipi_himax_pdata && mipi_himax_pdata->shrink_pwm)
led_pwm1[1] = mipi_himax_pdata->shrink_pwm(bl_level_prevset);
else
led_pwm1[1] = bl_level_prevset;
mipi_dsi_cmds_tx(&himax_tx_buf, himax_cmd_backlight_cmds,
ARRAY_SIZE(himax_cmd_backlight_cmds));
}
void mipi_dsi_enable_irq(void)
{
unsigned long flags;
spin_lock_irqsave(&dsi_lock, flags);
if (dsi_irq_enabled) {
PR_DISP_DEBUG("%s: IRQ already enabled\n", __func__);
spin_unlock_irqrestore(&dsi_lock, flags);
return;
}
dsi_irq_enabled = 1;
enable_irq(DSI_IRQ);
spin_unlock_irqrestore(&dsi_lock, flags);
}
