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); }