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