int mipi_smd_oled_hd_read_dev_reg( struct msm_fb_data_type *mfd, struct msmfb_register_read *data) { const int one_read_size = 4; const int loop_limit = 16; int read_pos = 0; int readed_size = 0; int data_cnt = 0; int i,j; read_target_reg[0] = (char)data->w_data[0]; packet_size[0] = (char)data->len; mipi_dsi_cmds_tx(&smd_oled_hd_tx_buf, &(mipi_smd_oled_hd_packet_size_cmd), 1); for (j = 0; j < loop_limit; j++) { read_position[1] = read_pos; if ( mipi_dsi_cmds_tx(&smd_oled_hd_tx_buf, &(mipi_smd_oled_hd_read_pos_cmd), 1) < 1 ) { printk(KERN_ERR "%s. mipi_dsi_cmds_tx FAILED.\n", __func__); return -1; } mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_sw_reset(); mipi_dsi_buf_init(&smd_oled_hd_rx_buf); readed_size = mipi_dsi_cmds_rx(mfd, &smd_oled_hd_tx_buf, &smd_oled_hd_rx_buf, &mipi_smd_oled_hd_read_reg_cmd, one_read_size); for (i = 0; i < readed_size; i++, data_cnt++) { if( data_cnt < data->len ) data->r_data[data_cnt] = smd_oled_hd_rx_buf.data[i]; } mipi_dsi_sw_reset(); mipi_dsi_op_mode_config(DSI_VIDEO_MODE); read_pos += readed_size; if( read_pos > data->len ) break; } return 0; }
static void mipi_orise_bkl_ctrl(bool on) { mutex_lock(&cmdlock); if(on) { mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_cmds_tx(&orise_tx_buf, orise_bkl_enable_cmds, ARRAY_SIZE(orise_bkl_enable_cmds)); } else { mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_cmds_tx(&orise_tx_buf, orise_bkl_disable_cmds, ARRAY_SIZE(orise_bkl_disable_cmds)); } mutex_unlock(&cmdlock); }
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_nt35565_ic_on_disp_on(struct msm_fb_data_type *mfd) { struct mipi_dsi_data *dsi_data; struct dsi_controller *pctrl; dsi_data = platform_get_drvdata(mfd->panel_pdev); if (!dsi_data) return -ENODEV; pctrl = dsi_data->panel->pctrl; if (!dsi_data->panel_detecting) { mipi_dsi_op_mode_config(DSI_CMD_MODE); if (dsi_data->eco_mode_on && pctrl->display_on_eco_cmds) { mipi_dsi_buf_init(&dsi_data->tx_buf); mipi_dsi_cmds_tx(mfd, &dsi_data->tx_buf, pctrl->display_on_eco_cmds, pctrl->display_on_eco_cmds_size); dev_info(&mfd->panel_pdev->dev, "ECO MODE ON\n"); } else { mipi_dsi_buf_init(&dsi_data->tx_buf); mipi_dsi_cmds_tx(mfd, &dsi_data->tx_buf, pctrl->display_on_cmds, pctrl->display_on_cmds_size); dev_info(&mfd->panel_pdev->dev, "ECO MODE OFF\n"); } } return 0; }
static int prepare_for_reg_access(struct msm_fb_data_type *mfd) { struct device *dev = &mfd->panel_pdev->dev; struct mipi_dsi_data *dsi_data; int ret = 0; dsi_data = platform_get_drvdata(mfd->panel_pdev); if (mfd->panel_power_on) { dev_dbg(dev, "%s: panel is on, don't do anything\n", __func__); on_state = false; } else { dev_dbg(dev, "%s: panel is NOT on, power on stack\n", __func__); ret = panel_next_on(mfd->pdev); /* msm_fb_dev */ if (ret) goto exit; on_state = true; } mutex_lock(&mfd->dma->ov_mutex); if (mfd->panel_info.mipi.mode == DSI_VIDEO_MODE) { mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE); MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 0); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE); msleep(ONE_FRAME_TRANSMIT_WAIT_MS); mipi_dsi_controller_cfg(0); mipi_dsi_op_mode_config(DSI_CMD_MODE); } exit: return ret; }
static void mipi_himax_display_on(struct msm_fb_data_type *mfd) { pr_debug("%s+\n", __func__); mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_cmds_tx(&himax_tx_buf, himax_display_on_cmds, ARRAY_SIZE(himax_display_on_cmds)); }
static int mipi_dsi_set_backlight(struct msm_fb_data_type *mfd) { struct mipi_panel_info *mipi; static int bl_level_old; mipi = &mfd->panel_info.mipi; pr_debug("%s+:bl=%d status=%d\n", __func__, mfd->bl_level, mipi_status); if (mipi_status == 0 || bl_level_old == mfd->bl_level) goto end; 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->mode == DSI_VIDEO_MODE) { mipi_dsi_cmd_mode_ctrl(1); /* enable cmd mode */ mipi_dsi_cmds_tx(&himax_tx_buf, himax_cmd_backlight_cmds, ARRAY_SIZE(himax_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(&himax_tx_buf, himax_cmd_backlight_cmds, ARRAY_SIZE(himax_cmd_backlight_cmds)); } bl_level_old = mfd->bl_level; end: return 0; }
static int mipi_dsi_set_backlight(struct msm_fb_data_type *mfd) { struct mipi_panel_info *mipi; static int bl_level_old; mutex_lock(&cmdlock); mipi = &mfd->panel_info.mipi; pr_debug("%s+:bl=%d status=%d\n", __func__, mfd->bl_level, mipi_status); if (mipi_status == 0) goto end; if (mipi_renesas_pdata && mipi_renesas_pdata->shrink_pwm && mfd->bl_level!=0) led_pwm[2] = mipi_renesas_pdata->shrink_pwm(mfd->bl_level); else led_pwm[2] = (unsigned char)(mfd->bl_level); if (mfd->bl_level == 0 || board_mfg_mode() == 4 || board_mfg_mode() == 5) { led_pwm[2] = 0; } mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_cmd_backlight_cmds, ARRAY_SIZE(renesas_cmd_backlight_cmds)); bl_level_prevset = bl_level_old = mfd->bl_level; end: mutex_unlock(&cmdlock); return 0; }
static int mipi_r63306_disp_off(struct msm_fb_data_type *mfd) { int ret = 0; struct mipi_dsi_data *dsi_data; dsi_data = platform_get_drvdata(mfd->panel_pdev); if (!dsi_data || !dsi_data->lcd_power) return -ENODEV; if (!dsi_data->panel_detecting) { mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_buf_init(&dsi_data->tx_buf); mipi_dsi_cmds_tx(&dsi_data->tx_buf, dsi_data->panel->pctrl->display_off_cmds, dsi_data->panel->pctrl->display_off_cmds_size); #ifdef CONFIG_FB_MSM_RECOVER_PANEL mipi_set_tx_power_mode(1); #endif ret = dsi_data->lcd_power(FALSE); } else { dsi_data->panel_detecting = false; ret = 0; } return ret; }
int prepare_for_reg_access(struct msm_fb_data_type *mfd) { struct device *dev = &mfd->panel_pdev->dev; struct mipi_dsi_data *dsi_data; int ret = 0; dsi_data = platform_get_drvdata(mfd->panel_pdev); #ifdef CONFIG_FB_MSM_RECOVER_PANEL mutex_lock(&mfd->nvrw_prohibit_draw); #endif /* Needed to make sure the display stack isn't powered on/off while */ /* we are executing. Also locks in msm_fb.c */ mutex_lock(&mfd->power_lock); if (mdp_fb_is_power_off(mfd)) { dev_err(dev, "%s: panel is OFF, not supported\n", __func__); mutex_unlock(&mfd->power_lock); #ifdef CONFIG_FB_MSM_RECOVER_PANEL mutex_unlock(&mfd->nvrw_prohibit_draw); #endif ret = -EINVAL; goto exit; } mutex_lock(&mfd->dma->ov_mutex); if (mfd->panel_info.mipi.mode == DSI_VIDEO_MODE) { mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE); MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 0); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE); msleep(ONE_FRAME_TRANSMIT_WAIT_MS); mipi_dsi_controller_cfg_toggle(0); mipi_dsi_op_mode_config(DSI_CMD_MODE); } exit: return ret; }
static void post_reg_access(struct msm_fb_data_type *mfd, enum power_state old_state) { struct mipi_dsi_data *dsi_data; dsi_data = platform_get_drvdata(mfd->panel_pdev); /* This should not be needed, but without this we sometimes don't get an * interrupt when transmitting the command */ if (mfd->panel_info.mipi.mode == DSI_VIDEO_MODE) { mipi_dsi_op_mode_config(DSI_VIDEO_MODE); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE); mipi_dsi_sw_reset(); mipi_dsi_controller_cfg(1); MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 1); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE); } mutex_unlock(&mfd->dma->ov_mutex); if (dsi_data->panel_state == DEBUGFS_POWER_ON) { (void)panel_next_off(mfd->pdev); mutex_lock(&dsi_data->lock); dsi_data->panel_state = old_state; mutex_unlock(&dsi_data->lock); } mutex_unlock(&mfd->power_lock); }
static int mipi_dsi_set_backlight(struct msm_fb_data_type *mfd) { struct mipi_panel_info *mipi; mutex_lock(&cmdlock); mipi = &mfd->panel_info.mipi; PR_DISP_INFO("%s+:bl=%d status=%d\n", __func__, mfd->bl_level, mipi_status); if (mipi_status == 0) goto end; 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(mfd->bl_level == 0 || board_mfg_mode() == 4 || board_mfg_mode() == 5) led_pwm1[1] = 0; if (mipi->mode == DSI_VIDEO_MODE) { mipi_dsi_cmds_tx(&himax_tx_buf, himax_cmd_backlight_cmds, ARRAY_SIZE(himax_cmd_backlight_cmds)); } else { mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_cmds_tx(&himax_tx_buf, himax_cmd_backlight_cmds, ARRAY_SIZE(himax_cmd_backlight_cmds)); } bl_level_prevset = mfd->bl_level; end: mutex_unlock(&cmdlock); return 0; }
static int mipi_lgit_lcd_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; printk(KERN_INFO"%s: mipi lgit lcd on started, lge_bd_rev = %d \n", __func__, lge_bd_rev); mipi_lgit_lcd_reset(); mipi_dsi_op_mode_config(DSI_CMD_MODE); //display on each panel //This is seperated by HW rev. if(lge_bd_rev < LGE_REV_E) mipi_dsi_cmds_tx(mfd, &lgit_tx_buf, lgit_power_on_set, ARRAY_SIZE(lgit_power_on_set)); else { if(lge_bd_rev == LGE_REV_E) mipi_dsi_cmds_tx(mfd, &lgit_tx_buf, lgit_power_on_set_2P3, ARRAY_SIZE(lgit_power_on_set_2P3)); else mipi_dsi_cmds_tx(mfd, &lgit_tx_buf, lgit_power_on_set_2P5, ARRAY_SIZE(lgit_power_on_set_2P5)); } return 0; }
/* 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_renesas_display_on(struct msm_fb_data_type *mfd) { pr_info("%s+\n", __func__); mutex_lock(&cmdlock); mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_cmd_display_on_cmds, ARRAY_SIZE(renesas_cmd_display_on_cmds)); mutex_unlock(&cmdlock); }
static void mipi_orise_display_on(struct msm_fb_data_type *mfd) { pr_debug("%s+\n", __func__); mutex_lock(&cmdlock); mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_cmds_tx(&orise_tx_buf, orise_display_on_cmds, ARRAY_SIZE(orise_display_on_cmds)); 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); }
/******************************************************************** Function Name :- drive_pwm_pin_to_low Arguments :- None Return Value :- int / Always Success. Functionality :- to drive PWM pin of lcd panel to LOW. dependencies :- Panel Should be already ON. Others :- By writing 1 to pwm_pin parameter (module/mipi_lg4573/) we can simulate low on pwm pin. For Software ESD simulation Testing. *********************************************************************/ static int drive_pwm_pin_to_low() { struct msm_fb_data_type *mfd; int ret = 0; printk("%s Enter \n",__func__); mfd = platform_get_drvdata(local_pdev_for_pwm); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_cmds_tx(mfd, &lg4573b_tx_buf, lg4573b_pwm_pin_low_cmds, ARRAY_SIZE(lg4573b_pwm_pin_low_cmds)); mipi_dsi_op_mode_config(DSI_VIDEO_MODE); printk("%s Exit \n",__func__); return ret; }
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 void mipi_dsi_clk_toggle(struct msm_fb_data_type *mfd) { mutex_lock(&mfd->dma->ov_mutex); if (mfd->panel_info.mipi.mode == DSI_VIDEO_MODE) { mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE); MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 0); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE); mipi_dsi_controller_cfg(0); mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_op_mode_config(DSI_VIDEO_MODE); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE); mipi_dsi_sw_reset(); mipi_dsi_controller_cfg(1); MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 1); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE); } mutex_unlock(&mfd->dma->ov_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 }
/******************************************************************** Function Name :- drive_pwm_pin_to_high Arguments :- None Return Value :- int / Always Success. Functionality :- Power off / reset / power on / lcd panel init. dependencies :- Panel Should be already ON. Others :- By writing 0 to pwm_pin parameter (module/mipi_lg4573/) we can re-initialize panel. For Software ESD simulation Testing. *********************************************************************/ static int drive_pwm_pin_to_high() { struct msm_fb_data_type *mfd; int ret = 0; printk("%s Enter \n",__func__); mfd = platform_get_drvdata(local_pdev_for_pwm); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_cmds_tx(mfd, &lg4573b_tx_buf, lg4573b_disp_off_cmds, ARRAY_SIZE(lg4573b_disp_off_cmds)); mipi_ldp_lcd_panel_poweroff();//reset pin esd_sw_test_lcd_panel_power_off(); //power mdelay(500); esd_sw_test_lcd_panel_power_on(); //panel power on mipi_set_tx_power_mode(1); mipi_dsi_cmds_tx(mfd, &lg4573b_tx_buf, lg4573b_init_on_cmds, ARRAY_SIZE(lg4573b_init_on_cmds)); mdelay(10); mipi_dsi_cmds_tx(mfd, &lg4573b_tx_buf, lg4573b_sleep_out_cmds, ARRAY_SIZE(lg4573b_sleep_out_cmds)); mdelay(120); mipi_dsi_cmds_tx(mfd, &lg4573b_tx_buf, lg4573b_disp_on_cmds, ARRAY_SIZE(lg4573b_disp_on_cmds)); mipi_set_tx_power_mode(0); mipi_dsi_op_mode_config(DSI_VIDEO_MODE); //back to video mode. printk("%s Exit \n",__func__); return ret; }
static void mipi_orise_display_on(struct msm_fb_data_type *mfd) { PR_DISP_DEBUG("%s\n", __FUNCTION__); mipi_dsi_op_mode_config(DSI_CMD_MODE); cmdreq_orise.cmds = orise_display_on_cmds; cmdreq_orise.cmds_cnt = ARRAY_SIZE(orise_display_on_cmds); cmdreq_orise.flags = 0; cmdreq_orise.rlen = 0; cmdreq_orise.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq_orise); }
static void mipi_himax_display_on(struct msm_fb_data_type *mfd) { PR_DISP_DEBUG("%s\n", __FUNCTION__); mipi_dsi_op_mode_config(DSI_CMD_MODE); cmdreq_himax.cmds = himax_display_on_cmds; cmdreq_himax.cmds_cnt = ARRAY_SIZE(himax_display_on_cmds); cmdreq_himax.flags = CMD_REQ_COMMIT; cmdreq_himax.rlen = 0; cmdreq_himax.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq_himax); }
static int prepare_for_reg_access(struct msm_fb_data_type *mfd, enum power_state *old_state) { struct device *dev = &mfd->panel_pdev->dev; struct mipi_dsi_data *dsi_data; int ret = 0; dsi_data = platform_get_drvdata(mfd->panel_pdev); /* Needed to make sure the display stack isn't powered on/off while */ /* we are executing. The best solution would be a read/write function */ /* that handles the current power state */ mutex_lock(&mfd->power_lock); if (mfd->panel_power_on) { dev_dbg(dev, "%s: panel is on, don't do anything\n", __func__); } else { dev_dbg(dev, "%s: panel is NOT on, power on stack\n", __func__); mutex_lock(&dsi_data->lock); *old_state = dsi_data->panel_state; dsi_data->panel_state = DEBUGFS_POWER_OFF; mutex_unlock(&dsi_data->lock); ret = panel_next_on(mfd->pdev); /* msm_fb_dev */ if (ret) { mutex_unlock(&mfd->power_lock); goto exit; } } mutex_lock(&mfd->dma->ov_mutex); /* This should not be needed, but without this we sometimes don't get an * interrupt when transmitting the command */ if (mfd->panel_info.mipi.mode == DSI_VIDEO_MODE) { mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE); MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 0); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE); msleep(20); mipi_dsi_controller_cfg(0); mipi_dsi_op_mode_config(DSI_CMD_MODE); } exit: return ret; }
static int mipi_r63306_disp_on(struct msm_fb_data_type *mfd) { int ret = 0; struct mipi_dsi_data *dsi_data; struct dsi_controller *pctrl; dsi_data = platform_get_drvdata(mfd->panel_pdev); if (!dsi_data || !dsi_data->lcd_power) { ret = -ENODEV; goto disp_on_fail; } pctrl = dsi_data->panel->pctrl; if (!dsi_data->panel_detecting) { ret = dsi_data->lcd_power(TRUE); if (ret) goto disp_on_fail; mipi_dsi_op_mode_config(DSI_CMD_MODE); if (pctrl->display_init_cmds) { mipi_dsi_buf_init(&dsi_data->tx_buf); mipi_dsi_cmds_tx(mfd, &dsi_data->tx_buf, pctrl->display_init_cmds, pctrl->display_init_cmds_size); } if (dsi_data->eco_mode_on && pctrl->display_on_eco_cmds) { mipi_dsi_buf_init(&dsi_data->tx_buf); mipi_dsi_cmds_tx(mfd, &dsi_data->tx_buf, pctrl->display_on_eco_cmds, pctrl->display_on_eco_cmds_size); dev_info(&mfd->panel_pdev->dev, "ECO MODE ON\n"); } else { mipi_dsi_buf_init(&dsi_data->tx_buf); mipi_dsi_cmds_tx(mfd, &dsi_data->tx_buf, pctrl->display_on_cmds, pctrl->display_on_cmds_size); dev_info(&mfd->panel_pdev->dev, "ECO MODE OFF\n"); } } disp_on_fail: return ret; }
static void post_reg_access(struct msm_fb_data_type *mfd) { struct mipi_dsi_data *dsi_data; dsi_data = platform_get_drvdata(mfd->panel_pdev); if (mfd->panel_info.mipi.mode == DSI_VIDEO_MODE) { mipi_dsi_op_mode_config(DSI_VIDEO_MODE); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE); mipi_dsi_sw_reset(); mipi_dsi_controller_cfg(1); MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 1); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE); } mutex_unlock(&mfd->dma->ov_mutex); if (on_state) (void)panel_next_off(mfd->pdev); }
static int mipi_lgit_lcd_off(struct platform_device *pdev) { struct msm_fb_data_type *mfd; mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; printk(KERN_INFO"%s: mipi lgit lcd off started \n", __func__); mipi_dsi_op_mode_config(DSI_CMD_MODE); mipi_dsi_cmds_tx(mfd, &lgit_tx_buf, lgit_power_off_set, ARRAY_SIZE(lgit_power_off_set)); gpio_tlmm_config(GPIO_CFG(LCD_RESET_N, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),GPIO_CFG_ENABLE); gpio_set_value(LCD_RESET_N,0); return 0; }
void post_reg_access(struct msm_fb_data_type *mfd) { struct mipi_dsi_data *dsi_data; dsi_data = platform_get_drvdata(mfd->panel_pdev); if (mfd->panel_info.mipi.mode == DSI_VIDEO_MODE) { mipi_dsi_op_mode_config(DSI_VIDEO_MODE); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE); mipi_dsi_sw_reset(); mipi_dsi_controller_cfg_toggle(1); MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 1); mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE); } mutex_unlock(&mfd->dma->ov_mutex); mutex_unlock(&mfd->power_lock); #ifdef CONFIG_FB_MSM_RECOVER_PANEL mutex_unlock(&mfd->nvrw_prohibit_draw); #endif }