static void cmi_disp_off(struct k3_fb_data_type *k3fd)
{
	u32 edc_base = 0;
	struct k3_panel_info *pinfo = NULL;

	BUG_ON(k3fd == NULL);
	edc_base = k3fd->edc_base;
	pinfo = &(k3fd->panel_info);

	/* lcd display off sequence */
	mipi_dsi_cmds_tx(cmi_display_off_cmds, \
		ARRAY_SIZE(cmi_display_off_cmds), edc_base);

	/* lcd gpio lowpower */
	gpio_cmds_tx(cmi_lcd_gpio_lowpower_cmds, \
		ARRAY_SIZE(cmi_lcd_gpio_lowpower_cmds));
	/* lcd gpio free */
	gpio_cmds_tx(cmi_lcd_gpio_free_cmds, \
		ARRAY_SIZE(cmi_lcd_gpio_free_cmds));

	/* lcd iomux lowpower */
	iomux_cmds_tx(cmi_lcd_iomux_lowpower_cmds, \
		ARRAY_SIZE(cmi_lcd_iomux_lowpower_cmds));

	/* lcd vcc disable */
	vcc_cmds_tx(NULL, cmi_lcd_vcc_disable_cmds, \
		ARRAY_SIZE(cmi_lcd_vcc_disable_cmds));
}
static int mipi_tianma_panel_off(struct platform_device *pdev)
{
	struct k3_fb_data_type *k3fd = NULL;
	struct k3_panel_info *pinfo = NULL;

	BUG_ON(pdev == NULL);
	k3fd = platform_get_drvdata(pdev);
	BUG_ON(k3fd == NULL);
	pinfo = &(k3fd->panel_info);
	BUG_ON(pinfo == NULL);

	K3_FB_DEBUG("fb%d, +.\n", k3fd->index);

	/* lcd display off sequence */
	rgb2mipi_cmds_tx(pinfo->spi_dev, tianma_display_off_cmds, \
		ARRAY_SIZE(tianma_display_off_cmds));

	/* lcd gpio lowpower */
	gpio_cmds_tx(tianma_lcd_gpio_lowpower_cmds, \
		ARRAY_SIZE(tianma_lcd_gpio_lowpower_cmds));
	/* lcd gpio free */
	gpio_cmds_tx(tianma_lcd_gpio_free_cmds, \
		ARRAY_SIZE(tianma_lcd_gpio_free_cmds));

	/* lcd vcc disable */
	vcc_cmds_tx(NULL, tianma_lcd_vcc_disable_cmds, \
		ARRAY_SIZE(tianma_lcd_vcc_disable_cmds));

	K3_FB_DEBUG("fb%d, -.\n", k3fd->index);

	return 0;
}
static int rgb2mipi_init(struct hisi_fb_data_type *hisifd)
{
    struct spi_device *spi_dev = NULL;

    BUG_ON(hisifd == NULL);
    spi_dev = hisifd->panel_info.spi_dev;
    BUG_ON(spi_dev == NULL);

    /* spi setup */
    spi_dev->mode = SPI_MODE_0;
    spi_setup(spi_dev);

    gpio_cmds_tx(rgb2mipi_gpio_request_cmds, \
                 ARRAY_SIZE(rgb2mipi_gpio_request_cmds));

    gpio_cmds_tx(rgb2mipi_gpio_normal_cmds, \
                 ARRAY_SIZE(rgb2mipi_gpio_normal_cmds));

    /* sending cmds via spi */
    rgb2mipi_spi_cmds_tx(spi_dev, software_reset_cmds,
                         ARRAY_SIZE(software_reset_cmds));
    rgb2mipi_spi_cmds_tx(spi_dev, spi_host_setting_cmds,
                         ARRAY_SIZE(spi_host_setting_cmds));
    rgb2mipi_spi_cmds_tx(spi_dev, pll_clock_setting_cmds,
                         ARRAY_SIZE(pll_clock_setting_cmds));
    rgb2mipi_spi_cmds_tx(spi_dev, picture_size_setting_cmds,
                         ARRAY_SIZE(picture_size_setting_cmds));
    rgb2mipi_spi_cmds_tx(spi_dev, dpi_input_setting_cmds,
                         ARRAY_SIZE(dpi_input_setting_cmds));
    rgb2mipi_spi_cmds_tx(spi_dev, dsi_param_setting_cmds,
                         ARRAY_SIZE(dsi_param_setting_cmds));

    return 0;
}
static int mipi_jdi_panel_set_fastboot(struct platform_device *pdev)
{
	struct k3_fb_data_type *k3fd = NULL;

	BUG_ON(pdev == NULL);

	k3fd = (struct k3_fb_data_type *)platform_get_drvdata(pdev);
	BUG_ON(k3fd == NULL);

	/* lcd vcc enable */
	vcc_cmds_tx(pdev, jdi_lcd_vcc_enable_cmds, \
		ARRAY_SIZE(jdi_lcd_vcc_enable_cmds));

	/* lcd iomux normal */
	iomux_cmds_tx(jdi_lcd_iomux_normal_cmds, \
		ARRAY_SIZE(jdi_lcd_iomux_normal_cmds));

	/* lcd gpio request */
	gpio_cmds_tx(jdi_lcd_gpio_request_cmds, \
		ARRAY_SIZE(jdi_lcd_gpio_request_cmds));

	g_display_on = true;

	return 0;
}
static void jdi_disp_off(struct k3_fb_data_type *k3fd)
{
	u32 edc_base = 0;
	struct k3_panel_info *pinfo = NULL;

	BUG_ON(k3fd == NULL);
	edc_base = k3fd->edc_base;
	pinfo = &(k3fd->panel_info);

	/* lcd display off sequence */
	mipi_dsi_cmds_tx(jdi_display_off_cmds,
		ARRAY_SIZE(jdi_display_off_cmds), edc_base);

	/* lcd gpio request */
	gpio_cmds_tx(jdi_lcd_gpio_lowpower_cmds, \
		ARRAY_SIZE(jdi_lcd_gpio_lowpower_cmds));
	/* lcd gpio free */
	gpio_cmds_tx(jdi_lcd_gpio_free_cmds, \
		ARRAY_SIZE(jdi_lcd_gpio_free_cmds));

	/* lcd iomux lowpower */
	iomux_cmds_tx(jdi_lcd_iomux_lowpower_cmds, \
		ARRAY_SIZE(jdi_lcd_iomux_lowpower_cmds));
	/* tp gpio request */
	printk("%s	enter:tp gpio request, free and iomux lowpower\n",__func__);
	gpio_cmds_tx(jdi_tp_gpio_lowpower_cmds, \
		ARRAY_SIZE(jdi_tp_gpio_lowpower_cmds));

	/* tp gpio free */
	gpio_cmds_tx(jdi_tp_gpio_free_cmds, \
		ARRAY_SIZE(jdi_tp_gpio_free_cmds));

	/* tp iomux lowpower */
	iomux_cmds_tx(jdi_tp_iomux_lowpower_cmds, \
		ARRAY_SIZE(jdi_tp_iomux_lowpower_cmds));
		
	/* lcd vcc disable */
	vcc_cmds_tx(NULL, jdi_lcd_vcc_disable_cmds, \
		ARRAY_SIZE(jdi_lcd_vcc_disable_cmds));

	/* tp vcc disable */
	vcc_cmds_tx(NULL, jdi_tp_vcc_disable_cmds, \
		ARRAY_SIZE(jdi_tp_vcc_disable_cmds));		
}
static int rgb2mipi_deinit(struct hisi_fb_data_type *hisifd)
{
    struct spi_device *spi_dev = NULL;

    BUG_ON(hisifd == NULL);
    spi_dev = hisifd->panel_info.spi_dev;
    BUG_ON(spi_dev == NULL);

    rgb2mipi_spi_cmds_tx(spi_dev, display_stop_cmds,
                         ARRAY_SIZE(display_stop_cmds));

    gpio_cmds_tx(rgb2mipi_gpio_lowpower_cmds, \
                 ARRAY_SIZE(rgb2mipi_gpio_lowpower_cmds));

    gpio_cmds_tx(rgb2mipi_gpio_free_cmds, \
                 ARRAY_SIZE(rgb2mipi_gpio_free_cmds));

    return 0;
}
static int mipi_tianma_panel_on(struct platform_device *pdev)
{
	struct k3_fb_data_type *k3fd = NULL;
	struct k3_panel_info *pinfo = NULL;

	BUG_ON(pdev == NULL);
	k3fd = platform_get_drvdata(pdev);
	BUG_ON(k3fd == NULL);
	pinfo = &(k3fd->panel_info);
	BUG_ON(pinfo == NULL);

	K3_FB_DEBUG("fb%d, +.\n", k3fd->index);

	if (pinfo->lcd_init_step == LCD_INIT_POWER_ON) {
		/* lcd vcc enable */
		vcc_cmds_tx(NULL, tianma_lcd_vcc_enable_cmds, \
			ARRAY_SIZE(tianma_lcd_vcc_enable_cmds));

		pinfo->lcd_init_step = LCD_INIT_MIPI_LP_SEND_SEQUENCE;
	} else if (pinfo->lcd_init_step == LCD_INIT_MIPI_LP_SEND_SEQUENCE) {
		/* lcd gpio request */
		gpio_cmds_tx(tianma_lcd_gpio_request_cmds, \
			ARRAY_SIZE(tianma_lcd_gpio_request_cmds));

		/* lcd gpio normal */
		gpio_cmds_tx(tianma_lcd_gpio_normal_cmds, \
			ARRAY_SIZE(tianma_lcd_gpio_normal_cmds));

		rgb2mipi_cmds_tx(pinfo->spi_dev, tianma_display_on_cmds, \
			ARRAY_SIZE(tianma_display_on_cmds));

		pinfo->lcd_init_step = LCD_INIT_MIPI_HS_SEND_SEQUENCE;
	} else if (pinfo->lcd_init_step == LCD_INIT_MIPI_HS_SEND_SEQUENCE) {
		;
	} else {
		K3_FB_ERR("failed to init lcd!\n");
	}

	K3_FB_DEBUG("fb%d, -.\n", k3fd->index);

	return 0;
}
static void jdi_disp_on(struct k3_fb_data_type *k3fd)
{
	u32 edc_base = 0;
	struct k3_panel_info *pinfo = NULL;

	BUG_ON(k3fd == NULL);
	edc_base = k3fd->edc_base;
	pinfo = &(k3fd->panel_info);

	/* tp iomux normal */
	iomux_cmds_tx(jdi_tp_iomux_normal_cmds, \
		ARRAY_SIZE(jdi_tp_iomux_normal_cmds));

	/* tp gpio request */
	gpio_cmds_tx(jdi_tp_gpio_request_cmds, \
		ARRAY_SIZE(jdi_tp_gpio_request_cmds));

	/* tp gpio normal */
	gpio_cmds_tx(jdi_tp_gpio_normal_cmds, \
		ARRAY_SIZE(jdi_tp_gpio_normal_cmds));

	 /*enable TP's irq which was disabled in jdi_disp_off.*/
	enable_irq(gpio_to_irq(GPIO_19_5));
	
	/* lcd iomux normal */
	iomux_cmds_tx(jdi_lcd_iomux_normal_cmds, \
		ARRAY_SIZE(jdi_lcd_iomux_normal_cmds));

	/* lcd gpio request */
	gpio_cmds_tx(jdi_lcd_gpio_request_cmds, \
		ARRAY_SIZE(jdi_lcd_gpio_request_cmds));
	/* lcd gpio normal */
	gpio_cmds_tx(jdi_lcd_gpio_normal_cmds, \
		ARRAY_SIZE(jdi_lcd_gpio_normal_cmds));

	/* lcd display on sequence */
	mipi_dsi_cmds_tx(jdi_display_on_cmds, \
		ARRAY_SIZE(jdi_display_on_cmds), edc_base);
}
static void cmi_disp_on(struct k3_fb_data_type *k3fd)
{
	u32 edc_base = 0;
	struct k3_panel_info *pinfo = NULL;

	BUG_ON(k3fd == NULL);
	edc_base = k3fd->edc_base;
	pinfo = &(k3fd->panel_info);

	/* lcd iomux normal */
	iomux_cmds_tx(cmi_lcd_iomux_normal_cmds, \
		ARRAY_SIZE(cmi_lcd_iomux_normal_cmds));

	/* lcd gpio request */
	gpio_cmds_tx(cmi_lcd_gpio_request_cmds, \
		ARRAY_SIZE(cmi_lcd_gpio_request_cmds));
	/* lcd gpio normal */
	gpio_cmds_tx(cmi_lcd_gpio_normal_cmds, \
		ARRAY_SIZE(cmi_lcd_gpio_normal_cmds));

	/* lcd display on sequence */
	mipi_dsi_cmds_tx(cmi_display_on_cmds, \
		ARRAY_SIZE(cmi_display_on_cmds), edc_base);
}
static int mipi_tianma_panel_set_fastboot(struct platform_device *pdev)
{
	struct k3_fb_data_type *k3fd = NULL;

	BUG_ON(pdev == NULL);
	k3fd = platform_get_drvdata(pdev);
	BUG_ON(k3fd == NULL);

	K3_FB_DEBUG("fb%d, +.\n", k3fd->index);

	/* lcd vcc enable */
	vcc_cmds_tx(pdev, tianma_lcd_vcc_enable_cmds, \
		ARRAY_SIZE(tianma_lcd_vcc_enable_cmds));

	/* lcd gpio request */
	gpio_cmds_tx(tianma_lcd_gpio_request_cmds, \
		ARRAY_SIZE(tianma_lcd_gpio_request_cmds));

	K3_FB_DEBUG("fb%d, -.\n", k3fd->index);

	return 0;
}
static int mipi_tm_panel_on(struct platform_device* pdev)
{
    struct balong_fb_data_type* balongfd = NULL;
    struct balong_panel_info* pinfo = NULL;
    struct balong_fb_panel_data* pdata = NULL;

#if defined (CONFIG_HUAWEI_DSM)
    u8* ade_base = NULL;
    u32 int_st0 = 0, int_st1 = 0;
#endif

    BUG_ON(pdev == NULL);

    pr_info("%s enter succ!\n", __func__);
    balongfd = (struct balong_fb_data_type*)platform_get_drvdata(pdev);
    BUG_ON(balongfd == NULL);

#if defined (CONFIG_HUAWEI_DSM)
    ade_base = balongfd->ade_base;
#endif

    pinfo = &(balongfd->panel_info);
    pr_info("%s,pinfo->lcd_init_step = %d!\n", __func__, pinfo->lcd_init_step);

    if (pinfo->lcd_init_step == LCD_INIT_POWER_ON)
    {
        /* lcd set voltage */
        vcc_cmds_tx(NULL, tm_lcd_vcc_set_cmds, \
                    ARRAY_SIZE(tm_lcd_vcc_set_cmds));

        pinfo->lcd_init_step = LCD_INIT_SEND_SEQUENCE;
    }
    else if (pinfo->lcd_init_step == LCD_INIT_SEND_SEQUENCE)
    {
        if (!g_display_on)
        {
            LOG_JANK_D(JLID_KERNEL_LCD_POWER_ON, "%s", "JL_KERNEL_LCD_POWER_ON");
            g_debug_enable = true;

            /* lcd pinctrl normal */
            pinctrl_cmds_tx(pdev, tm_lcd_pinctrl_normal_cmds, \
                            ARRAY_SIZE(tm_lcd_pinctrl_normal_cmds));

            /* lcd gpio request */
            gpio_cmds_tx(NULL, tm_lcd_gpio_request_cmds, \
                         ARRAY_SIZE(tm_lcd_gpio_request_cmds));

            /* lcd vcc enable */
            if(1==is_vcc_disabled)
            {
                balongfb_logi("enable VSP and VSN \n");
                vcc_cmds_tx(NULL, tm_lcd_vcc_enable_cmds, \
                        ARRAY_SIZE(tm_lcd_vcc_enable_cmds));
            }
            else
            {
                /* lcd vcc does not enable vsp_vsn*/
                balongfb_logi("VSP VSN does not power on for is_vcc_disabled = %d\n",is_vcc_disabled);
            }
            /* lcd gpio normal */
            gpio_cmds_tx(NULL, tm_lcd_gpio_normal_cmds, \
                         ARRAY_SIZE(tm_lcd_gpio_normal_cmds));

            /* lcd display on sequence */
            mipi_dsi_cmds_tx(tm_display_on_cmds, \
                             ARRAY_SIZE(tm_display_on_cmds), balongfd->dsi_base);

            g_display_on = true;
            /*first set sbl to panel*/
            if (balongfd->panel_info.sbl_enable)
            {
                pdata = (struct balong_fb_panel_data*)balongfd->pdev->dev.platform_data;
                if (pdata->set_sre != NULL)
                {
                    pdata->set_sre(balongfd->pdev, balongfd->sbl_enable, balongfd->sbl_lsensor_value);
                }
            }
        }
    }
    else
    {
        balongfb_loge("failed to init lcd!\n");
    }

    pr_info("%s exit succ!\n", __func__);

#if defined (CONFIG_HUAWEI_DSM)
    int_st0 = inp32(ade_base +  MIPIDSI_INT_ST0_ADDR);
    int_st1 = inp32(ade_base +  MIPIDSI_INT_ST1_ADDR);
    if ((0x00 != int_st0 || 0x00 != int_st1) && (!dsm_client_ocuppy(lcd_dclient)))
    {
        dsm_client_record(lcd_dclient, "LCD dsi status. int_st0:0x%x,\
            int_st1:0x%x.\n", int_st0, int_st1);
        dsm_client_notify(lcd_dclient, DSM_LCD_STATUS_ERROR_NO);
    }
Beispiel #12
0
static void jdi_disp_off(struct k3_fb_data_type *k3fd)
{
	u32 edc_base = 0;
	int retval = 0;
	struct k3_panel_info *pinfo = NULL;

	BUG_ON(k3fd == NULL);
	edc_base = k3fd->edc_base;
	pinfo = &(k3fd->panel_info);

	/* lcd display off sequence */
	mipi_dsi_cmds_tx(jdi_display_off_cmds,
		ARRAY_SIZE(jdi_display_off_cmds), edc_base);

	if(rmi_fc != NULL){

		retval = rmi_f01_glove_switch_read(rmi_fc);
		if (retval < 0)
			dev_err(&rmi_fc->dev,
				"Failed to switch mode between finger and glove. Code: %d.\n",
				retval);
	}

	/*tk suspend should be here, becuase this function is called before suspend*/
	if (g_touchkey_enable == true) {
		touchkey_early_suspend_extern();
	}
    
	/*
	GPIO_19_5 is TP's interrupt GPIO, It is upload by ldo14 which will be closed here,
	so this irq should be disabled at first and then enable it in mipi_jdi_panel_on.
	*/

	disable_irq(gpio_to_irq(GPIO_19_5));

	/* lcd gpio request */
	gpio_cmds_tx(jdi_lcd_gpio_lowpower_cmds, \
		ARRAY_SIZE(jdi_lcd_gpio_lowpower_cmds));

	/* lcd gpio free */
	gpio_cmds_tx(jdi_lcd_gpio_free_cmds, \
		ARRAY_SIZE(jdi_lcd_gpio_free_cmds));

	/* lcd iomux lowpower */
	iomux_cmds_tx(jdi_lcd_iomux_lowpower_cmds, \
		ARRAY_SIZE(jdi_lcd_iomux_lowpower_cmds));

	/* tp gpio request */
	printk("%s	enter:tp gpio request, free and iomux lowpower\n",__func__);
	gpio_cmds_tx(jdi_tp_gpio_lowpower_cmds, \
		ARRAY_SIZE(jdi_tp_gpio_lowpower_cmds));

	/* tp gpio free */
	gpio_cmds_tx(jdi_tp_gpio_free_cmds, \
		ARRAY_SIZE(jdi_tp_gpio_free_cmds));

	/* tp iomux lowpower */
	iomux_cmds_tx(jdi_tp_iomux_lowpower_cmds, \
		ARRAY_SIZE(jdi_tp_iomux_lowpower_cmds));

	/* lcd vcc disable */
	vcc_cmds_tx(NULL, jdi_lcd_vcc_disable_cmds, \
		ARRAY_SIZE(jdi_lcd_vcc_disable_cmds));

	/* tk vcc disable */
	if (g_touchkey_enable == true) {
		vcc_cmds_tx(NULL, jdi_tk_vcc_disable_cmds, \
			ARRAY_SIZE(jdi_tk_vcc_disable_cmds));
	}

	/* tp vcc disable */
	vcc_cmds_tx(NULL, jdi_tp_vcc_disable_cmds, \
		ARRAY_SIZE(jdi_tp_vcc_disable_cmds));

}
Beispiel #13
0
static void jdi_disp_on(struct k3_fb_data_type *k3fd)
{
	u32 edc_base = 0;
	struct k3_panel_info *pinfo = NULL;
	BUG_ON(k3fd == NULL);
	edc_base = k3fd->edc_base;
	pinfo = &(k3fd->panel_info);
	jdi_set_ct_cscValue(k3fd);

	/* tp iomux normal */
	iomux_cmds_tx(jdi_tp_iomux_normal_cmds, \
		ARRAY_SIZE(jdi_tp_iomux_normal_cmds));

	/* tp gpio request */
	gpio_cmds_tx(jdi_tp_gpio_request_cmds, \
		ARRAY_SIZE(jdi_tp_gpio_request_cmds));

	/* tp gpio normal */
	gpio_cmds_tx(jdi_tp_gpio_normal_cmds, \
		ARRAY_SIZE(jdi_tp_gpio_normal_cmds));

	/* lcd iomux normal */
	iomux_cmds_tx(jdi_lcd_iomux_normal_cmds, \
		ARRAY_SIZE(jdi_lcd_iomux_normal_cmds));

	/* lcd gpio request */
	gpio_cmds_tx(jdi_lcd_gpio_request_cmds, \
		ARRAY_SIZE(jdi_lcd_gpio_request_cmds));

	/* lcd gpio normal */
	gpio_cmds_tx(jdi_lcd_gpio_normal_cmds, \
		ARRAY_SIZE(jdi_lcd_gpio_normal_cmds));

	/* lcd display on sequence */
	mipi_dsi_cmds_tx(jdi_display_on_cmds, \
		ARRAY_SIZE(jdi_display_on_cmds), edc_base);

	 /*enable TP's irq which was disabled in jdi_disp_off.*/
	enable_irq(gpio_to_irq(GPIO_19_5));

	/* Enable CABC */
	mipi_dsi_cmds_tx(jdi_cabc_cmds, \
		ARRAY_SIZE(jdi_cabc_cmds), edc_base);
	mipi_dsi_cmds_tx(jdi_cabc_ui_on_cmds, \
		ARRAY_SIZE(jdi_cabc_ui_on_cmds), edc_base);
/*
	mipi_dsi_cmds_tx(jdi_ce_cmds, \
		ARRAY_SIZE(jdi_ce_cmds), edc_base);

	mipi_dsi_cmds_tx(jdi_ce_on_cmds, \
		ARRAY_SIZE(jdi_ce_on_cmds), edc_base);

	mipi_dsi_cmds_tx(jdi_vdd_cmds, \
		ARRAY_SIZE(jdi_vdd_cmds), edc_base);
*/
	/*tk suspend should be here, becuase this function is called before suspend*/
	if (g_touchkey_enable == true) {
		touchkey_later_resume_extern();
	}

	printk("---display on\n");
}