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