static int mipi_samsung_disp_send_cmd(struct msm_fb_data_type *mfd, enum mipi_samsung_cmd_list cmd, unsigned char lock) { struct dsi_cmd_desc *cmd_desc; struct dcs_cmd_req cmdreq; int cmd_size = 0; #ifdef CMD_DEBUG int i,j; #endif /* while lcd is off, ignore brightness cmd * because, it make LCD not to on */ if (mfd->resume_state == MIPI_SUSPEND_STATE) { switch (cmd) { case PANEL_BRIGHT_CTRL: pr_err("%s : 0x%d return (MIPI_SUSPEND_STATE)\n", __func__, cmd); return -EPERM; default: break; } } pr_info("%s cmd = 0x%x %s\n", __func__, cmd, mean_mipi_cmd(cmd)); if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_lock(&dsi_tx_mutex); else { if (lock) mutex_lock(&mfd->dma->ov_mutex); } switch (cmd) { case PANEL_ON: cmd_desc = msd.mpd->on.cmd; cmd_size = msd.mpd->on.size; break; case PANEL_OFF: cmd_desc = msd.mpd->off.cmd; cmd_size = msd.mpd->off.size; break; #if 0 /*temp*/ case PANEL_LATE_ON: cmd_desc = msd.mpd->late_on.cmd; cmd_size = msd.mpd->late_on.size; break; case PANEL_EARLY_OFF: cmd_desc = msd.mpd->early_off.cmd; cmd_size = msd.mpd->early_off.size; break; #endif case PANEL_BRIGHT_CTRL: cmd_desc = msd.mpd->brightness.cmd; cmd_size = msd.mpd->brightness.size; break; case PANEL_MTP_ENABLE: cmd_desc = msd.mpd->mtp_enable.cmd; cmd_size = msd.mpd->mtp_enable.size; break; case PANEL_MTP_DISABLE: cmd_desc = msd.mpd->mtp_disable.cmd; cmd_size = msd.mpd->mtp_disable.size; break; case PANEL_NEED_FLIP: cmd_desc = msd.mpd->need_flip.cmd; cmd_size = msd.mpd->need_flip.size; break; case PANEL_ACL_CONTROL: cmd_desc = msd.mpd->acl_cmds.cmd; cmd_size = msd.mpd->acl_cmds.size; break; case PANLE_TEMPERATURE: cmd_desc = msd.mpd->temperature.cmd; cmd_size = msd.mpd->temperature.size; break; case PANLE_TOUCH_KEY: cmd_desc = msd.mpd->touch_key.cmd; cmd_size = msd.mpd->touch_key.size; break; default: pr_info("%s UNKNOW CMD", __func__); goto unknown_command; ; } #ifdef CMD_DEBUG if (cmd == PANEL_BRIGHT_CTRL || cmd == PANEL_ACL_CONTROL) { pr_info("+++ cmd_size = %d\n",cmd_size); for(i=0; i<cmd_size; i++){ printk("cmd[%d] : ",i); for(j=0; j<cmd_desc[i].dlen; j++) printk("%x ",cmd_desc[i].payload[j]); printk("\n"); } pr_info("--- end\n"); } #endif if (!cmd_size) goto unknown_command; cmdreq.cmds = cmd_desc; cmdreq.cmds_cnt = cmd_size; if (cmd == PANEL_BRIGHT_CTRL) cmdreq.flags = CMD_REQ_COMMIT | CMD_REQ_SINGLE_TX; else cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_unlock(&dsi_tx_mutex); else { if (lock) mutex_unlock(&mfd->dma->ov_mutex); } return 0; unknown_command: if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_unlock(&dsi_tx_mutex); else { if (lock) mutex_unlock(&mfd->dma->ov_mutex); } 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(); }
static void sending_tune_cmd(char *src, int len) { struct msm_fb_data_type *mfd; struct dcs_cmd_req cmdreq; int data_pos; int cmd_step; int cmd_pos; cmd_step = 0; cmd_pos = 0; for (data_pos = 0; data_pos < len;) { if (*(src + data_pos) == '0') { if (*(src + data_pos + 1) == 'x') { if (!cmd_step) { mdni_tuning1[cmd_pos] = char_to_dec(*(src + data_pos + 2), *(src + data_pos + 3)); } else { mdni_tuning2[cmd_pos] = char_to_dec(*(src + data_pos + 2), *(src + data_pos + 3)); } data_pos += 3; cmd_pos++; if (cmd_pos == TUNE_FIRST_SIZE && !cmd_step) { cmd_pos = 0; cmd_step = 1; } } else data_pos++; } else { data_pos++; } } printk(KERN_INFO "\n"); for (data_pos = 0; data_pos < TUNE_FIRST_SIZE ; data_pos++) printk(KERN_INFO "0x%x ", mdni_tuning1[data_pos]); printk(KERN_INFO "\n"); for (data_pos = 0; data_pos < TUNE_SECOND_SIZE ; data_pos++) printk(KERN_INFO"0x%x ", mdni_tuning2[data_pos]); printk(KERN_INFO "\n"); mfd = platform_get_drvdata(msd.msm_pdev); mutex_lock(&dsi_tx_mutex); cmdreq.cmds = mdni_tune_cmd; cmdreq.cmds_cnt = ARRAY_SIZE(mdni_tune_cmd); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); mutex_unlock(&dsi_tx_mutex); }
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; }
//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; }
static void read_mtp(char srcReg, int readFrom, int srcLength, char *destBuffer, struct msm_fb_data_type *pMFD) { struct dcs_cmd_req cmdreq; int one_read_size = 6; int loop_limit = (srcLength / one_read_size) + 1; /* first byte = read-register */ char read_reg[2] = { 0xFF, 0x00 }; struct dsi_cmd_desc read_reg_cmd = { DTYPE_DCS_READ, 1, 0, 1, 5, sizeof(read_reg), read_reg }; /* first byte is size of Register */ char packet_size[] = { 0x00, 0x00 }; struct dsi_cmd_desc packet_size_cmd = { DTYPE_MAX_PKTSIZE, 1, 0, 0, 0, sizeof(packet_size), packet_size }; /* second byte is Read-position */ char reg_read_pos[] = { 0xB0, 0x00 }; struct dsi_cmd_desc read_pos_cmd = { DTYPE_DCS_WRITE1, 1, 0, 0, 0, sizeof(reg_read_pos), reg_read_pos }; int read_pos; int readed_size; int show_cnt; int read_size, read_loop; char show_buffer[256] = {0,}; int show_buffer_pos = 0; mutex_lock(&dsi_tx_mutex); read_reg[0] = srcReg; show_buffer_pos += snprintf(show_buffer, 256, "read_reg : %X[%d] : ", srcReg, srcLength); read_pos = readFrom; readed_size = 0; packet_size[0] = (char)srcLength; mipi_dsi_buf_init(&msd.samsung_tx_buf); cmdreq.cmds = &packet_size_cmd; cmdreq.cmds_cnt = 1; cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); show_cnt = 0; for (read_loop = 0; read_loop < loop_limit; read_loop++) { reg_read_pos[1] = read_pos; mipi_dsi_buf_init(&msd.samsung_tx_buf); cmdreq.cmds = &read_pos_cmd; cmdreq.cmds_cnt = 1; cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; if (mipi_dsi_cmdlist_put(&cmdreq) < 1) { show_buffer_pos += snprintf(show_buffer + show_buffer_pos, 256, "Tx command FAILED"); break; } mipi_dsi_buf_init(&msd.samsung_tx_buf); mipi_dsi_buf_init(&msd.samsung_rx_buf); readed_size = mipi_dsi_cmds_rx(pMFD, &msd.samsung_tx_buf, &msd.samsung_rx_buf, &read_reg_cmd, one_read_size); for (read_size = 0; read_size < readed_size; read_size++, show_cnt++) { show_buffer_pos += snprintf(show_buffer + show_buffer_pos, 256, "%02x ", msd.samsung_rx_buf.data[read_size]); if (destBuffer != NULL && show_cnt < srcLength) { pr_debug("show_cnt(%d),srcLength(%d), msd.samsung_rx_buf.data[%d] = %x \n", show_cnt,srcLength,read_size,msd.samsung_rx_buf.data[read_size]); destBuffer[show_cnt] = msd.samsung_rx_buf.data[read_size]; } } show_buffer_pos += snprintf(show_buffer + show_buffer_pos, 256, "."); read_pos += readed_size; if ((read_pos - readFrom) >= srcLength) break; } mutex_unlock(&dsi_tx_mutex); if (read_loop == loop_limit) show_buffer_pos += snprintf(show_buffer + show_buffer_pos, 256, "Overrun"); pr_info("%s\n", show_buffer); }
static int mipi_samsung_disp_send_cmd(struct msm_fb_data_type *mfd, enum mipi_samsung_cmd_list cmd, unsigned char lock) { struct dsi_cmd_desc *cmd_desc; struct dcs_cmd_req cmdreq; int cmd_size = 0; #ifdef CMD_DEBUG int i,j; #endif if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_lock(&dsi_tx_mutex); else { if (lock) mutex_lock(&mfd->dma->ov_mutex); } cmdreq.flags = CMD_REQ_COMMIT; switch (cmd) { case PANEL_READY_TO_ON: cmd_desc = msd.mpd->ready_to_on.cmd; cmd_size = msd.mpd->ready_to_on.size; break; case PANEL_ON: cmd_desc = msd.mpd->on.cmd; cmd_size = msd.mpd->on.size; break; case PANEL_OFF: cmd_desc = msd.mpd->off.cmd; cmd_size = msd.mpd->off.size; break; case PANEL_LATE_ON: cmd_desc = msd.mpd->late_on.cmd; cmd_size = msd.mpd->late_on.size; break; case PANEL_EARLY_OFF: cmd_desc = msd.mpd->early_off.cmd; cmd_size = msd.mpd->early_off.size; break; case PANEL_BRIGHT_CTRL: cmd_desc = msd.mpd->brightness.cmd; cmd_size = msd.mpd->brightness.size; cmdreq.flags = CMD_REQ_SINGLE_TX |CMD_REQ_COMMIT; break; case PANEL_MTP_ENABLE: cmd_desc = msd.mpd->mtp_enable.cmd; cmd_size = msd.mpd->mtp_enable.size; break; case PANEL_MTP_DISABLE: cmd_desc = msd.mpd->mtp_disable.cmd; cmd_size = msd.mpd->mtp_disable.size; break; case PANEL_NEED_FLIP: cmd_desc = msd.mpd->need_flip.cmd; cmd_size = msd.mpd->need_flip.size; break; case PANEL_ACL_CONTROL: cmd_desc = msd.mpd->acl_cmds.cmd; cmd_size = msd.mpd->acl_cmds.size; break; case PANLE_TOUCH_KEY: cmd_desc = msd.mpd->touch_key.cmd; cmd_size = msd.mpd->touch_key.size; break; case PANEL_LPTS: cmd_desc = msd.mpd->lpts.cmd; cmd_size = msd.mpd->lpts.size; break; default: pr_info("%s UNKNOW CMD", __func__); goto unknown_command; ; } #ifdef CMD_DEBUG if (cmd == PANEL_BRIGHT_CTRL || cmd == PANEL_ACL_CONTROL) { pr_info("+++ cmd_size = %d\n",cmd_size); for(i=0; i<cmd_size; i++){ printk("cmd[%d] : ",i); for(j=0; j<cmd_desc[i].dlen; j++) printk("%x ",cmd_desc[i].payload[j]); printk("\n"); } pr_info("--- end\n"); } #endif if (!cmd_size) goto unknown_command; cmdreq.cmds = cmd_desc; cmdreq.cmds_cnt = cmd_size; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_unlock(&dsi_tx_mutex); else { if (lock) mutex_unlock(&mfd->dma->ov_mutex); } return 0; unknown_command: if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_unlock(&dsi_tx_mutex); else { if (lock) mutex_unlock(&mfd->dma->ov_mutex); } return 0; }
static void cp5_wl_set_backlight(struct msm_fb_data_type *mfd) { int rc; led_pwm[1] = cp5_wl_shrink_pwm((unsigned char)(mfd->bl_level)); /* Check LCD power state */ 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; } /* Do not enable backlight for first boot */ if (enable_blk) { /* Set HWEN pin of LM3532 to control LED */ gpio_tlmm_config(GPIO_CFG(MSM_BL_HW_EN, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); gpio_set_value(MSM_BL_HW_EN, 1); /* Output Configuration: assign LED1 to Bank B */ rc = i2c_smbus_write_byte_data(blk_pwm_client, 0x10, 0xC1); if (rc) pr_err("i2c write fail\n"); /* Control B Full-Scale Current */ rc = i2c_smbus_write_byte_data(blk_pwm_client, 0x19, 0x13); if (rc) pr_err("i2c write fail\n"); /* Control B PWM */ rc = i2c_smbus_write_byte_data(blk_pwm_client, 0x14, 0xC2); if (rc) pr_err("i2c write fail\n"); /* Control B Zone Target 4 */ rc = i2c_smbus_write_byte_data(blk_pwm_client, 0x79, 0xFF); if (rc) pr_err("i2c write fail\n"); /* Control Enable */ rc = i2c_smbus_write_byte_data(blk_pwm_client, 0x1D, 0xFA); if (rc) pr_err("i2c write fail\n"); enable_blk = 0; } if (led_pwm[1] == 0) { /* Turn off dimming before suspend */ 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 = novatek_backlight_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(novatek_backlight_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); return; }
static int mipi_chimei_lcd_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; struct mipi_panel_info *mipi; struct msm_panel_info *pinfo; #if ESD struct fb_info *fbi; #endif 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 ESD mine_pdev = pdev;//Taylor mine_mfd = mfd;//Taylor fbi = mfd->fbi;//Taylor #endif pr_err("%s: MIPI init cmd start\n",__func__); #if 1 cmdreq_chimei.cmds = chimei_cmd_on_cmds; cmdreq_chimei.cmds_cnt = ARRAY_SIZE(chimei_cmd_on_cmds); cmdreq_chimei.flags = CMD_REQ_COMMIT; cmdreq_chimei.rlen = 0; cmdreq_chimei.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq_chimei); #else mipi_dsi_cmds_tx(&chimei_tx_buf, chimei_cmd_on_cmds, ARRAY_SIZE(chimei_cmd_on_cmds)); #endif // mipi_dsi_cmd_bta_sw_trigger(); /* clean up ack_err_status */ // // mipi_chimei_manufacture_id(mfd); //Taylor--B #if ESD lcd_on = 1; read_val = read_back_information(); if (!read_val){ //mipi_timeout=0; //wrtie_mipi_state(0); if (chimei_recover){ if (esd_lock == 1){ wake_unlock(&esd_wakelock); esd_lock = 0 ; } fbi->fbops->fb_pan_display(var_backup,fbi); mdelay(30); led_trigger_event(bkl_led_trigger, bl_backup); chimei_recover = 0;//Taylor--recover done } } schedule_delayed_work(&power_state_detect, msecs_to_jiffies(100)); //schedule the next poll operation #endif //Taylor--E pr_err("%s: MIPI init cmd end\n",__func__); return 0; }
/***************************************** @brief : transfor struct sequence to struct mipi packet, @param reg:register and param, value: reg type. @return none ******************************************/ void mipi_lcd_register_write(struct msm_fb_data_type *mfd,struct dsi_buf *tp, uint32 reg,uint32 value,uint32 time) { static boolean packet_ok = FALSE; static uint32 param_num = 0; static uint32 last_datatype = 0; static uint32 last_time = 0; uint32 datatype = 0; struct dsi_cmd_desc dsi_cmd; #ifdef USE_DSI_CMDLIST struct dcs_cmd_req cmdreq; #endif if (( (MIPI_DCS_COMMAND == last_datatype) || (MIPI_GEN_COMMAND == last_datatype) ) &&( TYPE_PARAMETER != value )) { packet_ok = TRUE; } else { packet_ok = FALSE; } if(packet_ok) { switch (param_num) { case 1: if (MIPI_DCS_COMMAND == last_datatype) { /*DCS MODE*/ datatype = DTYPE_DCS_WRITE; } else if (MIPI_GEN_COMMAND == last_datatype) { /*GCS MODE*/ datatype = DTYPE_GEN_WRITE1; } break; case 2: if (MIPI_DCS_COMMAND == last_datatype) { /*DCS MODE*/ datatype = DTYPE_DCS_WRITE1; } else if (MIPI_GEN_COMMAND == last_datatype) { /*GCS MODE*/ datatype = DTYPE_GEN_WRITE2; } break; default: if (MIPI_DCS_COMMAND == last_datatype) { /*DCS MODE*/ datatype = DTYPE_DCS_LWRITE; } else if (MIPI_GEN_COMMAND == last_datatype) { /*GCS MODE*/ datatype = DTYPE_GEN_LWRITE; } break; } dsi_cmd.dtype = datatype; dsi_cmd.last = 1; dsi_cmd.vc = 0; dsi_cmd.ack = 0; dsi_cmd.wait = last_time; dsi_cmd.dlen = param_num; dsi_cmd.payload = mipi_packet_struct; /*use qcom cmdlist interface,it have mipi sync itself*/ #ifdef USE_DSI_CMDLIST cmdreq.cmds = &dsi_cmd; cmdreq.cmds_cnt = 1; /*Qual Baseline Update,avoid backlight problem*/ cmdreq.flags = CMD_REQ_COMMIT | CMD_CLK_CTRL; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); #else mipi_dsi_cmds_tx(tp, &dsi_cmd,1); #endif packet_ok = FALSE; param_num = 0; last_datatype = 0; } switch (value) { case MIPI_DCS_COMMAND: case MIPI_GEN_COMMAND: last_datatype = value; last_time = time; mipi_packet_struct[param_num] = reg; param_num ++; break; case TYPE_PARAMETER: mipi_packet_struct[param_num] = reg; param_num ++; break; case MIPI_TYPE_END: packet_ok = FALSE; param_num = 0; last_datatype = 0; break; default : break; } }
//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_dsi_panel_power(int on) { static struct regulator *reg_lvs5, *reg_l10, *reg_l2; static int gpio11; int rc; PR_DISP_INFO("%s: on=%d\n", __func__, on); if (!dsi_power_on) { reg_lvs5 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi1_vddio"); if (IS_ERR_OR_NULL(reg_lvs5)) { pr_err("could not get 8921_lvs5, rc = %ld\n", PTR_ERR(reg_lvs5)); return -ENODEV; } reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi1_pll_vdda"); if (IS_ERR_OR_NULL(reg_l2)) { pr_err("could not get 8921_l2, rc = %ld\n", PTR_ERR(reg_l2)); return -ENODEV; } rc = regulator_set_voltage(reg_l2, 1200000, 1200000); if (rc) { pr_err("set_voltage l2 failed, rc=%d\n", rc); return -EINVAL; } reg_l10 = regulator_get(&msm_mipi_dsi1_device.dev, "dsi1_avdd"); if (IS_ERR_OR_NULL(reg_l10)) { pr_err("could not get 8921_l10, rc = %ld\n", PTR_ERR(reg_l10)); return -ENODEV; } rc = regulator_set_voltage(reg_l10, 3000000, 3000000); if (rc) { pr_err("set_voltage l10 failed, rc=%d\n", rc); return -EINVAL; } gpio11 = PM8921_GPIO_PM_TO_SYS(LCD_RSTz); rc = gpio_request(gpio11, "LCD_RSTz"); if (rc) { pr_err("request gpio 11 failed, rc=%d\n", rc); return -ENODEV; } dsi_power_on = true; } if (on) { if (!first_init) { rc = regulator_enable(reg_lvs5); if (rc) { pr_err("enable lvs5 failed, rc=%d\n", rc); return -ENODEV; } msleep(5); rc = regulator_set_optimum_mode(reg_l10, 110000); if (rc < 0) { pr_err("set_optimum_mode l10 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l10); if (rc) { pr_err("enable l10 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } msm_xo_mode_vote(wa_xo, MSM_XO_MODE_ON); msleep(20); gpio_set_value_cansleep(gpio11, 1); msleep(1); if (panel_type == PANEL_ID_IMN_SHARP_NT) { cmdreq.cmds = nvt_LowTemp_wrkr_enter; cmdreq.cmds_cnt = ARRAY_SIZE(nvt_LowTemp_wrkr_enter); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); cmdreq.cmds = nvt_LowTemp_wrkr_exit; cmdreq.cmds_cnt = ARRAY_SIZE(nvt_LowTemp_wrkr_exit); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); msleep(10); } gpio_set_value_cansleep(gpio11, 0); udelay(10); gpio_set_value_cansleep(gpio11, 1); msleep(20); msm_xo_mode_vote(wa_xo, MSM_XO_MODE_OFF); } else { rc = regulator_enable(reg_lvs5); if (rc) { pr_err("enable lvs5 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l10, 110000); if (rc < 0) { pr_err("set_optimum_mode l10 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l10); if (rc) { pr_err("enable l10 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_set_optimum_mode(reg_l2, 100000); if (rc < 0) { pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_enable(reg_l2); if (rc) { pr_err("enable l2 failed, rc=%d\n", rc); return -ENODEV; } msm_xo_mode_vote(wa_xo, MSM_XO_MODE_ON); msleep(10); msm_xo_mode_vote(wa_xo, MSM_XO_MODE_OFF); } rc = gpio_tlmm_config(cfg_panel_te_active[0], GPIO_CFG_ENABLE); if (rc) { pr_err("%s: gpio_tlmm_config(%#x)=%d\n", __func__, cfg_panel_te_active[0], rc); } } else { rc = gpio_tlmm_config(cfg_panel_te_sleep[0], GPIO_CFG_ENABLE); if (rc) { pr_err("%s: gpio_tlmm_config(%#x)=%d\n", __func__, cfg_panel_te_sleep[0], rc); } gpio_set_value_cansleep(gpio11, 0); msleep(10); rc = regulator_disable(reg_l2); if (rc) { pr_err("disable reg_l2 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_l10); if (rc) { pr_err("disable reg_l10 failed, rc=%d\n", rc); return -ENODEV; } rc = regulator_disable(reg_lvs5); if (rc) { pr_err("disable reg_lvs5 failed, rc=%d\n", rc); return -ENODEV; } } return 0; }
static int mipi_nt35510_lcd_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; struct mipi_panel_info *mipi; static int rotate; struct dcs_cmd_req cmdreq; mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; mipi = &mfd->panel_info.mipi; if (!mfd->cont_splash_done) { mfd->cont_splash_done = 1; return 0; } if (mipi_nt35510_pdata && mipi_nt35510_pdata->rotate_panel) rotate = mipi_nt35510_pdata->rotate_panel(); memset(&cmdreq, 0, sizeof(cmdreq)); if (mipi->mode == DSI_VIDEO_MODE) { cmdreq.cmds = nt35510_video_display_on_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(nt35510_video_display_on_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); if (rotate) { cmdreq.cmds = nt35510_video_display_on_cmds_rotate; cmdreq.cmds_cnt = ARRAY_SIZE(nt35510_video_display_on_cmds_rotate); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); } } else if (mipi->mode == DSI_CMD_MODE) { cmdreq.cmds = nt35510_cmd_display_on_cmds; cmdreq.cmds_cnt = ARRAY_SIZE(nt35510_cmd_display_on_cmds); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); if (rotate) { cmdreq.cmds = nt35510_cmd_display_on_cmds_rotate; cmdreq.cmds_cnt = ARRAY_SIZE(nt35510_cmd_display_on_cmds_rotate); cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); } } return 0; }
static int mipi_samsung_disp_send_cmd(struct msm_fb_data_type *mfd, enum mipi_samsung_cmd_list cmd, unsigned char lock) { struct dsi_cmd_desc *cmd_desc; struct dcs_cmd_req cmdreq; int cmd_size = 0; /* wake_lock(&idle_wake_lock);*//*temp*/ if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_lock(&dsi_tx_mutex); else { if (lock) mutex_lock(&mfd->dma->ov_mutex); } pr_info("%s cmd = 0x%x\n", __func__, cmd); switch (cmd) { case PANEL_READY_TO_ON: /*work*/ cmd_desc = msd.mpd->ready_to_on.cmd; cmd_size = msd.mpd->ready_to_on.size; break; case PANEL_READY_TO_OFF: cmd_desc = msd.mpd->ready_to_off.cmd; cmd_size = msd.mpd->ready_to_off.size; break; case PANEL_ON: cmd_desc = msd.mpd->on.cmd; cmd_size = msd.mpd->on.size; break; case PANEL_OFF: cmd_desc = msd.mpd->off.cmd; cmd_size = msd.mpd->off.size; break; case PANEL_LATE_ON: cmd_desc = msd.mpd->late_on.cmd; cmd_size = msd.mpd->late_on.size; break; case PANEL_EARLY_OFF: cmd_desc = msd.mpd->early_off.cmd; cmd_size = msd.mpd->early_off.size; break; case MTP_READ_ENABLE: cmd_desc = msd.mpd->mtp_read_enable.cmd; cmd_size = msd.mpd->mtp_read_enable.size; break; /* case PANEL_TUNE_CTRL: cmd_desc = msd.mpd->tune.cmd; cmd_size = msd.mpd->tune.size; break; */ default: goto unknown_command; ; } if (!cmd_size) goto unknown_command; cmdreq.cmds = cmd_desc; cmdreq.cmds_cnt = cmd_size; cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_unlock(&dsi_tx_mutex); else { if (lock) mutex_unlock(&mfd->dma->ov_mutex); } return 0; unknown_command: if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_unlock(&dsi_tx_mutex); else { if (lock) mutex_unlock(&mfd->dma->ov_mutex); } return 0; }