static int ville_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 (mipi->mode == DSI_VIDEO_MODE) {
PR_DISP_ERR("%s: not support DSI_VIDEO_MODE!(%d)\n", __func__, mipi->mode);
} else {
if (!mipi_lcd_on) {
mipi_dsi_cmd_bta_sw_trigger();
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG) {
printk(KERN_INFO "ville_lcd_on PANEL_ID_VILLE_SAMSUNG_SG\n");
cmdreq.cmds = samsung_cmd_on_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(samsung_cmd_on_cmds);
} else if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2) {
printk(KERN_INFO "ville_lcd_on PANEL_ID_VILLE_SAMSUNG_SG_C2\n");
cmdreq.cmds = samsung_cmd_on_cmds_c2;
cmdreq.cmds_cnt = ARRAY_SIZE(samsung_cmd_on_cmds_c2);
} else if (panel_type == PANEL_ID_VILLE_AUO) {
printk(KERN_INFO "ville_lcd_on PANEL_ID_VILLE_AUO\n");
cmdreq.cmds = auo_cmd_on_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(auo_cmd_on_cmds);
} else {
PR_DISP_ERR("%s: un-supported panel_type(%d)!\n", __func__, panel_type);
cmdreq.cmds = samsung_cmd_on_cmds;
cmdreq.cmds_cnt = ARRAY_SIZE(samsung_cmd_on_cmds);
}
cmdreq.flags = CMD_REQ_COMMIT;
if (mfd && mfd->panel_info.type == MIPI_CMD_PANEL)
cmdreq.flags |= CMD_CLK_CTRL;
cmdreq.rlen = 0;
cmdreq.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq);
}
mipi_dsi_cmd_bta_sw_trigger();
mipi_samsung_manufacture_id(mfd);
}
mipi_lcd_on = 1;
return 0;
}
static int ville_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 (mipi->mode == DSI_VIDEO_MODE) {
/*
//-mipi_dsi_cmds_tx(mfd, &ville_panel_tx_buf, novatek_video_on_cmds,
//- ARRAY_SIZE(novatek_video_on_cmds));
*/
PR_DISP_ERR("%s: not support DSI_VIDEO_MODE!(%d)\n", __func__, mipi->mode);
} else {
if (!mipi_lcd_on) {
mipi_dsi_cmd_bta_sw_trigger(); /* clean up ack_err_status */
if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG) {
printk(KERN_INFO "ville_lcd_on PANEL_ID_VILLE_SAMSUNG_SG\n");
mipi_dsi_cmds_tx(mfd, &ville_panel_tx_buf, samsung_cmd_on_cmds,
ARRAY_SIZE(samsung_cmd_on_cmds));
} else if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2) {
printk(KERN_INFO "ville_lcd_on PANEL_ID_VILLE_SAMSUNG_SG_C2\n");
mipi_dsi_cmds_tx(mfd, &ville_panel_tx_buf, samsung_cmd_on_cmds_c2,
ARRAY_SIZE(samsung_cmd_on_cmds));
} else if (panel_type == PANEL_ID_VILLE_AUO) {
printk(KERN_INFO "ville_lcd_on PANEL_ID_VILLE_AUO\n");
mipi_dsi_cmds_tx(mfd, &ville_panel_tx_buf, auo_cmd_on_cmds,
ARRAY_SIZE(auo_cmd_on_cmds));
} else {
PR_DISP_ERR("%s: panel_type is not supported!(%d)\n", __func__, panel_type);
mipi_dsi_cmds_tx(mfd, &ville_panel_tx_buf, samsung_cmd_on_cmds,
ARRAY_SIZE(samsung_cmd_on_cmds));
}
}
mipi_dsi_cmd_bta_sw_trigger(); /* clean up ack_err_status */
mipi_samsung_manufacture_id(mfd);
}
mipi_lcd_on = 1;
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;
}
int mdp_fb_mirror(struct mdp_device *mdp_dev,
struct fb_info *src_fb, struct fb_info *dst_fb,
struct mdp_blit_req *req)
{
int ret;
struct mdp_info *mdp = container_of(mdp_dev, struct mdp_info, mdp_dev);
if (!src_fb || !dst_fb)
return -EINVAL;
mdp->enable_irq(mdp, DL0_ROI_DONE);
ret = process_blit(mdp, req, (struct file *)-1, src_fb->fix.smem_start,
src_fb->fix.smem_len, (struct file *)-1,
dst_fb->fix.smem_start, dst_fb->fix.smem_len);
if (ret)
goto err_bad_blit;
ret = mdp_ppp_wait(mdp);
if (ret) {
PR_DISP_ERR("mdp_ppp_wait error\n");
goto err_wait_failed;
}
return 0;
err_bad_blit:
mdp->disable_irq(mdp, DL0_ROI_DONE);
err_wait_failed:
return ret;
}
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);
}
/*
* mipi dsi dcs short write with 1 parameters
*/
static int mipi_dsi_dcs_swrite1(struct dsi_buf *dp, struct dsi_cmd_desc *cm)
{
uint32 *hp;
if (cm->dlen < 2 || cm->payload == 0) {
PR_DISP_ERR("%s: NO payload error\n", __func__);
return -EINVAL;
}
mipi_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);
hp = dp->hdr;
*hp = 0;
*hp |= DSI_HDR_VC(cm->vc);
if (cm->ack) /* ask ACK trigger msg from peripeheral */
*hp |= DSI_HDR_BTA;
if (cm->last)
*hp |= DSI_HDR_LAST;
*hp |= DSI_HDR_DTYPE(DTYPE_DCS_WRITE1);
*hp |= DSI_HDR_DATA1(cm->payload[0]); /* dcs comamnd byte */
*hp |= DSI_HDR_DATA2(cm->payload[1]); /* parameter */
mipi_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);
return dp->len;
}
static int icm_init(struct mdp_lcdc_info *lcdc)
{
int ret = 0;
/* init panel_icm_info */
panel_icm = kzalloc(sizeof(struct panel_icm_info), GFP_KERNEL);
if (!panel_icm)
return -ENOMEM;
panel_icm->icm_doable = 1;
panel_icm->clock_enabled = true;
panel_icm->lcdc = lcdc;
panel_icm->force_leave = icm_force_leave;
panel_icm->icm_suspend = false;
mutex_init(&panel_icm->icm_lock);
th_display = kthread_run(icm_thread, lcdc, "panel-enterIdle");
if (IS_ERR(th_display)) {
ret = PTR_ERR(th_display);
PR_DISP_ERR("%s: panel_icm_thread create fail:%d!!!\n", __func__, ret);
goto error_create_thread;
}
return ret;
error_create_thread:
kfree(panel_icm);
return ret;
}
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 int
cabc_bl_handle(struct platform_device *pdev, int brightness)
{
struct cabc *cabc = platform_get_drvdata(pdev);
struct led_classdev *lcd_cdev;
if (unlikely(cabc == NULL)) {
PR_DISP_ERR("%s: do not have cabc data\n", __func__);
return -ENOENT;
}
PR_DISP_DEBUG("turn %s backlight.\n",
brightness == LED_FULL ? "on" : "off");
lcd_cdev = &cabc->lcd_backlight;
wake_lock(&cabc->wakelock);
if (brightness != LED_FULL) {
/* enter screen off */
} else {
__set_brightness(cabc, (g_brightness >= 0 && g_brightness <= LED_FULL)?
g_brightness : LED_FULL, 0);
}
wake_unlock(&cabc->wakelock);
return 0;
}
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 mipi_cmd_samsung_blue_qhd_pt_init(void)
{
int ret;
#if defined (CONFIG_FB_MSM_MDP_ABL)
pinfo.panel_char = smd_gamma_tbl;
#endif
pinfo.xres = 540;
pinfo.yres = 960;
pinfo.type = MIPI_CMD_PANEL;
pinfo.pdest = DISPLAY_1;
pinfo.wait_cycle = 0;
pinfo.bpp = 24;
pinfo.lcdc.h_back_porch = 64;
pinfo.lcdc.h_front_porch = 96;
pinfo.lcdc.h_pulse_width = 32;
pinfo.lcdc.v_back_porch = 16;
pinfo.lcdc.v_front_porch = 16;
pinfo.lcdc.v_pulse_width = 4;
pinfo.lcd.v_back_porch = 16;
pinfo.lcd.v_front_porch = 16;
pinfo.lcd.v_pulse_width = 4;
pinfo.lcdc.border_clr = 0; /* blk */
pinfo.lcdc.underflow_clr = 0xff; /* blue */
pinfo.lcdc.hsync_skew = 0;
pinfo.bl_max = 255;
pinfo.bl_min = 1;
pinfo.fb_num = 2;
pinfo.clk_rate = 482000000;
pinfo.lcd.vsync_enable = TRUE;
pinfo.lcd.hw_vsync_mode = TRUE;
pinfo.lcd.refx100 = 6096; /* adjust refx100 to prevent tearing */
pinfo.mipi.mode = DSI_CMD_MODE;
pinfo.mipi.dst_format = DSI_CMD_DST_FORMAT_RGB888;
pinfo.mipi.vc = 0;
pinfo.mipi.rgb_swap = DSI_RGB_SWAP_RGB;
pinfo.mipi.data_lane0 = TRUE;
pinfo.mipi.data_lane1 = TRUE;
pinfo.mipi.t_clk_post = 0x0a;
pinfo.mipi.t_clk_pre = 0x20;
pinfo.mipi.stream = 0; /* dma_p */
pinfo.mipi.mdp_trigger = DSI_CMD_TRIGGER_NONE;
pinfo.mipi.dma_trigger = DSI_CMD_TRIGGER_SW;
pinfo.mipi.te_sel = 1; /* TE from vsycn gpio */
pinfo.mipi.interleave_max = 1;
pinfo.mipi.insert_dcs_cmd = TRUE;
pinfo.mipi.wr_mem_continue = 0x3c;
pinfo.mipi.wr_mem_start = 0x2c;
pinfo.mipi.dsi_phy_db = &dsi_cmd_mode_phy_db;
pinfo.mipi.esc_byte_ratio = 4;
ret = mipi_samsung_device_register(&pinfo, MIPI_DSI_PRIM,
MIPI_DSI_PANEL_WVGA_PT);
if (ret)
PR_DISP_ERR("%s: failed to register device!\n", __func__);
return ret;
}
static int mipi_dsi_dcs_read(struct dsi_buf *dp, struct dsi_cmd_desc *cm)
{
uint32 *hp;
if (cm->payload == 0) {
PR_DISP_ERR("%s: NO payload error\n", __func__);
return -EINVAL;
}
mipi_dsi_buf_reserve_hdr(dp, DSI_HOST_HDR_SIZE);
hp = dp->hdr;
*hp = 0;
*hp |= DSI_HDR_VC(cm->vc);
*hp |= DSI_HDR_BTA;
*hp |= DSI_HDR_DTYPE(DTYPE_DCS_READ);
if (cm->last)
*hp |= DSI_HDR_LAST;
*hp |= DSI_HDR_DATA1(cm->payload[0]); /* dcs command byte */
*hp |= DSI_HDR_DATA2(0);
mipi_dsi_buf_push(dp, DSI_HOST_HDR_SIZE);
return dp->len; /* 4 bytes */
}
static int htc_hiaaero_regulator_init(struct platform_device *pdev)
{
int ret = 0;
struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
struct dsi_power_data *pwrdata = NULL;
PR_DISP_INFO("%s\n", __func__);
if (!pdev) {
PR_DISP_ERR("%s: invalid input\n", __func__);
return -EINVAL;
}
ctrl_pdata = platform_get_drvdata(pdev);
if (!ctrl_pdata) {
PR_DISP_ERR("%s: invalid driver data\n", __func__);
return -EINVAL;
}
pwrdata = devm_kzalloc(&pdev->dev,
sizeof(struct dsi_power_data), GFP_KERNEL);
if (!pwrdata) {
PR_DISP_ERR("%s: FAILED to alloc pwrdata\n", __func__);
return -ENOMEM;
}
ctrl_pdata->dsi_pwrctrl_data = pwrdata;
pwrdata->vci = devm_regulator_get(&pdev->dev, "vdd");
if (IS_ERR(pwrdata->vci)) {
PR_DISP_ERR("%s: could not get vdda vreg, rc=%ld\n",
__func__, PTR_ERR(pwrdata->vci));
return PTR_ERR(pwrdata->vci);
}
ret = regulator_set_voltage(pwrdata->vci, 3000000, 3000000);
if (ret) {
PR_DISP_ERR("%s: set voltage failed on vdda vreg, rc=%d\n",
__func__, ret);
return ret;
}
pwrdata->vdd1v8 = of_get_named_gpio(pdev->dev.of_node,
"htc,vdd1v8-gpio", 0);
return 0;
}
static int himax_cabc_probe(struct platform_device *pdev)
{
int i, err;
struct cabc *cabc;
struct cabc_config *data;
B(KERN_DEBUG "%s\n", __func__);
cabc = kzalloc(sizeof(struct cabc), GFP_KERNEL);
if (!cabc)
return -ENOMEM;
platform_set_drvdata(pdev, cabc);
data = pdev->dev.platform_data;
if (data == NULL || !data->client) {
PR_DISP_ERR("No CABC config data\n");
err = -EINVAL;
goto err_client;
}
g_brightness = LED_FULL;
cabc->cabc_config = data;
cabc->cabc_config->bl_handle = cabc_bl_handle;
if (!cabc->cabc_config->change_cabcmode)
cabc->cabc_config->change_cabcmode = himax_change_cabcmode;
INIT_WORK(&cabc->lcd_changed_work, cabc_lcd_work);
INIT_WORK(&cabc->set_auto_work, cabc_auto_work);
mutex_init(&cabc->lock);
mutex_init(&cabc->data_lock);
cabc->cabc_queue = create_singlethread_workqueue("cabc_work_q");
wake_lock_init(&cabc->wakelock, WAKE_LOCK_IDLE, "cabc_present");
cabc->lcd_backlight.name = "lcd-backlight";
cabc->lcd_backlight.brightness_set = himax_set_brightness;
cabc->lcd_backlight.brightness_get = himax_get_brightness;
cabc->lcd_backlight.brightness = LED_FULL;
err = led_classdev_register(&pdev->dev, &cabc->lcd_backlight);
if (err)
goto err_register_lcd_bl;
for (i = 0; i < ARRAY_SIZE(cabc_attrs); i++) {
err = device_create_file(cabc->lcd_backlight.dev,
&cabc_attrs[i]);
if (err)
goto err_out;
}
return 0;
err_out:
while (i--)
device_remove_file(&pdev->dev, &cabc_attrs[i]);
err_register_lcd_bl:
led_classdev_unregister(&cabc->lcd_backlight);
err_client:
kfree(cabc);
return err;
}
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;
}
int mdp_ppp_blit(struct mdp_info *mdp, struct fb_info *fb,
struct mdp_blit_req *req)
{
int ret;
unsigned long src_start = 0, src_len = 0, dst_start = 0, dst_len = 0;
struct file *src_file = 0, *dst_file = 0;
ret = mdp_ppp_validate_blit(mdp, req);
if (ret)
return ret;
/* do this first so that if this fails, the caller can always
* safely call put_img */
if (unlikely(get_img(&req->src, fb, &src_start, &src_len, &src_file))) {
PR_DISP_ERR("mdp_ppp: could not retrieve src image from "
"memory\n");
return -EINVAL;
}
if (unlikely(get_img(&req->dst, fb, &dst_start, &dst_len, &dst_file))) {
PR_DISP_ERR("mdp_ppp: could not retrieve dst image from "
"memory\n");
put_img(src_file);
return -EINVAL;
}
if (unlikely(req->src.format > ARRAY_SIZE(src_img_cfg) ||
req->dst.format > ARRAY_SIZE(dst_img_cfg))) {
return -EINVAL;
}
mutex_lock(&mdp_mutex);
/* transp_masking unimplemented */
req->transp_mask = MDP_TRANSP_NOP;
mdp->req = req;
ret = mdp_ppp_do_blit(mdp, req, src_file, src_start, src_len,
dst_file, dst_start, dst_len);
put_img(src_file);
put_img(dst_file);
mutex_unlock(&mdp_mutex);
return ret;
}
static void lcdc_wait_vsync(struct msm_panel_data *panel)
{
struct mdp_lcdc_info *lcdc = panel_to_lcdc(panel);
int ret;
ret = wait_event_timeout(lcdc->vsync_waitq, lcdc->got_vsync, HZ / 2);
if (!ret && !lcdc->got_vsync)
PR_DISP_ERR("%s: timeout waiting for VSYNC\n", __func__);
lcdc->got_vsync = 0;
}
void mipi_dsi_timeout_status(void)
{
uint32 status;
status = MIPI_INP(MIPI_DSI_BASE + 0x00bc);/* DSI_TIMEOUT_STATUS */
if (status & 0x0111) {
MIPI_OUTP(MIPI_DSI_BASE + 0x00bc, status);
PR_DISP_ERR("%s: status=%x\n", __func__, status);
}
}
void mipi_dsi_error(void)
{
PR_DISP_ERR("%s\n", __func__);
/* DSI_ERR_INT_MASK0 */
mipi_dsi_ack_err_status(); /* mask0, 0x01f */
mipi_dsi_timeout_status(); /* mask0, 0x0e0 */
mipi_dsi_fifo_status(); /* mask0, 0x133d00 */
mipi_dsi_status(); /* mask0, 0xc0100 */
mipi_dsi_dln0_phy_err(); /* mask0, 0x3e00000 */
}
int mipi_dsi_buf_alloc(struct dsi_buf *dp, int size)
{
dp->start = kmalloc(size, GFP_KERNEL);
if (dp->start == NULL) {
PR_DISP_ERR("%s:%u\n", __func__, __LINE__);
return -ENOMEM;
}
dp->end = dp->start + size;
dp->size = size;
if ((int)dp->start & 0x07)
PR_DISP_ERR("%s: buf NOT 8 bytes aligned\n", __func__);
dp->data = dp->start;
dp->len = 0;
return size;
}
void mipi_dsi_ack_err_status(void)
{
uint32 status;
status = MIPI_INP(MIPI_DSI_BASE + 0x0064);/* DSI_ACK_ERR_STATUS */
if (status) {
MIPI_OUTP(MIPI_DSI_BASE + 0x0064, status);
PR_DISP_ERR("%s: status=%x\n", __func__, status);
}
}
void mipi_dsi_dln0_phy_err(void)
{
uint32 status;
status = MIPI_INP(MIPI_DSI_BASE + 0x00b0);/* DSI_DLN0_PHY_ERR */
if (status & 0x011111) {
MIPI_OUTP(MIPI_DSI_BASE + 0x00b0, status);
PR_DISP_ERR("%s: status=%x\n", __func__, status);
}
}
void mipi_dsi_status(void)
{
uint32 status;
status = MIPI_INP(MIPI_DSI_BASE + 0x0004);/* DSI_STATUS */
if (status & 0x80000000) {
MIPI_OUTP(MIPI_DSI_BASE + 0x0004, status);
PR_DISP_ERR("%s: status=%x\n", __func__, status);
}
}
void mipi_dsi_fifo_status(void)
{
uint32 status;
status = MIPI_INP(MIPI_DSI_BASE + 0x0008);/* DSI_FIFO_STATUS */
if (status & 0x44444489) {
MIPI_OUTP(MIPI_DSI_BASE + 0x0008, status);
PR_DISP_ERR("%s: status=%x\n", __func__, status);
}
}
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;
}
int mipi_sony_device_register(struct msm_panel_info *pinfo,
u32 channel, u32 panel)
{
struct platform_device *pdev = NULL;
int ret;
if ((channel >= 3) || ch_used[channel])
return -ENODEV;
ch_used[channel] = TRUE;
pdev = platform_device_alloc("mipi_sony", (panel << 8)|channel);
if (!pdev)
return -ENOMEM;
sony_panel_data.panel_info = *pinfo;
ret = platform_device_add_data(pdev, &sony_panel_data,
sizeof(sony_panel_data));
if (ret) {
PR_DISP_ERR("%s: platform_device_add_data failed!\n",
__func__);
goto err_device_put;
}
ret = platform_device_add(pdev);
if (ret) {
PR_DISP_ERR("%s: platform_device_register failed!\n",
__func__);
goto err_device_put;
}
return 0;
err_device_put:
platform_device_put(pdev);
return ret;
}
int mdp_ppp_blit_and_wait(struct mdp_info *mdp, struct mdp_blit_req *req,
struct file *src_file, unsigned long src_start, unsigned long src_len,
struct file *dst_file, unsigned long dst_start, unsigned long dst_len)
{
int ret;
mdp->enable_irq(mdp, DL0_ROI_DONE);
ret = process_blit(mdp, req, src_file, src_start, src_len,
dst_file, dst_start, dst_len);
if (unlikely(ret)) {
mdp->disable_irq(mdp, DL0_ROI_DONE);
return ret;
}
ret = mdp_ppp_wait(mdp);
if (unlikely(ret)) {
PR_DISP_ERR("%s: failed!\n", __func__);
PR_DISP_ERR("original request:\n");
dump_req(mdp->req, src_start, src_len, dst_start, dst_len);
PR_DISP_ERR("dead request:\n");
dump_req(req, src_start, src_len, dst_start, dst_len);
BUG();
return ret;
}
return 0;
}
static int mipi_villec2_device_register(const char* dev_name, struct msm_panel_info *pinfo,
u32 channel, u32 panel)
{
struct platform_device *pdev = NULL;
static int ch_used[3] = {0, 0, 0};
int ret;
if ((channel >= 3) || ch_used[channel])
return -ENODEV;
ch_used[channel] = TRUE;
pdev = platform_device_alloc(dev_name, (panel << 8)|channel);
if (!pdev)
return -ENOMEM;
villec2_panel_data.panel_info = *pinfo;
ret = platform_device_add_data(pdev, &villec2_panel_data,
sizeof(villec2_panel_data));
if (ret) {
PR_DISP_ERR("%s: platform_device_add_data failed!\n", __func__);
goto err_device_put;
}
ret = platform_device_add(pdev);
if (ret) {
PR_DISP_ERR("%s: platform_device_register failed!\n", __func__);
goto err_device_put;
}
return 0;
err_device_put:
platform_device_put(pdev);
return ret;
}
static inline void samsung_clear_vsync(void)
{
unsigned val;
int retry = 1000;
while (retry--) {
writel((1U << (97 - 95)), VSYNC_CLEAR);
wmb();
val = readl(VSYNC_STATUS);
if (!!(val & 0x04) == 0)
break;
}
if (retry == 0)
PR_DISP_ERR("%s: clear vsync failed!\n", __func__);
}
static ssize_t
himax_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
int rc;
unsigned long res;
const ptrdiff_t off = attr - cabc_attrs;
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct cabc *cabc = to_cabc(led_cdev, lcd_backlight);
struct msm_mddi_client_data *client_data = cabc_get_client(cabc);
rc = strict_strtoul(buf, 10, &res);
if (rc) {
PR_DISP_ERR("invalid parameter, %s %d\n", buf, rc);
count = -EINVAL;
goto err_out;
}
mutex_lock(&cabc->lock);
switch (off) {
case CABC_MODE:
if (res < CABC_UNDEF) {
cabc->mode_cabc = res;
cabc->cabc_config->change_cabcmode(client_data, res, 0x25);
}
break;
case BC_MODE:
if (res < BC_UNDEF)
cabc->mode_bc = res;
break;
case AUTO_BACKLIGHT:
if (himax_auto_backlight(cabc, !!res))
count = -EIO;
break;
default:
count = -EINVAL;
break;
}
mutex_unlock(&cabc->lock);
err_out:
return count;
}
