static int mipi_renesas_lcd_off(struct platform_device *pdev) { struct msm_fb_data_type *mfd; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (renesas_state.disp_on == true) { mutex_lock(&renesas_state.lcd_mutex); mipi_set_tx_power_mode(0); mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_display_off_cmds, ARRAY_SIZE(renesas_display_off_cmds)); renesas_state.disp_on = false; renesas_state.disp_initialized = false; mipi_set_tx_power_mode(1); mutex_unlock(&renesas_state.lcd_mutex); #ifdef CONFIG_F_SKYDISP_SILENT_BOOT sky_sys_rst_set_silent_boot_backlight(0); is_silent_boot_mode_n_bl_off = 0; #endif } EXIT_FUNC2(); return 0; }
static int __init mipi_sony_lcd_init(void) { ENTER_FUNC2(); #if defined(CONFIG_F_SKYDISP_SILENT_BOOT) && defined(CONFIG_PANTECH_RESET_REASON) is_silent_boot_mode = sky_sys_rst_get_silent_boot_mode(); is_backlight_on_before_reset = sky_sys_rst_get_silent_boot_backlight(); if(is_silent_boot_mode == 1 && is_backlight_on_before_reset == 0) { printk("This time is silent boot mode.\n"); is_silent_boot_mode_n_bl_off = 1; } else printk("This time is NOT silent boot mode.\n"); #endif sony_state.disp_powered_up = true; mipi_dsi_buf_alloc(&sony_tx_buf, DSI_BUF_SIZE); mipi_dsi_buf_alloc(&sony_rx_buf, DSI_BUF_SIZE); EXIT_FUNC2(); return platform_driver_register(&this_driver); }
static int mipi_samsung_oled_hd_off(struct platform_device *pdev) { struct msm_fb_data_type *mfd; // u32 tmp; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (samsung_oled_hd_state.disp_on == true) { // is_sleep = TRUE; samsung_oled_hd_state.disp_initialized = false; samsung_oled_hd_state.disp_on = false; printk("[PANTECH_LCD] power off state (oled_hd panel).... \n"); #ifdef CONFIG_PANTECH_HDMI_PW_CTRL_ON_LCD if (!HDMI_Get_Cable_State()) { hdmi_autodetect_control(HDMI_PW_OFF); HDMI_Schedule_Control(0); } #endif } EXIT_FUNC2(); return 0; }
static int __init mipi_renesas_lcd_init(void) { ENTER_FUNC2(); #ifdef CONFIG_F_SKYDISP_CHANGE_BL_TABLE_WHEN_OFFLINE_CHARGING is_offline_charging_mode = pantech_charging_status(); printk("is_offline_charging_mode : %d\n", is_offline_charging_mode); #endif #ifdef CONFIG_F_SKYDISP_SILENT_BOOT is_silent_boot_mode = pantech_sys_rst_is_silent_boot_mode(); is_backlight_on_before_reset = pantech_sys_reset_backlight_flag_get(); if(is_silent_boot_mode == 1 && is_backlight_on_before_reset == 0) { printk("This time is silent boot mode.\n"); is_silent_boot_mode_n_bl_off = 1; } else printk("This time is NOT silent boot mode.\n"); #endif renesas_state.disp_powered_up = true; mipi_dsi_buf_alloc(&renesas_tx_buf, DSI_BUF_SIZE); mipi_dsi_buf_alloc(&renesas_rx_buf, DSI_BUF_SIZE); EXIT_FUNC2(); return platform_driver_register(&this_driver); }
static int __init mipi_sony_lcd_init(void) { ENTER_FUNC2(); lcd_gpio_init(lcd_gpio_init_table, ARRAY_SIZE(lcd_gpio_init_table), 1); #ifdef FEATURE_SKY_BACLIGHT_MAX8831 led_i2c_api_Init(); #endif gpio_set_value_cansleep(LCD_DET, GPIO_LOW_VALUE); sony_state.disp_powered_up = true; mipi_dsi_buf_alloc(&sony_tx_buf, DSI_BUF_SIZE); mipi_dsi_buf_alloc(&sony_rx_buf, DSI_BUF_SIZE); #if 1//def CONFIG_SW_RESET if (msm_reset_reason_read_only()) { first_enable = 0; prev_bl_level = 0; } #endif EXIT_FUNC2(); return platform_driver_register(&this_driver); }
static int mipi_sony_lcd_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; //mutex_lock(&mfd->dma->ov_mutex); if (sony_state.disp_initialized == false) { //PRINT("[LIVED] LCD RESET!!\n"); gpio_set_value_cansleep(LCD_RESET, GPIO_LOW_VALUE); usleep(10);//msleep(1); gpio_set_value_cansleep(LCD_RESET, GPIO_HIGH_VALUE); usleep(10);//msleep(120); #ifdef USE_INITIAL_SEQ mipi_dsi_cmds_tx(mfd, &sony_tx_buf, sony_display_init_cmds, ARRAY_SIZE(sony_display_init_cmds)); #endif sony_state.disp_initialized = true; } mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_on_cmds, ARRAY_SIZE(sony_display_on_cmds)); sony_state.disp_on = true; //mutex_unlock(&mfd->dma->ov_mutex); EXIT_FUNC2(); return 0; }
static int mipi_sony_lcd_off(struct platform_device *pdev) { struct msm_fb_data_type *mfd; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; //mutex_lock(&mfd->dma->ov_mutex); if (sony_state.disp_on == true) { gpio_set_value_cansleep(LCD_RESET, GPIO_LOW_VALUE); usleep(10);//msleep(1); gpio_set_value_cansleep(LCD_RESET, GPIO_HIGH_VALUE); usleep(10);//msleep(120); mipi_samsung_lcd_off_running=1; mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_off_cmds, ARRAY_SIZE(sony_display_off_cmds)); mipi_samsung_lcd_off_running=0; sony_state.disp_on = false; sony_state.disp_initialized = false; } //mutex_unlock(&mfd->dma->ov_mutex); EXIT_FUNC2(); return 0; }
static int mipi_oscar_lcd_off(struct platform_device *pdev) { struct msm_fb_data_type *mfd; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (oscar_state.disp_on == true) { mipi_dsi_cmds_tx(mfd, &oscar_tx_buf, oscar_sleep_in, ARRAY_SIZE(oscar_sleep_in)); oscar_state.disp_on = false; oscar_state.disp_initialized = false; } backlight_cnt = false; oscar_state.disp_powered_up = false; EXIT_FUNC2(); return 0; }
static int mipi_himax_lcd_off(struct platform_device *pdev) { struct msm_fb_data_type *mfd; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (himax_state.disp_on == true) { gpio_set_value_cansleep(gpio43, GPIO_LOW_VALUE); usleep(10); gpio_set_value_cansleep(gpio43, GPIO_HIGH_VALUE); usleep(10); mipi_dsi_cmds_tx(mfd, &himax_tx_buf, himax_sleep_in_cmds, ARRAY_SIZE(himax_sleep_in_cmds)); himax_state.disp_on = false; himax_state.disp_initialized = false; EXIT_FUNC2(); } return 0; }
static int mipi_sony_lcd_off(struct platform_device *pdev) { struct msm_fb_data_type *mfd; #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT struct dcs_cmd_req cmdreq; #endif ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; mutex_lock(&sony_state.lcd_mutex); if (sony_state.disp_on == true) { sony_state.disp_on = false; sony_state.disp_initialized = false; //mipi_set_tx_power_mode(0); #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_off_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_off_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_off_cmds, ARRAY_SIZE(sony_display_off_cmds)); #endif #if defined(CONFIG_F_SKYDISP_SILENT_BOOT) && defined(CONFIG_PANTECH_ERR_CRASH_LOGGING) pantech_sys_reset_backlight_flag_set(false); is_silent_boot_mode_n_bl_off = 0; #endif //mipi_set_tx_power_mode(1); } #ifdef CONFIG_F_SKYDISP_EF52_KK_TEARING_WORKAROUND mfd->ibuf.vsync_enable = FALSE; #endif #ifdef FEATURE_RENESAS_BL_CTRL_CHG wrdisbv[1] = 0; if(gpio_get_value_cansleep(gpio_lcd_bl_en)) gpio_set_value_cansleep(gpio_lcd_bl_en, GPIO_LOW_VALUE); #endif mutex_unlock(&sony_state.lcd_mutex); EXIT_FUNC2(); return 0; }
static int __init mipi_samsung_oled_init(void) { ENTER_FUNC2(); samsung_oled_state.disp_powered_up = true; mipi_dsi_buf_alloc(&samsung_oled_tx_buf, DSI_BUF_SIZE); mipi_dsi_buf_alloc(&samsung_oled_rx_buf, DSI_BUF_SIZE); EXIT_FUNC2(); return platform_driver_register(&this_driver); }
static int mipi_sony_lcd_off(struct platform_device *pdev) { struct msm_fb_data_type *mfd; #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT struct dcs_cmd_req cmdreq; #endif ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; mutex_lock(&sony_state.lcd_mutex); if (sony_state.disp_on == true) { //mipi_set_tx_power_mode(0); #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_off_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_off_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_off_cmds, ARRAY_SIZE(sony_display_off_cmds)); #endif sony_state.disp_on = false; sony_state.disp_initialized = false; #ifdef CONFIG_F_SKYDISP_SILENT_BOOT sky_sys_rst_set_silent_boot_backlight(0); is_silent_boot_mode_n_bl_off = 0; #endif //mipi_set_tx_power_mode(1); } mutex_unlock(&sony_state.lcd_mutex); #ifdef FEATURE_RENESAS_BL_CTRL_CHG wrdisbv[1] = 0; #endif EXIT_FUNC2(); return 0; }
static int __init mipi_oscar_lcd_init(void) { ENTER_FUNC2(); oscar_state.disp_powered_up = true; id_read_flag = false; mipi_dsi_buf_alloc(&oscar_tx_buf, DSI_BUF_SIZE); mipi_dsi_buf_alloc(&oscar_rx_buf, DSI_BUF_SIZE); EXIT_FUNC2(); return platform_driver_register(&this_driver); }
int mipi_sony_force_lcd_off(void) { struct msm_fb_data_type *mfd; struct fb_info *info; struct dcs_cmd_req cmdreq; ENTER_FUNC2(); info = registered_fb[0]; mfd = (struct msm_fb_data_type *)info->par; if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; mutex_lock(&sony_state.lcd_mutex); if (sony_state.disp_on == true) { //mipi_set_tx_power_mode(0); cmdreq.cmds = sony_display_off_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_off_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); sony_state.disp_on = false; sony_state.disp_initialized = false; #if defined(CONFIG_F_SKYDISP_SILENT_BOOT) && defined(CONFIG_PANTECH_RESET_REASON) sky_sys_rst_set_silent_boot_backlight(0); is_silent_boot_mode_n_bl_off = 0; #endif //mipi_set_tx_power_mode(1); } mutex_unlock(&sony_state.lcd_mutex); #ifdef FEATURE_RENESAS_BL_CTRL_CHG wrdisbv[1] = 0; #endif EXIT_FUNC2(); return 0; }
static int mipi_samsung_oled_off(struct platform_device *pdev) { struct msm_fb_data_type *mfd; u32 tmp; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (samsung_oled_state.disp_on == true) { #if 0 gpio_set_value_cansleep(gpio43, 0); usleep(10); gpio_set_value_cansleep(gpio43, 1); usleep(10); mipi_dsi_sw_reset(); #endif tmp = MIPI_INP(MIPI_DSI_BASE + 0xA8); tmp &= ~(1<<28); MIPI_OUTP(MIPI_DSI_BASE + 0xA8, tmp); wmb(); is_sleep = FALSE; samsung_oled_state.disp_initialized = false; samsung_oled_state.disp_on = false; printk("[PANTECH_LCD] power off state (oled panel).... \n"); #ifdef CONFIG_PANTECH_F_HDMI_PW_CTRL_ON_LCD if (!HDMI_Get_Cable_State()) { hdmi_autodetect_control(HDMI_PW_OFF); HDMI_Schedule_Control(0); } #endif } EXIT_FUNC2(); return 0; }
void android_poweroff(void) { struct fb_info *info; struct msm_fb_data_type *mfd; info = registered_fb[0]; mfd = (struct msm_fb_data_type *)info->par; if(mfd->panel_power_on == FALSE) return; mipi_set_tx_power_mode(0); mipi_dsi_cmds_tx(mfd, &oscar_tx_buf, oscar_sleep_in, ARRAY_SIZE(oscar_sleep_in)); mipi_set_tx_power_mode(1); gpio_direction_output(gpio43, 0); mdelay(110); //mipi_dsi_cdp_panel_power(0); mipi_dsi_cdp_panel_power_Oscar(0); EXIT_FUNC2(); }
static int mipi_samsung_oled_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (samsung_oled_state.disp_initialized == false) { is_first = TRUE; samsung_oled_state.disp_initialized = true; usleep(10); gpio_set_value_cansleep(gpio43, 0); usleep(10); gpio_set_value_cansleep(gpio43, 1); // lcd panel reset msleep(10); /* bllp bit initialized ... */ mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_init_cmds, ARRAY_SIZE(samsung_oled_display_init_cmds)); is_sleep = FALSE; printk("[PANTECH_LCD] power on state (oled panel).... \n"); #ifdef CONFIG_PANTECH_F_HDMI_PW_CTRL_ON_LCD hdmi_autodetect_control(HDMI_PW_ON); HDMI_Schedule_Control(1); #endif } samsung_oled_state.disp_on = true; EXIT_FUNC2(); return 0; }
static int mipi_renesas_lcd_off(struct platform_device *pdev) { struct msm_fb_data_type *mfd; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (renesas_state.disp_on == true) { #if defined(FEATURE_RENESAS_BL_ON_DEBUG) gpio_set_value_cansleep(gpio_lcd_bl_ctl, GPIO_LOW_VALUE); gpio_set_value_cansleep(gpio_lcd_bl_en, GPIO_LOW_VALUE); #endif mutex_lock(&renesas_state.lcd_mutex); mipi_set_tx_power_mode(0); mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_display_off_cmds, ARRAY_SIZE(renesas_display_off_cmds)); renesas_state.disp_on = false; renesas_state.disp_initialized = false; mipi_set_tx_power_mode(1); mutex_unlock(&renesas_state.lcd_mutex); #ifdef CONFIG_F_SKYDISP_SILENT_BOOT pantech_sys_reset_backlight_flag_set(false); is_silent_boot_mode_n_bl_off = 0; #endif } EXIT_FUNC2(); return 0; }
static void mipi_samsung_oled_set_backlight(struct msm_fb_data_type *mfd) { unsigned long flags; ENTER_FUNC2(); if((prev_bl != mfd->bl_level) || (is_first==TRUE)){ now_bl = mfd->bl_level; prev_bl = now_bl; } else { printk("[PANTECH_LCD:%s] Equal backlight value ... pass ....\n",__func__); return; } printk(KERN_ERR "[PANTECH_LCD:] %s:%d(is_sleep:%d,is_first:%d)\n", __FUNCTION__, (mfd->bl_level),is_sleep, is_first); if((samsung_oled_state.disp_initialized != true) || (samsung_oled_state.disp_on == false)) { printk("[PANTECH_LCD:%s] Panel is off state....Ignore backlight value... \n",__func__); return; } #ifdef D_SKY_BACKLIGHT_CONTROL if((is_sleep==TRUE) && (samsung_oled_state.disp_on == true)) { msleep(50); is_sleep = FALSE; mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_on_cmds, ARRAY_SIZE(samsung_oled_display_on_cmds)); printk("[PANTECH_LCD:%s] wakeup state (oled panel).... \n",__func__); } local_save_flags(flags); local_irq_disable(); switch (now_bl) { case 15: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_300, ARRAY_SIZE(samsung_oled_display_gamma_cmds_300)); break; case 14: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_280, ARRAY_SIZE(samsung_oled_display_gamma_cmds_280)); break; case 13: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_260, ARRAY_SIZE(samsung_oled_display_gamma_cmds_260)); break; case 12: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_240, ARRAY_SIZE(samsung_oled_display_gamma_cmds_240)); break; case 11: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_220, ARRAY_SIZE(samsung_oled_display_gamma_cmds_220)); break; case 10: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_200, ARRAY_SIZE(samsung_oled_display_gamma_cmds_200)); break; case 9: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_180, ARRAY_SIZE(samsung_oled_display_gamma_cmds_180)); break; case 8: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_160, ARRAY_SIZE(samsung_oled_display_gamma_cmds_160)); break; case 7: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_140, ARRAY_SIZE(samsung_oled_display_gamma_cmds_140)); break; case 6: default: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_120, ARRAY_SIZE(samsung_oled_display_gamma_cmds_120)); break; case 5: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_100, ARRAY_SIZE(samsung_oled_display_gamma_cmds_100)); break; case 4: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_80, ARRAY_SIZE(samsung_oled_display_gamma_cmds_80)); break; case 3: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_60, ARRAY_SIZE(samsung_oled_display_gamma_cmds_60)); break; case 2: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_40, ARRAY_SIZE(samsung_oled_display_gamma_cmds_40)); break; case 1: mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_display_gamma_cmds_30, ARRAY_SIZE(samsung_oled_display_gamma_cmds_30)); break; case 0: if(!is_first) { mipi_dsi_cmds_tx(mfd, &samsung_oled_tx_buf, samsung_oled_screen_off_cmds, ARRAY_SIZE(samsung_oled_screen_off_cmds)); is_sleep = TRUE; printk("[PANTECH_LCD:%s] sleep state (oled panel).... \n",__func__); }else is_first = FALSE; break; } local_irq_restore(flags); #endif EXIT_FUNC2(); }
//extern void LCD_gpio_set_vci_control(int on); static int mipi_sony_lcd_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT struct dcs_cmd_req cmdreq; #endif ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; mutex_lock(&sony_state.lcd_mutex); if (sony_state.disp_initialized == false) { #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_init_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_init_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_init_cmds, ARRAY_SIZE(sony_display_init_cmds)); #endif sony_state.disp_initialized = true; } #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_on_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_on_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_on_cmds, ARRAY_SIZE(sony_display_on_cmds)); #endif sony_state.disp_on = true; #if (1)// kkcho_temp #if (0) if(sony_state.acl_flag == true){ #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_cabc_off_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_cabc_off_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(mfd, &sony_tx_buf, sony_display_cabc_off_cmds, ARRAY_SIZE(sony_display_cabc_off_cmds)); #endif } else{ #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_cabc_on_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_cabc_on_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(mfd, &sony_tx_buf, sony_display_cabc_on_cmds, ARRAY_SIZE(sony_display_cabc_on_cmds)); #endif } //#else #endif // if 0 #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_cabc_on_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_cabc_on_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_cabc_on_cmds, ARRAY_SIZE(sony_display_cabc_on_cmds)); #endif #endif // if 1 //kkcho_temp mutex_unlock(&sony_state.lcd_mutex); #ifdef CONFIG_F_SKYDISP_SILENT_BOOT // In case of reset when silentboot mode(doing boot), only when is_silent_boot_mode_n_bl_off == 0, do it. // If always do it, display silentboot image eventhough reset occur when backlight off. if(is_silent_boot_mode_n_bl_off == 0) sky_sys_rst_set_silent_boot_backlight(1); #endif #ifdef BOOT_TOUCH_RESET // touch reset code if(touch_init == false) { gpio_direction_output(TOUCH_RST_GPIO, 1); gpio_set_value(TOUCH_RST_GPIO, 0); msleep(50); gpio_set_value(TOUCH_RST_GPIO, 1); touch_init = true; } #endif EXIT_FUNC2(); return 0; }
static int mipi_oscar_lcd_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; struct fb_info *fbi; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); fbi = mfd->fbi; if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (oscar_state.disp_initialized == false) { mdelay(25); gpio_direction_output(gpio43, 0); udelay(10); gpio_direction_output(gpio43, 1); // lcd panel reset mdelay(10); mipi_set_tx_power_mode(0); mipi_dsi_cmds_tx(mfd, &oscar_tx_buf, oscar_display_init_cmds, ARRAY_SIZE(oscar_display_init_cmds)); mipi_set_tx_power_mode(1); #ifdef SAMSUNG_LCD_MIPI_CELL if(id_read_flag == false){ //read ID3 mipi_set_tx_power_mode(0); mipi_dsi_cmd_bta_sw_trigger(); mipi_oscar_lcd_read(mfd); mipi_set_tx_power_mode(1); printk("oscar_mipi_cell-read\n"); id_read_flag = true; } #endif #ifdef CONFIG_ACL_FOR_AMOLED mipi_set_tx_power_mode(0); switch(oscar_state.acl_data) { case 10: mipi_dsi_cmds_tx(mfd, &oscar_tx_buf, oscar_acl_control10, ARRAY_SIZE(oscar_acl_control10)); break; case 30: mipi_dsi_cmds_tx(mfd, &oscar_tx_buf, oscar_acl_control30, ARRAY_SIZE(oscar_acl_control30)); break; case 50: mipi_dsi_cmds_tx(mfd, &oscar_tx_buf, oscar_acl_control50, ARRAY_SIZE(oscar_acl_control50)); break; } mipi_set_tx_power_mode(1); #endif if(first == 0){ mipi_set_tx_power_mode(0); mipi_dsi_cmds_tx(mfd, &oscar_tx_buf, oscar_sleep_out, ARRAY_SIZE(oscar_sleep_out)); mipi_set_tx_power_mode(1); first =true; } oscar_state.disp_initialized = true; } #ifdef SAMSUNG_LCD_MIPI_CELL mipi_set_tx_power_mode(0); //after read id, mipi_dsi_cmds_tx(mfd, &oscar_tx_buf, Cell_on_cmd, ARRAY_SIZE(Cell_on_cmd)); mipi_set_tx_power_mode(1); #endif oscar_state.disp_on = true; printk(KERN_WARNING"mipi_oscar_lcd_acl_data = %d, %d\n",oscar_state.acl_data,oscar_state.acl_data); EXIT_FUNC2(); return 0; }
static int mipi_samsung_oled_hd_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; #if (BOARD_VER > WS10) int noled_det; #endif ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (samsung_oled_hd_state.disp_initialized == false) { samsung_oled_hd_state.disp_initialized = true; gpio_set_value_cansleep(gpio43, 0); usleep(10); gpio_set_value_cansleep(gpio43, 1); // lcd panel reset usleep(10); // mdelay(10); // mdelay(1); mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_init_cmds, ARRAY_SIZE(samsung_oled_hd_display_init_cmds)); /* mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_sleepout_cmds, ARRAY_SIZE(samsung_oled_hd_display_sleepout_cmds)); mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_on1_cmds, ARRAY_SIZE(samsung_oled_hd_display_on1_cmds)); */ #if (BOARD_VER > WS10) noled_det = gpio_get_value(OLED_DET); if(noled_det) printk("[PANTECH_LCD] OLED Panel Connector State : Disconnect !!!(%d)\n",noled_det); else printk("[PANTECH_LCD] OLED Panel Connector State : Connect !!!(%d)\n",noled_det); if((!is_read)&(!noled_det)) #else if(!is_read) #endif { mipi_dsi_cmd_bta_sw_trigger(); mipi_samsung_oled_hd_read_id(mfd); mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_300, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_300)); is_read = TRUE; }else{ mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_20, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_20)); } mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_on2_cmds, ARRAY_SIZE(samsung_oled_hd_display_on2_cmds)); is_sleep = FALSE; printk("[PANTECH_LCD] power on state (oled_hd panel).... \n"); #ifdef D_SKY_OLED_TEMP is_oled_temp_check(); #endif samsung_oled_hd_state.disp_on = true; #ifdef CONFIG_PANTECH_HDMI_PW_CTRL_ON_LCD hdmi_autodetect_control(HDMI_PW_ON); HDMI_Schedule_Control(1); #endif } EXIT_FUNC2(); return 0; }
static void mipi_samsung_oled_hd_set_backlight(struct msm_fb_data_type *mfd) { ENTER_FUNC2(); #ifdef D_SKY_BACKLIGHT_CONTROL if(prev_bl != mfd->bl_level) { now_bl = mfd->bl_level; } else { printk("[PANTECH_LCD:%s] Equal backlight value ... pass ....(prev_bl = %d, mfd->bl_level = %d)\n",__func__,prev_bl,mfd->bl_level); return; } printk(KERN_ERR "[PANTECH_LCD:] %s: Set : %d (is_stanby_mode:%d)\n", __FUNCTION__, (mfd->bl_level),is_sleep); if((samsung_oled_hd_state.disp_initialized != true) || (samsung_oled_hd_state.disp_on == false)) { printk("[PANTECH_LCD:%s] Panel is off state....Ignore backlight value... \n",__func__); return; } mutex_lock(&mfd->dma->ov_mutex); mipi_set_tx_power_mode(0); if((is_sleep==TRUE) && (samsung_oled_hd_state.disp_on == true)) { is_sleep = FALSE; mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_wakeup_cmds, ARRAY_SIZE(samsung_oled_hd_display_wakeup_cmds)); printk("[PANTECH_LCD:%s] wakeup state (oled_hd panel).... \n",__func__); } switch (now_bl) { case 15: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_300, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_300)); break; case 14: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_280, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_280)); break; case 13: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_260, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_260)); break; case 12: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_240, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_240)); break; case 11: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_220, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_220)); break; case 10: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_200, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_200)); break; case 9: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_180, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_180)); break; case 8: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_160, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_160)); break; case 7: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_140, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_140)); break; case 6: default: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_120, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_120)); break; case 5: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_100, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_100)); break; case 4: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_80, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_80)); break; case 3: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_60, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_60)); break; case 2: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_40, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_40)); break; case 1: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_display_gamma_cmds_20, ARRAY_SIZE(samsung_oled_hd_display_gamma_cmds_20)); break; case 0: mipi_dsi_cmds_tx(mfd, &samsung_oled_hd_tx_buf, samsung_oled_hd_screen_off_cmds, ARRAY_SIZE(samsung_oled_hd_screen_off_cmds)); is_sleep = TRUE; printk("[PANTECH_LCD:%s] sleep state (oled_hd panel).... \n",__func__); break; } prev_bl = now_bl; mipi_set_tx_power_mode(1); mutex_unlock(&mfd->dma->ov_mutex); #endif EXIT_FUNC2(); }
static int mipi_renesas_lcd_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; #ifndef SKY_LCD_SINGLE_WIRE_LB_CON #ifdef CONFIG_F_SKYDISP_CHANGE_BL_TABLE_WHEN_OFFLINE_CHARGING if(is_offline_charging_mode == 1) { // Configure cabc_ctrl_con[1] to turn off CABC. cabc_ctrl_con[1] = 0; // CABC OFF } #endif #endif #if 0 if (!lcd_on_skip_during_bootup) { lcd_on_skip_during_bootup = true; renesas_state.disp_initialized = true; renesas_state.disp_on = true; goto out; } #endif if (renesas_state.disp_initialized == false) { #if defined(FEATURE_RENESAS_BL_ON_DEBUG) #ifndef SKY_LCD_SINGLE_WIRE_LB_CON cabc_data_val[2] = bl_table[0]; #endif // SKY_LCD_SINGLE_WIRE_LB_CON #endif // vci enable gpio_set_value(LCD_VCI_EN, GPIO_HIGH_VALUE); msleep(20); // reset low gpio_set_value_cansleep(gpio_lcd_mipi_reset, GPIO_LOW_VALUE); msleep(10); // reset high gpio_set_value_cansleep(gpio_lcd_mipi_reset, GPIO_HIGH_VALUE); msleep(10); mutex_lock(&renesas_state.lcd_mutex); mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_part1, ARRAY_SIZE(renesas_part1)); //mutex_unlock(&renesas_state.lcd_mutex); switch (renesas_state.test_control_flag) { case 0: //default mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_1Column, ARRAY_SIZE(renesas_1Column)); break; case 1: mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_1HDot, ARRAY_SIZE(renesas_1HDot)); PRINT("[kkcho]renesas_1HDot bl_level\n"); break; case 2: mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_2HDot, ARRAY_SIZE(renesas_2HDot)); PRINT("[kkcho]renesas_2HDot bl_level\n"); break; case 3: mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_3HDot, ARRAY_SIZE(renesas_3HDot)); PRINT("[kkcho]renesas_3HDot bl_level\n"); break; case 4: mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_3Column, ARRAY_SIZE(renesas_3Column)); PRINT("[kkcho]renesas_3Column bl_level\n"); break; default: mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_1Column, ARRAY_SIZE(renesas_1Column)); break; } //mutex_lock(&renesas_state.lcd_mutex); mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_part2, ARRAY_SIZE(renesas_part2)); mutex_unlock(&renesas_state.lcd_mutex); renesas_state.disp_initialized = true; #if defined(FEATURE_RENESAS_BL_ON_DEBUG) gpio_set_value_cansleep(gpio_lcd_bl_en, GPIO_HIGH_VALUE); gpio_set_value_cansleep(gpio_lcd_bl_ctl, GPIO_HIGH_VALUE); #endif } mutex_lock(&renesas_state.lcd_mutex); mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_display_on_cmds, ARRAY_SIZE(renesas_display_on_cmds)); mipi_dsi_cmds_tx(&renesas_tx_buf, renesas_sleep_out_cmds, ARRAY_SIZE(renesas_sleep_out_cmds)); mutex_unlock(&renesas_state.lcd_mutex); //============================================ // read test //============================================ #ifdef SKY_LCD_MIPI_TEST_READ mipi_renesas_read_buf(pdev); #endif //============================================ renesas_state.disp_on = true; //out: #ifdef CONFIG_F_SKYDISP_SILENT_BOOT // In case of reset when silentboot mode(doing boot), only when is_silent_boot_mode_n_bl_off == 0, do it. // If always do it, display silentboot image eventhough reset occur when backlight off. if(is_silent_boot_mode_n_bl_off == 0) pantech_sys_reset_backlight_flag_set(true); #endif EXIT_FUNC2(); return 0; }
static void mipi_sony_set_backlight(struct msm_fb_data_type *mfd) { int bl_level; #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT struct dcs_cmd_req cmdreq; #endif #ifndef FEATURE_RENESAS_BL_CTRL_CHG if (prev_bl_level == mfd->bl_level) return; #endif #ifdef PANTECH_LCD_MIPI_CONTROL_CHANGE if (sony_state.disp_on == false){ printk(KERN_INFO"[#######SKY_LCD#######] bl-set return during disp-off \n"); return; } if (msmfb_early_suspend_get_state()){ printk(KERN_INFO"[#######SKY_LCD#######] bl-set return during suspend \n"); return; } #endif ENTER_FUNC2(); bl_level=mfd->bl_level; printk(KERN_INFO"[SKY_LCD]mipi_sony_set_backlight prev_bl_level = %d bl_level =%d \n",prev_bl_level,mfd->bl_level); #ifdef CONFIG_F_SKYDISP_SILENT_BOOT if (is_silent_boot_mode_n_bl_off == 1) { printk(KERN_ERR"DONOT set backlight because this time is silentboot mode.\n"); return; } #endif mutex_lock(&sony_state.lcd_mutex); wrdisbv[1] = mipi_sony_backlight_tbl[bl_level]; if(!gpio_get_value_cansleep(gpio_lcd_bl_en)) gpio_set_value_cansleep(gpio_lcd_bl_en, GPIO_HIGH_VALUE); mipi_set_tx_power_mode(0); #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_cabc_bl_set_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_cabc_bl_set_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_cabc_bl_set_cmds, ARRAY_SIZE(sony_display_cabc_bl_set_cmds)); #endif prev_bl_level = mfd->bl_level; mipi_set_tx_power_mode(1); mutex_unlock(&sony_state.lcd_mutex); EXIT_FUNC2(); }
//extern void LCD_gpio_set_vci_control(int on); static int mipi_sony_lcd_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT struct dcs_cmd_req cmdreq; #endif ENTER_FUNC2(); mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; #ifdef FEATURE_SKYDISP_BOOT_ANI_SKIP_BUG_FIX if (!lcd_on_skip_during_bootup) { lcd_on_skip_during_bootup = true; sony_state.disp_initialized = true; sony_state.disp_on = true; goto out; } #endif mutex_lock(&sony_state.lcd_mutex); if(!gpio_get_value_cansleep(gpio_lcd_bl_en)) gpio_set_value_cansleep(gpio_lcd_bl_en, GPIO_HIGH_VALUE); if (sony_state.disp_initialized == false) { #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_init_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_init_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_init_cmds, ARRAY_SIZE(sony_display_init_cmds)); #endif sony_state.disp_initialized = true; } #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_on_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_on_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_on_cmds, ARRAY_SIZE(sony_display_on_cmds)); #endif sony_state.disp_on = true; #ifdef MIPI_CMDSTX_CHANGE_TO_CMDLISTPUT cmdreq.cmds = sony_display_cabc_on_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_cabc_on_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(&sony_tx_buf, sony_display_cabc_on_cmds, ARRAY_SIZE(sony_display_cabc_on_cmds)); #endif mutex_unlock(&sony_state.lcd_mutex); #ifdef FEATURE_SKYDISP_BOOT_ANI_SKIP_BUG_FIX out: #endif #if defined(CONFIG_F_SKYDISP_SILENT_BOOT) && defined(CONFIG_PANTECH_RESET_REASON) // In case of reset when silentboot mode(doing boot), only when is_silent_boot_mode_n_bl_off == 0, do it. // If always do it, display silentboot image eventhough reset occur when backlight off. if(is_silent_boot_mode_n_bl_off == 0) sky_sys_rst_set_silent_boot_backlight(1); #endif #ifdef BOOT_TOUCH_RESET // touch reset code #ifdef PANTECH_LCD_REQUEST_GPIO_TOUCHRESET if (touch_init == false) { pr_info("[LIVED] %s touch_init=%d, gpio_init=%d\n", __func__, touch_init, gpio_init); if (gpio_init == false) { if (gpio_request(touch_reset_gpio, "TOUCH_RESET_GPIO") != 0) { pr_err("[LCD]%s: fail to request touch_reset_gpio=%d, touch_init=%d, gpio_init=%d\n", __func__, touch_reset_gpio, touch_init, gpio_init); } gpio_init = true; } gpio_direction_output(TOUCH_RST_GPIO, 1); gpio_set_value(TOUCH_RST_GPIO, GPIO_LOW_VALUE); msleep(50); gpio_set_value(TOUCH_RST_GPIO, GPIO_HIGH_VALUE); touch_init = true; } #else if (touch_init == false) { gpio_direction_output(TOUCH_RST_GPIO, 1); gpio_set_value(TOUCH_RST_GPIO, GPIO_LOW_VALUE); msleep(50); gpio_set_value(TOUCH_RST_GPIO, GPIO_HIGH_VALUE); touch_init = true; } #endif #endif EXIT_FUNC2(); return 0; }
int mipi_sony_force_lcd_on(void) { struct msm_fb_data_type *mfd; struct fb_info *info; struct dcs_cmd_req cmdreq; ENTER_FUNC2(); info = registered_fb[0]; mfd = (struct msm_fb_data_type *)info->par; if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; mutex_lock(&sony_state.lcd_mutex); if (sony_state.disp_initialized == false) { cmdreq.cmds = sony_display_init_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_init_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); sony_state.disp_initialized = true; } cmdreq.cmds = sony_display_on_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_on_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); sony_state.disp_on = true; cmdreq.cmds = sony_display_cabc_on_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_cabc_on_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); wrdisbv[1] = 0; cmdreq.cmds = sony_display_cabc_bl_set_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(sony_display_cabc_bl_set_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); mutex_unlock(&sony_state.lcd_mutex); #if defined(CONFIG_F_SKYDISP_SILENT_BOOT) && defined(CONFIG_PANTECH_RESET_REASON) // In case of reset when silentboot mode(doing boot), only when is_silent_boot_mode_n_bl_off == 0, do it. // If always do it, display silentboot image eventhough reset occur when backlight off. if(is_silent_boot_mode_n_bl_off == 0) sky_sys_rst_set_silent_boot_backlight(1); #endif #ifdef BOOT_TOUCH_RESET //gpio_direction_output(TOUCH_RST_GPIO, 1); gpio_set_value(TOUCH_RST_GPIO, GPIO_LOW_VALUE); msleep(50); gpio_set_value(TOUCH_RST_GPIO, GPIO_HIGH_VALUE); #endif EXIT_FUNC2(); return 0; }