void mipi_sony_panel_type_detect(struct mipi_panel_info *mipi)
{
if (panel_type == PANEL_ID_PRIMODS_SONY) {
PR_DISP_INFO("%s: panel_type=PANEL_ID_PRIMODS_SONY\n", __func__);
strcat(ptype, "PANEL_ID_PRIMODS_SONY");
mipi_power_on_cmd = primods_sony_cmd_on_cmds;
mipi_power_on_cmd_size = ARRAY_SIZE(primods_sony_cmd_on_cmds);
mipi_power_off_cmd = sony_display_off_cmds;
mipi_power_off_cmd_size = ARRAY_SIZE(sony_display_off_cmds);
} else if (panel_type == PANEL_ID_PRIMODD_SONY) {
PR_DISP_INFO("%s: panel_type=PANEL_ID_PRIMODD_SONY\n", __func__);
strcat(ptype, "PANEL_ID_PRIMODD_SONY");
mipi_power_on_cmd = primods_sony_cmd_on_cmds;
mipi_power_on_cmd_size = ARRAY_SIZE(primods_sony_cmd_on_cmds);
mipi_power_off_cmd = sony_display_off_cmds;
mipi_power_off_cmd_size = ARRAY_SIZE(sony_display_off_cmds);
} else {
printk(KERN_ERR "%s: panel_type=0x%x not support\n", __func__, panel_type);
strcat(ptype, "PANEL_ID_NONE");
}
return;
}
int mipi_dsi_cmd_reg_tx(uint32 data)
{
#ifdef DSI_HOST_DEBUG
int i;
char *bp;
bp = (char *)&data;
PR_DISP_INFO("%s: ", __func__);
for (i = 0; i < 4; i++)
PR_DISP_INFO("%x ", *bp++);
PR_DISP_INFO("\n");
#endif
MIPI_OUTP(MIPI_DSI_BASE + 0x0080, 0x04);/* sw trigger */
MIPI_OUTP(MIPI_DSI_BASE + 0x0, 0x135);
wmb();
MIPI_OUTP(MIPI_DSI_BASE + 0x038, data);
wmb();
MIPI_OUTP(MIPI_DSI_BASE + 0x08c, 0x01); /* trigger */
wmb();
udelay(300);
return 4;
}
/*
TODO:
1.find a better way to handle msm_fb_resources, to avoid passing it across file.
2.error handling
*/
int __init golfu_init_panel(void)
{
int ret = 0;
if ((panel_type == PANEL_ID_PIO_SAMSUNG) ||
(panel_type == PANEL_ID_PIO_SAMSUNG_C2))
mipi_dsi_cmd_hvga_panel_device.name = "mipi_samsung";
else if (panel_type == PANEL_ID_GOLFU_AUO ||
panel_type == PANEL_ID_GOLFU_AUO_C2 ||
panel_type == PANEL_ID_GOLFU_AUO_C3 ||
panel_type == PANEL_ID_GOLFU_AUO_C4)
mipi_dsi_cmd_hvga_panel_device.name = "mipi_orise";
else
golfu_panel_power(0);
PR_DISP_INFO("panel_type= 0x%x\n", panel_type);
PR_DISP_INFO("%s: %s\n", __func__, mipi_dsi_cmd_hvga_panel_device.name);
mipi_golfu_panel_data.shrink_pwm = golfu_shrink_pwm;
ret = platform_device_register(&msm_fb_device);
ret = platform_device_register(&mipi_dsi_cmd_hvga_panel_device);
msm_fb_add_devices();
return 0;
}
static int __init deluxe_j_panel_init(void)
{
int ret;
if(panel_type == PANEL_ID_NONE) {
PR_DISP_INFO("%s panel ID = PANEL_ID_NONE\n", __func__);
return 0;
}
ret = i2c_add_driver(&pwm_i2c_driver);
if (ret)
pr_err(KERN_ERR "%s: failed to add i2c driver\n", __func__);
mipi_dsi_buf_alloc(&deluxe_j_panel_tx_buf, DSI_BUF_SIZE);
mipi_dsi_buf_alloc(&deluxe_j_panel_rx_buf, DSI_BUF_SIZE);
if (panel_type == PANEL_ID_DLXJ_SHARP_RENESAS) {
mipi_video_sharp_init();
PR_DISP_INFO("%s panel ID = PANEL_ID_DLXJ_SHARP_RENESAS\n", __func__);
} else if (panel_type == PANEL_ID_DLXJ_SONY_RENESAS) {
mipi_video_sony_init();
PR_DISP_INFO("%s panel ID = PANEL_ID_DLXJ_SONY_RENESAS\n", __func__);
} else {
PR_DISP_ERR("%s: panel not supported!!\n", __func__);
return -ENODEV;
}
PR_DISP_INFO("%s\n", __func__);
return platform_driver_register(&this_driver);
}
static int __init impression_j_panel_init(void)
{
if(panel_type == PANEL_ID_NONE) {
PR_DISP_INFO("%s panel ID = PANEL_ID_NONE\n", __func__);
return 0;
}
mipi_dsi_buf_alloc(&impression_j_panel_tx_buf, DSI_BUF_SIZE);
mipi_dsi_buf_alloc(&impression_j_panel_rx_buf, DSI_BUF_SIZE);
if (panel_type == PANEL_ID_IMN_SHARP_HX) {
mipi_cmd_sharp_init();
PR_DISP_INFO("%s panel ID = PANEL_ID_IMN_SHARP_HX\n", __func__);
} else if (panel_type == PANEL_ID_IMN_SHARP_NT) {
mipi_video_sharp_nt_720p_pt_init();
PR_DISP_INFO("%s panel ID = PANEL_ID_IMN_SHARP_NT\n", __func__);
} else {
PR_DISP_ERR("%s: panel not supported!!\n", __func__);
return -ENODEV;
}
PR_DISP_INFO("%s\n", __func__);
return platform_driver_register(&this_driver);
}
static int ville_samsung_acl_enable(int on, struct msm_fb_data_type *mfd)
{
static int first_time = 1;
static unsigned long last_autobkl_stat = 0, cur_autobkl_stat = 0;
if(cur_bl_level > 245)
cur_autobkl_stat = 8;
else
cur_autobkl_stat = on;
if(cur_autobkl_stat == last_autobkl_stat)
return 0;
last_autobkl_stat = cur_autobkl_stat;
if (cur_autobkl_stat == 8 && !first_time) {
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG || panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2) {
mipi_dsi_cmds_tx(&ville_panel_tx_buf, samsung_acl_off_cmd,
ARRAY_SIZE(samsung_acl_off_cmd));
acl_enable = 0;
PR_DISP_INFO("%s acl disable", __func__);
}
} else if (cur_autobkl_stat == 12) {
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG || panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2) {
mipi_dsi_cmds_tx(&ville_panel_tx_buf, samsung_acl_on_cmd,
ARRAY_SIZE(samsung_acl_on_cmd));
acl_enable = 1;
PR_DISP_INFO("%s acl enable", __func__);
}
}
first_time = 0;
return 0;
}
void mipi_samsung_panel_type_detect(struct mipi_panel_info *mipi)
{
if (panel_type == PANEL_ID_PIO_SAMSUNG) {
PR_DISP_INFO("%s: panel_type=PANEL_ID_PIO_SAMSUNG\n", __func__);
strcat(ptype, "PANEL_ID_PIO_SAMSUNG");
if (mipi->mode == DSI_VIDEO_MODE) {
mipi_power_on_cmd = pico_samsung_cmd_on_cmds;
mipi_power_on_cmd_size = ARRAY_SIZE(pico_samsung_cmd_on_cmds);
} else {
mipi_power_on_cmd = pico_samsung_cmd_on_cmds;
mipi_power_on_cmd_size = ARRAY_SIZE(pico_samsung_cmd_on_cmds);
}
mipi_power_off_cmd = samsung_display_off_cmds;
mipi_power_off_cmd_size = ARRAY_SIZE(samsung_display_off_cmds);
} else if (panel_type == PANEL_ID_PIO_SAMSUNG_C2) {
PR_DISP_INFO("%s: panel_type=PANEL_ID_PIO_SAMSUNG_C2\n", __func__);
strcat(ptype, "PANEL_ID_PIO_SAMSUNG_C2");
if (mipi->mode == DSI_VIDEO_MODE) {
mipi_power_on_cmd = pico_samsung_C2_cmd_on_cmds;
mipi_power_on_cmd_size = ARRAY_SIZE(pico_samsung_C2_cmd_on_cmds);
} else {
mipi_power_on_cmd = pico_samsung_C2_cmd_on_cmds;
mipi_power_on_cmd_size = ARRAY_SIZE(pico_samsung_C2_cmd_on_cmds);
}
mipi_power_off_cmd = samsung_display_off_cmds;
mipi_power_off_cmd_size = ARRAY_SIZE(samsung_display_off_cmds);
} else {
printk(KERN_ERR "%s: panel_type=0x%x not support\n", __func__, panel_type);
strcat(ptype, "PANEL_ID_NONE");
}
return;
}
static int deluxe_j_detect_panel(const char *name)
{
#if 0
if (panel_type == PANEL_ID_DLX_SONY_RENESAS) {
if (!strncmp(name, MIPI_RENESAS_PANEL_NAME,
strnlen(MIPI_RENESAS_PANEL_NAME,
PANEL_NAME_MAX_LEN))){
PR_DISP_INFO("deluxe_j_%s\n", name);
return 0;
}
} else if (panel_type == PANEL_ID_DLX_SHARP_RENESAS) {
if (!strncmp(name, MIPI_RENESAS_PANEL_NAME,
strnlen(MIPI_RENESAS_PANEL_NAME,
PANEL_NAME_MAX_LEN))){
PR_DISP_INFO("deluxe_j_%s\n", name);
return 0;
}
}
#endif
if (!strncmp(name, HDMI_PANEL_NAME,
strnlen(HDMI_PANEL_NAME,
PANEL_NAME_MAX_LEN)))
return 0;
return -ENODEV;
}
static int lcdc_off(struct platform_device *pdev)
{
int ret = 0;
struct msm_fb_data_type *mfd;
PR_DISP_INFO("+ %s\n", __func__);
mfd = platform_get_drvdata(pdev);
ret = panel_next_off(pdev);
clk_disable(pixel_mdp_clk);
clk_disable(pixel_lcdc_clk);
if (lcdc_pdata && lcdc_pdata->lcdc_power_save)
lcdc_pdata->lcdc_power_save(0);
if (lcdc_pdata && lcdc_pdata->lcdc_gpio_config)
ret = lcdc_pdata->lcdc_gpio_config(0);
#ifndef CONFIG_MSM_BUS_SCALING
if (mfd->ebi1_clk)
clk_disable(mfd->ebi1_clk);
#else
mdp_bus_scale_update_request(0);
#endif
PR_DISP_INFO("- %s\n", __func__);
return ret;
}
static int htc_hiaaero_panel_power_on(struct mdss_panel_data *pdata, int enable)
{
int ret;
struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
struct dsi_power_data *pwrdata = NULL;
PR_DISP_INFO("%s: en=%d\n", __func__, enable);
if (pdata == NULL) {
PR_DISP_ERR("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata, panel_data);
pwrdata = ctrl_pdata->dsi_pwrctrl_data;
if (!pwrdata) {
PR_DISP_ERR("%s: pwrdata not initialized\n", __func__);
return -EINVAL;
}
if (enable) {
ret = regulator_set_optimum_mode(pwrdata->vci, 100000);
if (ret < 0) {
PR_DISP_ERR("%s: vdda set opt mode failed.\n",
__func__);
return ret;
}
ret = regulator_enable(pwrdata->vci);
if (ret) {
PR_DISP_ERR("%s: Failed to enable regulator.\n",__func__);
return ret;
}
usleep_range(1000,1500);
gpio_set_value(pwrdata->vdd1v8, 1);
} else {
gpio_set_value(pwrdata->vdd1v8, 0);
ret = regulator_disable(pwrdata->vci);
if (ret) {
PR_DISP_ERR("%s: Failed to disable vdda regulator.\n",
__func__);
return ret;
}
ret = regulator_set_optimum_mode(pwrdata->vci, 100);
if (ret < 0) {
PR_DISP_ERR("%s: vddpll_vreg set opt mode failed.\n",
__func__);
return ret;
}
}
PR_DISP_INFO("%s: en=%d done\n", __func__, enable);
return 0;
}
static int lcdc_on(struct platform_device *pdev)
{
int ret = 0;
struct msm_fb_data_type *mfd;
unsigned long panel_pixclock_freq = 0;
#ifndef CONFIG_MSM_BUS_SCALING
unsigned long pm_qos_rate;
#endif
PR_DISP_INFO("+ %s\n", __func__);
mfd = platform_get_drvdata(pdev);
if (lcdc_pdata && lcdc_pdata->lcdc_get_clk)
panel_pixclock_freq = lcdc_pdata->lcdc_get_clk();
if (!panel_pixclock_freq)
panel_pixclock_freq = mfd->fbi->var.pixclock;
#ifdef CONFIG_MSM_BUS_SCALING
mdp_bus_scale_update_request(2);
#else
#ifdef CONFIG_MSM_NPA_SYSTEM_BUS
pm_qos_rate = MSM_AXI_FLOW_MDP_LCDC_WVGA_2BPP;
#else
if (panel_pixclock_freq > 65000000)
/* pm_qos_rate should be in Khz */
pm_qos_rate = panel_pixclock_freq / 1000 ;
else
pm_qos_rate = 65000;
#endif
if (mfd->ebi1_clk) {
clk_set_rate(mfd->ebi1_clk, pm_qos_rate * 1000);
clk_enable(mfd->ebi1_clk);
}
#endif
mfd = platform_get_drvdata(pdev);
mfd->fbi->var.pixclock = clk_round_rate(pixel_mdp_clk,
mfd->fbi->var.pixclock);
ret = clk_set_rate(pixel_mdp_clk, mfd->fbi->var.pixclock);
if (ret) {
pr_err("%s: Can't set MDP LCDC pixel clock to rate %u\n",
__func__, mfd->fbi->var.pixclock);
goto out;
}
clk_enable(pixel_mdp_clk);
clk_enable(pixel_lcdc_clk);
if (lcdc_pdata && lcdc_pdata->lcdc_power_save)
lcdc_pdata->lcdc_power_save(1);
if (lcdc_pdata && lcdc_pdata->lcdc_gpio_config)
ret = lcdc_pdata->lcdc_gpio_config(1);
ret = panel_next_on(pdev);
out:
PR_DISP_INFO("- %s\n", __func__);
return ret;
}
/*
* mutex need to be acquired by caller
*/
void mipi_dsi_controller_cfg(int enable, int cmd, int video)
{
uint32 dsi_ctrl;
uint32 status, mask;
int cnt;
mask = 0x02; /* CMD_MODE_DMA_BUSY */
if (!cmd || !video) {
if (cmd)
mask |= 0x08; /* VIDEO_MODE_ENGINE_BUSY */
else
mask |= 0x04; /* CMD_MODE_MDP_BUSY */
}
cnt = 16;
while (cnt--) {
status = MIPI_INP(MIPI_DSI_BASE + 0x0004);
status &= mask;
if (status == 0)
break;
usleep(1000);
}
if (cnt == 0)
PR_DISP_INFO("%s: DSI status=%x failed\n", __func__, status);
cnt = 16;
while (cnt--) {
status = MIPI_INP(MIPI_DSI_BASE + 0x0008);
status &= 0x11111000; /* x_HS_FIFO_EMPTY */
if (status == 0x11111000) /* all empty */
break;
usleep(1000);
}
if (cnt == 0)
PR_DISP_INFO("%s: FIFO status=%x failed\n", __func__, status);
dsi_ctrl = MIPI_INP(MIPI_DSI_BASE + 0x0000);
if (enable)
dsi_ctrl |= 0x01;
else
dsi_ctrl &= ~0x01;
if (cmd && video) {
dsi_ctrl |= 0x06;
} else if (cmd) {
dsi_ctrl &= ~0x02;
dsi_ctrl |= 0x04;
} else if (video) {
dsi_ctrl &= ~0x04;
dsi_ctrl |= 0x02;
}
MIPI_OUTP(MIPI_DSI_BASE + 0x0000, dsi_ctrl);
wmb();
}
int mdp_dsi_video_off(struct platform_device *pdev)
{
int ret = 0;
int retry_cnt = 0;
struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)platform_get_drvdata(pdev);
PR_DISP_INFO("%s\n", __func__);
if (panel_type == PANEL_ID_PROTOU_LG || panel_type == PANEL_ID_PROTODCG_LG) {
if(!mfd) {
PR_DISP_ERR("mdp_dsi_video_off: mfd is NULL\n");
return -ENODEV;
}
do {
memset(mfd->fbi->screen_base, 0x00, mfd->fbi->fix.smem_len);
hr_msleep(80);
#ifdef CONFIG_MACH_DUMMY
ret = protodcg_lcd_off2(pdev);
#elif defined CONFIG_MACH_PROTOU
ret = protou_lcd_off2(pdev);
#else
#endif
if (ret < 0) {
panel_next_off(pdev);
hr_msleep(2);
panel_next_on(pdev);
hr_msleep(5);
retry_cnt++;
} else {
ret = 0;
break;
}
} while (retry_cnt < 10);
PR_DISP_INFO("%s : mipi_lg_lcd_off retry_cnt = %d\n", __func__, retry_cnt);
hr_msleep(20);
}
mdp_histogram_ctrl_all(FALSE);
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 0);
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
mdp_pipe_ctrl(MDP_DMA2_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
ret = panel_next_off(pdev);
atomic_set(&vsync_cntrl.suspend, 1);
atomic_set(&vsync_cntrl.vsync_resume, 0);
complete_all(&vsync_cntrl.vsync_wait);
msleep(20);
return ret;
}
// -----------------------------------------------------------------------------
// Common Routine Implementation
// -----------------------------------------------------------------------------
static int mipi_himax_lcd_on(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
struct mipi_panel_info *mipi;
mfd = platform_get_drvdata(pdev);
if (!mfd)
return -ENODEV;
if (mfd->key != MFD_KEY)
return -EINVAL;
mipi = &mfd->panel_info.mipi;
if (panel_type == PANEL_ID_VIG_SHARP_HX_C2)
PR_DISP_INFO("Panel type = PANEL_ID_VIG_SHARP_HX_C2\n");
else if (panel_type == PANEL_ID_VIG_SHARP_HX)
PR_DISP_INFO("Panel type = PANEL_ID_VIG_SHARP_HX\n");
else if (panel_type == PANEL_ID_VIG_CHIMEI_HX)
PR_DISP_INFO("Panel type = PANEL_ID_VIG_CHIMEI_HX\n");
mutex_lock(&cmdlock);
if (mipi->mode == DSI_VIDEO_MODE) {
PR_DISP_INFO("DSI_VIDEO_MODE.%s",__func__);
if (panel_type == PANEL_ID_VIG_CHIMEI_HX)
{
mipi_dsi_cmds_tx(&himax_tx_buf, himax_CMI_video_on_cmds,
ARRAY_SIZE(himax_CMI_video_on_cmds));
}else
{
mipi_dsi_cmds_tx(&himax_tx_buf, himax_video_on_cmds,
ARRAY_SIZE(himax_video_on_cmds));
}
} else {
PR_DISP_INFO("DSI_CMD_MODE.%s",__func__);
if (panel_type == PANEL_ID_VIG_CHIMEI_HX)
{
mipi_dsi_cmds_tx(&himax_tx_buf, himax_CMI_cmd_on_cmds,
ARRAY_SIZE(himax_CMI_cmd_on_cmds));
}else
{
mipi_dsi_cmds_tx(&himax_tx_buf, himax_cmd_on_cmds,
ARRAY_SIZE(himax_cmd_on_cmds));
}
mipi_dsi_cmd_bta_sw_trigger();
mipi_himax_manufacture_id();
}
mutex_unlock(&cmdlock);
return 0;
}
static int mdp4_dsi_video_do_blt(struct msm_fb_data_type *mfd, int enable)
{
unsigned long flag;
unsigned int data;
int change = 0;
void mdp4_overlay_dsi_video_wait4dmap(struct msm_fb_data_type *mfd);
PR_DISP_INFO("%s: enable=%d addr=%x base=%x\n", __func__, enable, (int)dsi_pipe->blt_addr, (int)dsi_pipe->blt_base);
spin_lock_irqsave(&mdp_spin_lock, flag);
if (enable && dsi_pipe->blt_addr == 0) {
dsi_pipe->blt_addr = dsi_pipe->blt_base;
change++;
} else if (enable == 0 && dsi_pipe->blt_addr) {
dsi_pipe->blt_addr = 0;
change++;
}
dsi_pipe->blt_cnt = 0;
spin_unlock_irqrestore(&mdp_spin_lock, flag);
if (!change)
return 0;
mutex_lock(&cmdlock);
PR_DISP_INFO("%s: start\n", __func__);
data = inpdw(MDP_BASE + DSI_VIDEO_BASE);
data &= 0x01;
if (data) { /* timing generator enabled */
mdp4_overlay_dsi_video_wait4dmap(mfd);
MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 0);
mdelay(17); /* make sure last frame is finished */
mipi_dsi_controller_cfg(0, 0, 0);
}
mdp4_overlayproc_cfg(dsi_pipe);
mdp4_overlay_dmap_xy(dsi_pipe);
if (data) { /* timing generator enabled */
MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 1);
mdp4_overlay_dsi_video_wait4dmap(mfd);
mdp4_overlay_dsi_video_wait4dmap(mfd);
MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 0);
mipi_dsi_sw_reset();
mipi_dsi_controller_cfg(1, 0, 0);
MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 1);
}
PR_DISP_INFO("%s: done\n", __func__);
mutex_unlock(&cmdlock);
return 0;
}
static void mdp4_dsi_overlay_busy_wait(struct msm_fb_data_type *mfd)
{
unsigned long flag;
int need_wait = 0;
#if 1 /* HTC_CSP_START */
int retry_count = 0;
long timeout;
#endif /* HTC_CSP_END */
spin_lock_irqsave(&mdp_spin_lock, flag);
if (mfd->dma->busy == TRUE) {
INIT_COMPLETION(mfd->dma->comp);
need_wait++;
}
spin_unlock_irqrestore(&mdp_spin_lock, flag);
if (need_wait) {
#if 1 /* HTC_CSP_START */
mdp4_stat.busywait1++;
timeout = wait_for_completion_timeout(&mfd->dma->comp, HZ/5);
mdp4_stat.busywait1--;
while (!timeout && retry_count++ < 15) {
rmb();
if (mfd->dma->busy == FALSE) {
PR_DISP_INFO("%s(%d)timeout but dma not busy now\n", __func__, __LINE__);
break;
} else {
PR_DISP_INFO("%s(%d)timeout but dma still busy\n", __func__, __LINE__);
PR_DISP_INFO("### need_wait:%d pending pid=%d dsi_clk_on=%d\n", need_wait, current->pid, mipi_dsi_clk_on);
mdp4_dump_status();
mdp4_stat.busywait1++;
timeout = wait_for_completion_timeout(&mfd->dma->comp, HZ/5);
mdp4_stat.busywait1--;
}
}
if (retry_count >= 15) {
PR_DISP_INFO("###mdp busy wait retry timed out, mfd->dma->busy:%d\n", mfd->dma->busy);
spin_lock_irqsave(&mdp_spin_lock, flag);
mfd->dma->busy = FALSE;
spin_unlock_irqrestore(&mdp_spin_lock, flag);
}
#else /* HTC_CSP_END */
mdp4_stat.busywait1++;
wait_for_completion(&mfd->dma->comp);
mdp4_stat.busywait1--;
#endif
}
}
static int protou_lcd_on(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
struct msm_fb_panel_data *pdata = NULL;
struct mipi_panel_info *mipi;
mfd = platform_get_drvdata(pdev);
if (!mfd)
return -ENODEV;
pdata = (struct msm_fb_panel_data *)mfd->pdev->dev.platform_data;
if (mfd->key != MFD_KEY)
return -EINVAL;
mipi = &mfd->panel_info.mipi;
if (mfd->init_mipi_lcd == 0) {
PR_DISP_INFO("Display On - 1st time\n");
if (panel_type == PANEL_ID_PROTOU_SHARP || panel_type == PANEL_ID_PROTOU_SHARP_C1)
mipi_dsi_cmds_tx(mfd, &protou_panel_tx_buf, protou_power_on_cmd,
protou_power_on_cmd_size);
mfd->init_mipi_lcd = 1;
} else {
PR_DISP_INFO("Display On \n");
if (panel_type != PANEL_ID_NONE) {
PR_DISP_INFO("%s\n", ptype);
htc_mdp_sem_down(current, &mfd->dma->mutex);
mipi_dsi_cmds_tx(mfd, &protou_panel_tx_buf, protou_power_on_cmd,
protou_power_on_cmd_size);
htc_mdp_sem_up(&mfd->dma->mutex);
#if 0 /* mipi read command verify */
/* clean up ack_err_status */
mdelay(1000);
mipi_dsi_cmd_bta_sw_trigger();
protou_manufacture_id(mfd);
#endif
} else {
printk(KERN_ERR "panel_type=0x%x not support at power on\n", panel_type);
return -EINVAL;
}
}
PR_DISP_DEBUG("Init done!\n");
return 0;
}
int mipi_dsi_cmd_dma_tx(struct dsi_buf *tp)
{
int len;
long timeout;
#ifdef DSI_HOST_DEBUG
int i;
char *bp;
bp = tp->data;
PR_DISP_INFO("%s: ", __func__);
for (i = 0; i < tp->len; i++)
PR_DISP_INFO("%x ", *bp++);
PR_DISP_INFO("\n");
#endif
len = tp->len;
len += 3;
len &= ~0x03; /* multipled by 4 */
tp->dmap = dma_map_single(&dsi_dev, tp->data, len, DMA_TO_DEVICE);
if (dma_mapping_error(&dsi_dev, tp->dmap))
PR_DISP_ERR("%s: dmap mapp failed\n", __func__);
INIT_COMPLETION(dsi_dma_comp);
MIPI_OUTP(MIPI_DSI_BASE + 0x044, tp->dmap);
MIPI_OUTP(MIPI_DSI_BASE + 0x048, len);
wmb();
MIPI_OUTP(MIPI_DSI_BASE + 0x08c, 0x01); /* trigger */
wmb();
timeout = wait_for_completion_timeout(&dsi_dma_comp, HZ/10);
if (!timeout) {
u32 isr = MIPI_INP(MIPI_DSI_BASE + 0x010c);
MIPI_OUTP(MIPI_DSI_BASE + 0x010c, isr);
PR_DISP_ERR("%s timeout, isr=0x%08x\n", __func__, isr);
mipi_dsi_read_status_reg();
mipi_dsi_sw_reset();
atomic_set(&need_soft_reset, 1);
}
dma_unmap_single(&dsi_dev, tp->dmap, len, DMA_TO_DEVICE);
tp->dmap = 0;
return tp->len;
}
static int lcdc_resume(struct msm_panel_data *fb_panel)
{
struct mdp_lcdc_info *lcdc = panel_to_lcdc(fb_panel);
struct msm_lcdc_panel_ops *panel_ops = lcdc->pdata->panel_ops;
PR_DISP_INFO("%s: resuming\n", __func__);
if (panel_ops->init) {
if (panel_ops->init(panel_ops) < 0)
PR_DISP_ERR("LCD init fail!\n");
}
clk_enable(lcdc->mdp_clk);
clk_enable(lcdc->pclk);
clk_enable(lcdc->pad_pclk);
#if defined(CONFIG_ARCH_MSM7227)
writel(0x1, LCDC_MUX_CTL);
D("resume_lcdc_mux_ctl = %x\n", readl(LCDC_MUX_CTL));
#endif
mdp_writel(lcdc->mdp, 1, MDP_LCDC_EN);
#ifdef CONFIG_PANEL_SELF_REFRESH
if (lcdc->mdp->mdp_dev.overrides & MSM_MDP_RGB_PANEL_SELE_REFRESH) {
mutex_lock(&panel_icm->icm_lock);
panel_icm->icm_doable = true;
panel_icm->clock_enabled = true;
panel_icm->icm_suspend = false;
mutex_unlock(&panel_icm->icm_lock);
}
#endif
return 0;
}
static ssize_t store_3D_mode(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
enum MODE_3D val = buf[0] - '0';
if (val < 0 || val >= BARRIER_END) {
pr_err("%s: unsupport value %c\n", __func__, val);
return -EINVAL;
}
if (val == atomic_read(&g_3D_mode)) {
printk(KERN_NOTICE "%s: status is same(%d)\n", __func__, val);
return count;
}
atomic_set(&g_3D_mode, val);
PR_DISP_INFO("%s mode = %d\n", __func__, val);
switch (val) {
case BARRIER_OFF:
shooter_u_3Dpanel_off();
break;
case BARRIER_LANDSCAPE:
shooter_u_3Dpanel_on(true);
break;
case BARRIER_PORTRAIT:
shooter_u_3Dpanel_on(false);
break;
default:
break;
}
return count;
}
int shooter_u_mdp_gamma(void)
{
PR_DISP_INFO("%s\n", __func__);
mdp4_dsi_color_enhancement(mdp_sharp_barrier_off, ARRAY_SIZE(mdp_sharp_barrier_off));
return 0;
}
int shooter_u_mdp_color_enhance(void)
{
PR_DISP_INFO("%s\n", __func__);
/* mdp4_dsi_color_enhancement(shooter_u_color_v11, ARRAY_SIZE(shooter_u_color_v11)); */
return 0;
}
static void ville_display_on(struct msm_fb_data_type *mfd)
{
printk(KERN_INFO "%s ++\n", __func__);
mutex_lock(&mfd->dma->ov_mutex);
if (mfd->panel_info.type == MIPI_CMD_PANEL) {
mdp4_dsi_cmd_dma_busy_wait(mfd);
mdp4_dsi_blt_dmap_busy_wait(mfd);
mipi_dsi_mdp_busy_wait(mfd);
}
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG || panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2)
mipi_dsi_cmds_tx(mfd, &ville_panel_tx_buf, samsung_display_on_cmds,
ARRAY_SIZE(samsung_display_on_cmds));
else if (panel_type == PANEL_ID_VILLE_AUO)
mipi_dsi_cmds_tx(mfd, &ville_panel_tx_buf, samsung_display_on_cmds,
ARRAY_SIZE(auo_display_on_cmds));
cur_bl_level = 0;
if (acl_enable) {
mipi_dsi_cmds_tx(mfd, &ville_panel_tx_buf, samsung_acl_on_cmd,
ARRAY_SIZE(samsung_acl_on_cmd));
acl_enable = 1;
PR_DISP_INFO("%s acl enable", __func__);
}
mutex_unlock(&mfd->dma->ov_mutex);
printk(KERN_INFO "%s --\n", __func__);
}
int mdp4_dtv_off(struct platform_device *pdev)
{
int ret = 0;
ret = panel_next_off(pdev);
/* disable DTV block */
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
MDP_OUTP(MDP_BASE + DTV_BASE, 0);
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
mdp_pipe_ctrl(MDP_OVERLAY1_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
/* delay to make sure the last frame finishes */
msleep(100);
/* We also delay to turn writeback mode off after new overlay_set finishes */
atomic_set(&mdp_dtv_on, false);
PR_DISP_INFO("%s\n", __func__);
/* dis-engage rgb2 from mixer1 */
if (dtv_pipe)
mdp4_mixer_stage_down(dtv_pipe);
return ret;
}
static void golfu_panel_power(int on)
{
PR_DISP_INFO("%s: power %s.\n", __func__, on ? "on" : "off");
if (on) {
gpio_set_value(GOLFU_GPIO_LCD_RST_N, 1);
hr_msleep(1);
gpio_set_value(GOLFU_GPIO_LCM_1v8_EN, 1);
hr_msleep(5);
gpio_set_value(GOLFU_GPIO_LCM_2v85_EN, 1);
hr_msleep(1);
gpio_set_value(GOLFU_GPIO_LCD_RST_N, 1);
hr_msleep(1);
gpio_set_value(GOLFU_GPIO_LCD_RST_N, 0);
udelay(50);
gpio_set_value(GOLFU_GPIO_LCD_RST_N, 1);
udelay(50);
} else {
gpio_set_value(GOLFU_GPIO_LCM_2v85_EN, 0);
gpio_set_value(GOLFU_GPIO_LCM_1v8_EN, 0);
hr_msleep(300);
gpio_set_value(GOLFU_GPIO_LCD_RST_N, 0);
}
}
static int mipi_dsi_set_backlight(struct msm_fb_data_type *mfd)
{
struct mipi_panel_info *mipi;
mutex_lock(&cmdlock);
mipi = &mfd->panel_info.mipi;
PR_DISP_INFO("%s+:bl=%d status=%d\n", __func__, mfd->bl_level, mipi_status);
if (mipi_status == 0)
goto end;
if (mipi_himax_pdata && mipi_himax_pdata->shrink_pwm)
led_pwm1[1] = mipi_himax_pdata->shrink_pwm(mfd->bl_level);
else
led_pwm1[1] = (unsigned char)(mfd->bl_level);
if(mfd->bl_level == 0 || board_mfg_mode() == 4 || board_mfg_mode() == 5)
led_pwm1[1] = 0;
if (mipi->mode == DSI_VIDEO_MODE) {
mipi_dsi_cmds_tx(&himax_tx_buf, himax_cmd_backlight_cmds,
ARRAY_SIZE(himax_cmd_backlight_cmds));
} else {
mipi_dsi_op_mode_config(DSI_CMD_MODE);
mipi_dsi_cmds_tx(&himax_tx_buf, himax_cmd_backlight_cmds,
ARRAY_SIZE(himax_cmd_backlight_cmds));
}
bl_level_prevset = mfd->bl_level;
end:
mutex_unlock(&cmdlock);
return 0;
}
static void icm_force_leave(void)
{
struct msm_lcdc_panel_ops *panel_ops;
unsigned long irq_flags = 0;
panel_ops = panel_icm->lcdc->pdata->panel_ops;
mutex_lock(&panel_icm->icm_lock);
ICM_DBG("Force Leave ICM: icm_mode=%d icm_doable=%d \n", panel_icm->icm_mode, panel_icm->icm_doable);
if (panel_icm->icm_mode == true) {
clk_enable(panel_icm->lcdc->mdp_clk);
clk_enable(panel_icm->lcdc->pclk);
clk_enable(panel_icm->lcdc->pad_pclk);
mdp_writel(panel_icm->lcdc->mdp, 1, MDP_LCDC_EN);
panel_icm->clock_enabled = true;
if (panel_ops->refresh_disable)
panel_ops->refresh_disable(panel_ops);
panel_icm->icm_mode = false;
panel_icm->icm_doable = true;
PR_DISP_INFO("ForceLeaveICM: leave ICM MODE done !!!\n");
}
spin_lock_irqsave(&panel_icm->lock, irq_flags);
panel_icm->panel_update = 0;
spin_unlock_irqrestore(&panel_icm->lock, irq_flags);
mutex_unlock(&panel_icm->icm_lock);
}
static void himax_self_refresh_switch(int on)
{
PR_DISP_INFO("%s %d \n", __func__, on);
if (on) {
mutex_lock(&cmdlock);
mipi_set_tx_power_mode(0);
mipi_dsi_cmds_tx(&himax_tx_buf, video_to_cmd,
ARRAY_SIZE(video_to_cmd));
mipi_set_tx_power_mode(1);
disable_video_mode_clk();
mutex_unlock(&cmdlock);
} else {
mutex_lock(&cmdlock);
mipi_set_tx_power_mode(0);
enable_irq(vsync_irq);
mipi_dsi_cmds_tx(&himax_tx_buf, cmd_to_video,
ARRAY_SIZE(cmd_to_video));
wait_vsync = 1;
wait_event_timeout(himax_vsync_wait, himax_vsync_gpio ||
gpio_get_value(28), HZ/2);
disable_irq(vsync_irq);
wait_vsync = 0;
himax_vsync_gpio = 0;
udelay(100);
mipi_dsi_cmds_tx(&himax_tx_buf, vsync_hsync_cmds,
ARRAY_SIZE(vsync_hsync_cmds));
mutex_unlock(&cmdlock);
enable_video_mode_clk();
}
}
static unsigned char cp5_wl_shrink_pwm(int val)
{
unsigned int pwm_min, pwm_default, pwm_max;
unsigned char shrink_br = BRI_SETTING_MAX;
pwm_min = 11;
pwm_default = 79;
pwm_max = 255;
if (val <= 0) {
shrink_br = 0;
} else if (val > 0 && (val < BRI_SETTING_MIN)) {
shrink_br = pwm_min;
} else if ((val >= BRI_SETTING_MIN) && (val <= BRI_SETTING_DEF)) {
shrink_br = (val - BRI_SETTING_MIN) * (pwm_default - pwm_min) /
(BRI_SETTING_DEF - BRI_SETTING_MIN) + pwm_min;
} else if (val > BRI_SETTING_DEF && val <= BRI_SETTING_MAX) {
shrink_br = (val - BRI_SETTING_DEF) * (pwm_max - pwm_default) /
(BRI_SETTING_MAX - BRI_SETTING_DEF) + pwm_default;
} else if (val > BRI_SETTING_MAX)
shrink_br = pwm_max;
PR_DISP_INFO("brightness orig=%d, transformed=%d\n", val, shrink_br);
return shrink_br;
}
void htc_8974_panel_reset(struct mdss_panel_data *pdata, int enable)
{
struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return;
}
ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
if (!gpio_is_valid(ctrl_pdata->disp_en_gpio)) {
pr_debug("%s:%d, reset line not configured\n",
__func__, __LINE__);
}
if (!gpio_is_valid(ctrl_pdata->rst_gpio)) {
pr_debug("%s:%d, reset line not configured\n",
__func__, __LINE__);
return;
}
pr_debug("%s: enable = %d\n", __func__, enable);
if (enable) {
if (pdata->panel_info.first_power_on == 1) {
PR_DISP_INFO("reset already on in first time\n");
return;
}
if (pdata->panel_info.panel_id == 1) {
gpio_set_value((ctrl_pdata->rst_gpio), 1);
msleep(10);
gpio_set_value((ctrl_pdata->rst_gpio), 0);
msleep(10);
gpio_set_value((ctrl_pdata->rst_gpio), 1);
msleep(10);
} else {
gpio_set_value((ctrl_pdata->rst_gpio), 0);
msleep(10);
gpio_set_value((ctrl_pdata->rst_gpio), 1);
msleep(10);
}
if (gpio_is_valid(ctrl_pdata->disp_en_gpio))
gpio_set_value((ctrl_pdata->disp_en_gpio), 1);
if (ctrl_pdata->ctrl_state & CTRL_STATE_PANEL_INIT) {
pr_debug("%s: Panel Not properly turned OFF\n",
__func__);
ctrl_pdata->ctrl_state &= ~CTRL_STATE_PANEL_INIT;
pr_debug("%s: Reset panel done\n", __func__);
}
} else {
gpio_set_value((ctrl_pdata->rst_gpio), 0);
if (gpio_is_valid(ctrl_pdata->disp_en_gpio))
gpio_set_value((ctrl_pdata->disp_en_gpio), 0);
}
}
