Ejemplo n.º 1
0
static int mipi_nt35510_lcd_init(void)
{
	DPRINT("start %s\n", __func__);

	lcd_reset = (board_hw_revision >= 2) ? 23 : 22;

	DPRINT("%s : LCD reset %d\n", __func__, lcd_reset);

	mipi_dsi_buf_alloc(&nt35510_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&nt35510_rx_buf, DSI_BUF_SIZE);

	return platform_driver_register(&this_driver);
}
Ejemplo n.º 2
0
static int __init mipi_samsung_oled_hd_init(void)
{
    ENTER_FUNC2();

    samsung_oled_hd_state.disp_powered_up = true;

    mipi_dsi_buf_alloc(&samsung_oled_hd_tx_buf, DSI_BUF_SIZE);
    mipi_dsi_buf_alloc(&samsung_oled_hd_rx_buf, DSI_BUF_SIZE);

    EXIT_FUNC2();

    return platform_driver_register(&this_driver);
}
static int __init mipi_himax_lcd_init(void)
{
    ENTER_FUNC2();

    himax_state.disp_powered_up = true;

    mipi_dsi_buf_alloc(&himax_tx_buf, DSI_BUF_SIZE);
    mipi_dsi_buf_alloc(&himax_rx_buf, DSI_BUF_SIZE);

    EXIT_FUNC2();

    return platform_driver_register(&this_driver);
}
Ejemplo n.º 4
0
void mipi_dsi_init(void)
{
	init_completion(&dsi_dma_comp);
	init_completion(&dsi_mdp_comp);
	mipi_dsi_buf_alloc(&dsi_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&dsi_rx_buf, DSI_BUF_SIZE);
	spin_lock_init(&dsi_irq_lock);
	spin_lock_init(&dsi_mdp_lock);
	spin_lock_init(&dsi_clk_lock);
	mutex_init(&cmd_mutex);

	INIT_LIST_HEAD(&pre_kickoff_list);
	INIT_LIST_HEAD(&post_kickoff_list);
}
Ejemplo n.º 5
0
static int __init monarudo_panel_init(void)
{
	int ret;

	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(&monarudo_panel_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&monarudo_panel_rx_buf, DSI_BUF_SIZE);

	return platform_driver_register(&this_driver);
}
static int __init mipi_dummy_lcd_init(void)
{
	mipi_dsi_buf_alloc(&dummy_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&dummy_rx_buf, DSI_BUF_SIZE);

#if 0 //def CONFIG_FB_MSM_MIPI_PANEL_DETECT
        if (msm_fb_detect_client("mipi_video_dummy_wvga"))
                return platform_driver_register(&this_driver);
        return 0;
#else
        return platform_driver_register(&this_driver);
#endif

}
Ejemplo n.º 7
0
static int setup_reg_access(struct device *dev, struct dsi_buf *rx_buf,
			    struct dsi_buf *tx_buf, char **buf,
			    const char __user *ubuf, size_t count)
{
	int ret = 0;

	reset_res_buf();

	if (rx_buf) {
		ret = mipi_dsi_buf_alloc(rx_buf, DSI_BUF_SIZE);
		if (ret <= 0) {
			dev_err(dev, "mipi_dsi_buf_alloc(rx) failed!\n");
			ret = -ENOMEM;
			goto exit;
		}
	}

	if (tx_buf) {
		ret = mipi_dsi_buf_alloc(tx_buf, DSI_BUF_SIZE);
		if (ret <= 0) {
			dev_err(dev, "mipi_dsi_buf_alloc(tx) failed!\n");
			ret = -ENOMEM;
			goto fail_free_rx;
		}
	}

	*buf = kzalloc(sizeof(char) * count, GFP_KERNEL);
	if (!*buf) {
		dev_err(dev, "%s: Failed to allocate buffer\n", __func__);
		ret = -ENOMEM;
		goto fail_free_all;
	}

	if (copy_from_user(*buf, ubuf, count)) {
		ret = -EFAULT;
                kfree(*buf);
		goto fail_free_all;
	}
	return 0;

fail_free_all:
	if (tx_buf)
		mipi_dsi_buf_release(tx_buf);
fail_free_rx:
	if (rx_buf)
		mipi_dsi_buf_release(rx_buf);
exit:
	return ret;
}
Ejemplo n.º 8
0
static int __init mipi_oscar_lcd_init(void)
{
    ENTER_FUNC2();

    oscar_state.disp_powered_up = true;
	id_read_flag = false;

    mipi_dsi_buf_alloc(&oscar_tx_buf, DSI_BUF_SIZE);
    mipi_dsi_buf_alloc(&oscar_rx_buf, DSI_BUF_SIZE);

    EXIT_FUNC2();

    return platform_driver_register(&this_driver);

}
static int __init mipi_ili9486_lcd_init(void)
{

	mipi_dsi_buf_alloc(&ili9486_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&ili9486_rx_buf, DSI_BUF_SIZE);      

	gpio_tlmm_config(GPIO_CFG(35, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA),
					GPIO_CFG_ENABLE);
      
	LCM_ID = gpio_get_value(35);

	pr_emerg("Tracy:LCM_ID %d \n",LCM_ID);	

	return platform_driver_register(&this_driver);
}
static int __init mipi_orise_lcd_init(void)
{
	mipi_dsi_buf_alloc(&orise_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&orise_rx_buf, DSI_BUF_SIZE);

	printk("huyu----%s: --\n", __func__);
	if(get_pcb_version() < 20 )
	{
		printk("huyu----%s: lcd is 720p!--\n", __func__);
		return platform_driver_register(&this_driver);

	}

	return 0;

}
static int __init villec2_panel_late_init(void)
{
	mipi_dsi_buf_alloc(&panel_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&panel_rx_buf, DSI_BUF_SIZE);

	if(panel_type == PANEL_ID_NONE) {
		PR_DISP_INFO("%s panel ID = PANEL_ID_NONE\n", __func__);
		return 0;
	}

	if (panel_type == PANEL_ID_VILLE_SAMSUNG_SG_C2) {
		mipi_cmd_samsung_blue_qhd_pt_init();
	}

	return platform_driver_register(&this_driver);
}
void mipi_dsi_init(void)
{
    init_completion(&dsi_dma_comp);
    mutex_init(&dsi_mutex);
    mipi_dsi_buf_alloc(&dsi_tx_buf, DSI_BUF_SIZE);
    spin_lock_init(&dsi_lock);
}
static int __init mipi_cmd_nt35560_fwvga_init(void)
{
	int ret = 0;
	struct msm_panel_info *pinfo = NULL;

	lcd_panel_hvga = get_lcd_panel_type();
	if(MIPI_CMD_NT35560_TOSHIBA_FWVGA != lcd_panel_hvga) 
	{
		return 0;
	}
	pr_info("enter mipi_cmd_nt35560_fwvga_init \n");
	mipi_dsi_buf_alloc(&nt35560_tx_buf, DSI_BUF_SIZE);

	ret = platform_driver_register(&this_driver);
	if (!ret)
	{
	 	pinfo = &nt35560_panel_data.panel_info;
		pinfo->xres = 480;
		pinfo->yres = 854;
		pinfo->type = MIPI_CMD_PANEL;
		pinfo->pdest = DISPLAY_1;
		pinfo->wait_cycle = 0;
		pinfo->bpp = 24;		
		pinfo->bl_max = 255;
		pinfo->bl_min = 30;
		pinfo->fb_num = 2;

		pinfo->clk_rate = 499000000;
		pinfo->lcd.refx100 = 6000; /* 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 = 0xB0;
		pinfo->mipi.t_clk_pre = 0x2f;
		pinfo->mipi.stream = 0; /* dma_p */
		pinfo->mipi.mdp_trigger = DSI_CMD_TRIGGER_SW;
		pinfo->mipi.dma_trigger = DSI_CMD_TRIGGER_SW;
		pinfo->mipi.te_sel = 1; /* TE from vsync 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.tx_eot_append = 0x01;
		pinfo->mipi.rx_eot_ignore = 0;
		pinfo->mipi.dlane_swap = 0x1;

		ret = platform_device_register(&this_device);
		if (ret)
			pr_err("%s: failed to register device!\n", __func__);
	}


	return ret;
}
Ejemplo n.º 14
0
void mipi_dsi_init(void)
{
	init_completion(&dsi_dma_comp);
	init_completion(&dsi_mdp_comp);
	mipi_dsi_buf_alloc(&dsi_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&dsi_rx_buf, DSI_BUF_SIZE);
	spin_lock_init(&dsi_irq_lock);
	spin_lock_init(&dsi_mdp_lock);
	spin_lock_init(&dsi_clk_lock);
	mutex_init(&cmd_mutex);

	INIT_LIST_HEAD(&pre_kickoff_list);
	INIT_LIST_HEAD(&post_kickoff_list);
#ifdef CONFIG_FIH_SW_TCXO_SD_DURING_DISPLAY_ON
	pm_qos_add_request(&pm_qos_req, PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE);
#endif
}
Ejemplo n.º 15
0
void mipi_dsi_init(void)
{
	init_completion(&dsi_dma_comp);
	init_completion(&dsi_mdp_comp);
	init_completion(&dsi_video_comp);
	mipi_dsi_buf_alloc(&dsi_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&dsi_rx_buf, DSI_BUF_SIZE);
	spin_lock_init(&dsi_irq_lock);
	spin_lock_init(&dsi_mdp_lock);
	spin_lock_init(&dsi_clk_lock);
	mutex_init(&cmd_mutex);
	mutex_init(&clk_mutex);
	INIT_WORK(&mdp_reset_work, mdp_reset_wq_handler);

	INIT_LIST_HEAD(&pre_kickoff_list);
	INIT_LIST_HEAD(&post_kickoff_list);
}
Ejemplo n.º 16
0
static int __devinit mipi_lead_lcd_probe(struct platform_device *pdev)
{	
	if (pdev->id == 0) return 0;
	
	mipi_dsi_buf_alloc(&lead_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&lead_rx_buf, DSI_BUF_SIZE);
	
#ifdef CONFIG_ZTE_PLATFORM	
	if((LcdPanleID = get_lcdpanleid_from_bootloader() )==(u32)LCD_PANEL_NOPANEL)
		printk("cann't get get_lcdpanelid from bootloader\n");
#endif	


	msm_fb_add_device(pdev);

	return 0;
}
Ejemplo n.º 17
0
static int mipi_chimei_lcd_init(void)
{

	led_trigger_register_simple("bkl_trigger", &bkl_led_trigger);
	pr_info("%s: SUCCESS (WLED TRIGGER)\n", __func__);
	wled_trigger_initialized = 1;

	mipi_dsi_buf_alloc(&chimei_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&chimei_rx_buf, DSI_BUF_SIZE);
	
	#if ESD
	INIT_DELAYED_WORK(&power_state_detect, power_state_detect_work);
	//INIT_WORK(&esd_work, check_state_work);
	#endif


	return platform_driver_register(&this_driver);
}
Ejemplo n.º 18
0
void mipi_dsi_init(void)
{
	init_completion(&dsi_dma_comp);
	mipi_dsi_buf_alloc(&dsi_tx_buf, DSI_BUF_SIZE);
	spin_lock_init(&dsi_lock);

	INIT_LIST_HEAD(&pre_kickoff_list);
	INIT_LIST_HEAD(&post_kickoff_list);
}
Ejemplo n.º 19
0
static int __init mipi_lg4573b_lcd_init(void)
{
	int bufsize=0;
	
	bufsize=mipi_dsi_buf_alloc(&lg4573b_tx_buf, DSI_BUF_SIZE);
	
	bufsize=mipi_dsi_buf_alloc(&lg4573b_rx_buf, DSI_BUF_SIZE);
	
#ifdef CONFIG_FB_MSM_MIPI_DSI_HX8379A
	if( maker_id == 0) //Tovis
		return 0;
	else{
#endif
		return platform_driver_register(&this_driver);
#ifdef CONFIG_FB_MSM_MIPI_DSI_HX8379A
		}
#endif
}
static int __init k2_init_panel(void)
{
	if(panel_type == PANEL_ID_NONE) {
		PR_DISP_INFO("%s panel ID = PANEL_ID_NONE\n", __func__);
		return 0;
	}

	led_trigger_register_simple("bkl_trigger", &bkl_led_trigger);
	pr_info("%s: SUCCESS (WLED TRIGGER)\n", __func__);
	wled_trigger_initialized = 1;
	atomic_set(&lcd_power_state, 1);

	mipi_dsi_buf_alloc(&k2_panel_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&k2_panel_rx_buf, DSI_BUF_SIZE);

	mipi_video_novatek_wvga_pt_init();

	return platform_driver_register(&this_driver);
}
Ejemplo n.º 21
0
static int __init zara_init_panel(void)
{
	if(panel_type == PANEL_ID_NONE) {
		PR_DISP_INFO("%s panel ID = PANEL_ID_NONE\n", __func__);
		return 0;
	}

	atomic_set(&lcd_power_state, 1);

	mipi_dsi_buf_alloc(&zara_panel_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&zara_panel_rx_buf, DSI_BUF_SIZE);

	if (panel_type == PANEL_ID_CANIS_LG_NOVATEK)
		mipi_cmd_lg_novatek_init();
	else if (panel_type == PANEL_ID_CANIS_JDI_NOVATEK)
		mipi_cmd_jdi_novatek_init();

	return platform_driver_register(&this_driver);
}
static int __init protou_panel_late_init(void)
{
	mipi_dsi_buf_alloc(&protou_panel_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&protou_panel_rx_buf, DSI_BUF_SIZE);

	PR_DISP_INFO("%s: enter 0x%x\n", __func__, panel_type);

	if (panel_type == PANEL_ID_PROTOU_LG) {
		mipi_video_lg_wvga_pt_init();
		PR_DISP_INFO("match PANEL_ID_PROTOU_LG panel_type\n");
	} else if (panel_type == PANEL_ID_PROTOU_SHARP || panel_type == PANEL_ID_PROTOU_SHARP_C1) {
		mipi_power_save_on = 0;
		mipi_video_orise_wvga_pt_init();
		PR_DISP_INFO("match PANEL_ID_PROTOU_SHARP panel_type\n");
	} else
		PR_DISP_INFO("Mis-match panel_type\n");

	return platform_driver_register(&this_driver);
}
Ejemplo n.º 23
0
void mipi_dsi_init(void)
{
	init_completion(&dsi_dma_comp);
	#ifdef CONFIG_HW_ESD_DETECT
	/*add qcom patch to solve esd issue*/
	init_completion(&dsi_bta_comp);
	#endif
	init_completion(&dsi_mdp_comp);
	mipi_dsi_buf_alloc(&dsi_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&dsi_rx_buf, DSI_BUF_SIZE);
	spin_lock_init(&dsi_irq_lock);
	spin_lock_init(&dsi_mdp_lock);
	spin_lock_init(&dsi_clk_lock);
	mutex_init(&cmd_mutex);
	mutex_init(&clk_mutex);

	INIT_LIST_HEAD(&pre_kickoff_list);
	INIT_LIST_HEAD(&post_kickoff_list);
}
static int __init cp5_wl_init_panel(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);

	atomic_set(&lcd_power_state, 1);

	mipi_dsi_buf_alloc(&cp5_wl_panel_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&cp5_wl_panel_rx_buf, DSI_BUF_SIZE);

	mipi_cmd_jdi_novatek_init_5inch();

	return platform_driver_register(&this_driver);
}
Ejemplo n.º 25
0
void mipi_dsi_init(void)
{
	init_completion(&dsi_dma_comp);
	init_completion(&dsi_mdp_comp);
	init_completion(&dsi_video_comp);
	mipi_dsi_buf_alloc(&dsi_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&dsi_rx_buf, DSI_BUF_SIZE);
	spin_lock_init(&dsi_irq_lock);
	spin_lock_init(&dsi_mdp_lock);
	spin_lock_init(&dsi_clk_lock);
	mutex_init(&cmd_mutex);
	mutex_init(&clk_mutex);

	INIT_LIST_HEAD(&pre_kickoff_list);
	INIT_LIST_HEAD(&post_kickoff_list);

#if defined(RUMTIME_MIPI_CLK_CHANGE)
	mutex_init(&fps_done_mutex);
	init_completion(&dsi_fps_comp);
#endif
}
Ejemplo n.º 26
0
static int __init mipi_orise_lcd_init(void)
{
	mipi_dsi_buf_alloc(&orise_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&orise_rx_buf, DSI_BUF_SIZE);
	return platform_driver_register(&this_driver);
}
Ejemplo n.º 27
0
static int __devinit mipi_nt35565_lcd_probe(struct platform_device *pdev)
{
	int ret;
	struct lcd_panel_platform_data *platform_data;
	struct mipi_dsi_data *dsi_data;
#ifdef CONFIG_FB_MSM_PANEL_ECO_MODE
	struct platform_device *fb_pdev;
#endif

	platform_data = pdev->dev.platform_data;
	if (platform_data == NULL)
		return -EINVAL;

	dsi_data = kzalloc(sizeof(struct mipi_dsi_data), GFP_KERNEL);
	if (dsi_data == NULL)
		return -ENOMEM;

	dsi_data->panel_data.on = mipi_nt35565_ic_on_lcd_off;
	dsi_data->panel_data.controller_on_panel_on
					= mipi_nt35565_ic_on_lcd_on;
	dsi_data->panel_data.off = mipi_nt35565_lcd_off;
	dsi_data->panel_data.power_on_panel_at_pan = 0;
	dsi_data->default_panels = platform_data->default_panels;
	dsi_data->panels = platform_data->panels;
	dsi_data->lcd_power = platform_data->lcd_power;
	dsi_data->lcd_reset = platform_data->lcd_reset;
	if (mipi_dsi_need_detect_panel(dsi_data->panels)) {
		dsi_data->panel_data.panel_detect = mipi_dsi_detect_panel;
		dsi_data->panel_data.update_panel = mipi_dsi_update_panel;
		dsi_data->panel_detecting = true;
	} else {
		dev_info(&pdev->dev, "no need to detect panel\n");
	}

	ret = mipi_dsi_buf_alloc(&dsi_data->tx_buf, DSI_BUF_SIZE);
	if (ret <= 0) {
		dev_err(&pdev->dev, "mipi_dsi_buf_alloc(tx) failed!\n");
		goto out_free;
	}

	ret = mipi_dsi_buf_alloc(&dsi_data->rx_buf, DSI_BUF_SIZE);
	if (ret <= 0) {
		dev_err(&pdev->dev, "mipi_dsi_buf_alloc(rx) failed!\n");
		goto out_rx_release;
	}

	platform_set_drvdata(pdev, dsi_data);

	mipi_dsi_set_default_panel(dsi_data);

	ret = platform_device_add_data(pdev, &dsi_data->panel_data,
		sizeof(dsi_data->panel_data));
	if (ret) {
		dev_err(&pdev->dev,
			"platform_device_add_data failed!\n");
		goto out_tx_release;
	}
#ifdef CONFIG_FB_MSM_PANEL_ECO_MODE
	fb_pdev = msm_fb_add_device(pdev);
	eco_mode_sysfs_register(&fb_pdev->dev);
#else
	msm_fb_add_device(pdev);
#endif

#ifdef CONFIG_DEBUG_FS
	mipi_dsi_debugfs_init(pdev, "mipi_nt35565");
#endif

	return 0;
out_tx_release:
	mipi_dsi_buf_release(&dsi_data->rx_buf);
out_rx_release:
	mipi_dsi_buf_release(&dsi_data->tx_buf);
out_free:
	kfree(dsi_data);
	return ret;
}
static int __devinit mipi_r63306_lcd_probe(struct platform_device *pdev)
{
	int ret;
	struct lcd_panel_platform_data *platform_data;
	struct mipi_dsi_data *dsi_data;
	struct platform_device *fb_pdev;

	platform_data = pdev->dev.platform_data;
	if (platform_data == NULL)
		return -EINVAL;

	dsi_data = kzalloc(sizeof(struct mipi_dsi_data), GFP_KERNEL);
	if (dsi_data == NULL)
		return -ENOMEM;
	dsi_data->panel_data.on = mipi_r63306_lcd_on;
	dsi_data->panel_data.off = mipi_r63306_lcd_off;
	dsi_data->default_panels = platform_data->default_panels;
	dsi_data->panels = platform_data->panels;
	dsi_data->lcd_power = platform_data->lcd_power;
	dsi_data->lcd_reset = platform_data->lcd_reset;
	dsi_data->eco_mode_switch = mipi_dsi_eco_mode_switch;
	if (mipi_dsi_need_detect_panel(dsi_data->panels)) {
		dsi_data->panel_data.panel_detect = mipi_dsi_detect_panel;
		dsi_data->panel_data.update_panel = mipi_dsi_update_panel;
		dsi_data->panel_detecting = true;
	} else {
		dev_info(&pdev->dev, "no need to detect panel\n");
	}
#ifdef CONFIG_FB_MSM_RECOVER_PANEL
	dsi_data->is_nvm_ok = mipi_r63303_is_nvm_ok;
	dsi_data->backup_nvm_to_ram = mipi_r63306_backup_nvm_to_ram;
	dsi_data->get_nvm_backup = mipi_r63303_get_nvm_backup;
	dsi_data->override_nvm_data = mipi_r63306_nvm_override_data;
	dsi_data->nvm_erase_all = mipi_r63306_nvm_erase_all;
	dsi_data->nvm_write_trim_area = mipi_r63306_nvm_write_trim_area;
	dsi_data->nvm_write_user_area = mipi_r63306_nvm_write_user_area;
	dsi_data->panel_nvm_ok = true;
	dsi_data->panel_nvm_backup_ok = false;
#endif
	ret = mipi_dsi_buf_alloc(&dsi_data->tx_buf, DSI_BUF_SIZE);
	if (ret <= 0) {
		dev_err(&pdev->dev, "mipi_dsi_buf_alloc(tx) failed!\n");
		goto err_dsibuf_free;
	}

	ret = mipi_dsi_buf_alloc(&dsi_data->rx_buf, DSI_BUF_SIZE);
	if (ret <= 0) {
		dev_err(&pdev->dev, "mipi_dsi_buf_alloc(rx) failed!\n");
		goto err_txbuf_free;
	}

	platform_set_drvdata(pdev, dsi_data);

	mipi_dsi_set_default_panel(dsi_data);

	ret = platform_device_add_data(pdev, &dsi_data->panel_data,
		sizeof(dsi_data->panel_data));
	if (ret) {
		dev_err(&pdev->dev,
			"platform_device_add_data failed!\n");
		goto err_rxbuf_free;
	}
	fb_pdev = msm_fb_add_device(pdev);
#ifdef CONFIG_FB_MSM_PANEL_ECO_MODE
	eco_mode_sysfs_register(&fb_pdev->dev);
#endif
#ifdef CONFIG_FB_MSM_RECOVER_PANEL
	create_sysfs_interfaces(&fb_pdev->dev);
#endif
#ifdef CONFIG_DEBUG_FS
	mipi_dsi_panel_create_debugfs(fb_pdev, "mipi_r63306");
#endif

	return 0;
err_rxbuf_free:
	mipi_dsi_buf_release(&dsi_data->rx_buf);
err_txbuf_free:
	mipi_dsi_buf_release(&dsi_data->tx_buf);
err_dsibuf_free:
	kfree(dsi_data);
	return ret;
}
static int __init mipi_cmd_nt35510_wvga_init(void)
{
	int ret = 0;
	struct msm_panel_info *pinfo = NULL;
	lcd_panel_wvga = get_lcd_panel_type();
	if (MIPI_CMD_NT35510_BOE_WVGA != lcd_panel_wvga
		&& MIPI_CMD_NT35510_CHIMEI_WVGA != lcd_panel_wvga)
	{
		return 0;
	}
    
    LCD_DEBUG("enter mipi_cmd_nt35510_wvga_init \n");

	mipi_dsi_buf_alloc(&nt35510_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&nt35510_rx_buf, DSI_BUF_SIZE);

	ret = platform_driver_register(&this_driver);
	if (!ret)
	{
		pinfo = &nt35510_panel_data.panel_info;
		pinfo->xres = 480;
		pinfo->yres = 800;
		pinfo->type = MIPI_CMD_PANEL;
		pinfo->pdest = DISPLAY_1;
		pinfo->wait_cycle = 0;
		pinfo->bpp = 24;		
		pinfo->bl_max = 255;
		pinfo->bl_min = 30;		
		pinfo->fb_num = 2;
        /* increase the DSI bit clock to 490 MHz */
		pinfo->clk_rate = 490000000;
		pinfo->lcd.refx100 = 6000; /* 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 = 0xB0;// min 60 + 128*UI
		pinfo->mipi.t_clk_pre = 0x2f;// min 8*UI
		pinfo->mipi.stream = 0; /* dma_p */
		pinfo->mipi.mdp_trigger = DSI_CMD_TRIGGER_SW;
		pinfo->mipi.dma_trigger = DSI_CMD_TRIGGER_SW;
		pinfo->lcd.hw_vsync_mode = TRUE;
		pinfo->lcd.vsync_enable = TRUE;
		pinfo->mipi.te_sel = 1; /* TE from vsync 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.tx_eot_append = 0x01;
		pinfo->mipi.rx_eot_ignore = 0;
		pinfo->mipi.dlane_swap = 0x1;

		ret = platform_device_register(&this_device);
		if (ret)
            LCD_DEBUG("%s: failed to register device!\n", __func__);
	}
    /*delete the printed infomation of no value*/
    
	return ret;
}
Ejemplo n.º 30
0
void disp_ext_blc_init(void)
{
	mipi_dsi_buf_alloc(&disp_ext_blc_tx_buf, DSI_BUF_SIZE);
	mipi_dsi_buf_alloc(&disp_ext_blc_rx_buf, DSI_BUF_SIZE);
}