Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8070f4c1 authored by raghavendra ambadas's avatar raghavendra ambadas
Browse files

msm: mdss: Dynamically enabling ESD 



Allow the check_status interval time to be
configurable via /sys interface.
Allow the dsi_check_status function to be
enabled or disabled via /sys interface
Combine MDP3 & MDP5 code and separate
the platform specific code.

Change-Id: Ida14b96864353fb58606009bc00312f6f338c736
Signed-off-by: default avatarRaghavendra Ambadas <rambad@codeaurora.org>
parent 174102e8

drivers/video/msm/mdss/Makefile

+2 −6
Original line number Diff line number Diff line 
mdss-mdp3-objs = mdp3.o mdp3_dma.o mdp3_ctrl.o

mdss-mdp3-objs = mdp3.o mdp3_dma.o mdp3_ctrl.o dsi_status_v2.o

mdss-mdp3-objs += mdp3_ppp.o mdp3_ppp_hwio.o mdp3_ppp_data.o

obj-$(CONFIG_FB_MSM_MDSS_MDP3) += mdss-mdp3.o



mdss-mdp-objs := mdss_mdp.o mdss_mdp_ctl.o mdss_mdp_pipe.o mdss_mdp_util.o

mdss-mdp-objs := mdss_mdp.o mdss_mdp_ctl.o mdss_mdp_pipe.o mdss_mdp_util.o dsi_status_6g.o

mdss-mdp-objs += mdss_mdp_pp.o mdss_mdp_pp_debug.o

mdss-mdp-objs += mdss_mdp_intf_video.o

mdss-mdp-objs += mdss_mdp_intf_cmd.o
@@ -43,8 +43,4 @@ obj-$(CONFIG_FB_MSM_QPIC_ILI_QVGA_PANEL) += qpic_panel_ili_qvga.o 
obj-$(CONFIG_FB_MSM_MDSS) += mdss_fb.o

obj-$(CONFIG_COMPAT) += mdss_compat_utils.o



ifeq ($(CONFIG_FB_MSM_MDSS_MDP3),y)

obj-$(CONFIG_FB_MSM_MDSS_DSI_CTRL_STATUS) += dsi_status_v2.o

else

obj-$(CONFIG_FB_MSM_MDSS_DSI_CTRL_STATUS) += mdss_dsi_status.o
 
endif

drivers/video/msm/mdss/dsi_status_6g.c

0 → 100644
+109 −0
Original line number Diff line number Diff line 
/* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */



#include <linux/workqueue.h>

#include <linux/delay.h>

#include <linux/kobject.h>

#include <linux/sysfs.h>



#include "mdss_dsi.h"

#include "mdss_mdp.h"



/*

 * mdss_check_dsi_ctrl_status() - Check MDP5 DSI controller status periodically.

 * @work     : dsi controller status data

 * @interval : duration in milliseconds to schedule work queue

 *

 * This function calls check_status API on DSI controller to send the BTA

 * command. If DSI controller fails to acknowledge the BTA command, it sends

 * the PANEL_ALIVE=0 status to HAL layer.

 */

void mdss_check_dsi_ctrl_status(struct work_struct *work, uint32_t interval)

{

	struct dsi_status_data *pstatus_data = NULL;

	struct mdss_panel_data *pdata = NULL;

	struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;

	struct mdss_overlay_private *mdp5_data = NULL;

	struct mdss_mdp_ctl *ctl = NULL;

	int ret = 0;



	pstatus_data = container_of(to_delayed_work(work),

		struct dsi_status_data, check_status);



	pdata = dev_get_platdata(&pstatus_data->mfd->pdev->dev);

	if (!pdata) {

		pr_err("%s: Panel data not available\n", __func__);

		return;

	}



	ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,

							panel_data);

	if (!ctrl_pdata || !ctrl_pdata->check_status) {

		pr_err("%s: DSI ctrl or status_check callback not available\n",

								__func__);

		return;

	}



	mdp5_data = mfd_to_mdp5_data(pstatus_data->mfd);

	ctl = mfd_to_ctl(pstatus_data->mfd);



	if (ctl->shared_lock)

		mutex_lock(ctl->shared_lock);

	mutex_lock(&mdp5_data->ov_lock);



	if (pstatus_data->mfd->shutdown_pending) {

		mutex_unlock(&mdp5_data->ov_lock);

		if (ctl->shared_lock)

			mutex_unlock(ctl->shared_lock);

		pr_err("%s: DSI turning off, avoiding BTA status check\n",

							__func__);

		return;

	}



	/*

	 * For the command mode panels, we return pan display

	 * IOCTL on vsync interrupt. So, after vsync interrupt comes

	 * and when DMA_P is in progress, if the panel stops responding

	 * and if we trigger BTA before DMA_P finishes, then the DSI

	 * FIFO will not be cleared since the DSI data bus control

	 * doesn't come back to the host after BTA. This may cause the

	 * display reset not to be proper. Hence, wait for DMA_P done

	 * for command mode panels before triggering BTA.

	 */

	if (ctl->wait_pingpong)

		ctl->wait_pingpong(ctl, NULL);



	pr_debug("%s: DSI ctrl wait for ping pong done\n", __func__);



	mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON, false);

	ret = ctrl_pdata->check_status(ctrl_pdata);

	mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF, false);



	mutex_unlock(&mdp5_data->ov_lock);

	if (ctl->shared_lock)

		mutex_unlock(ctl->shared_lock);



	if ((pstatus_data->mfd->panel_power_on)) {

		if (ret > 0) {

			schedule_delayed_work(&pstatus_data->check_status,

				msecs_to_jiffies(interval));

		} else {

			char *envp[2] = {"PANEL_ALIVE=0", NULL};

			pdata->panel_info.panel_dead = true;

			ret = kobject_uevent_env(

				&pstatus_data->mfd->fbi->dev->kobj,

							KOBJ_CHANGE, envp);

			pr_err("%s: Panel has gone bad, sending uevent - %s\n",

							__func__, envp[0]);

		}

	}

}

drivers/video/msm/mdss/dsi_status_v2.c

+18 −128
Original line number Diff line number Diff line
@@ -10,49 +10,26 @@ 
 * GNU General Public License for more details.

 */



#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/fb.h>

#include <linux/notifier.h>

#include <linux/workqueue.h>

#include <linux/delay.h>

#include <linux/debugfs.h>

#include <linux/slab.h>

#include <linux/uaccess.h>

#include <linux/iopoll.h>

#include <linux/kobject.h>

#include <linux/string.h>

#include <linux/sysfs.h>



#include "mdss_fb.h"

#include "mdss_dsi.h"

#include "mdss_panel.h"

#include "mdp3_ctrl.h"



#define STATUS_CHECK_INTERVAL 5000



/**

 * dsi_status_data - Stores all the data necessary for this module

 * @fb_notif: Used to egister for the fb events

 * @live_status: Delayed worker structure, used to associate the

 * delayed worker function

 * @mfd: Used to store the msm_fb_data_type received when the notifier

 * call back happens

 * @root: Stores the dir created by debuugfs

 * @debugfs_reset_panel: The debugfs variable used to inject errors

/*

 * mdp3_check_dsi_ctrl_status() - Check MDP3 DSI controller status periodically.

 * @work     : dsi controller status data

 * @interval : duration in milliseconds to schedule work queue

 *

 * This function calls check_status API on DSI controller to send the BTA

 * command. If DSI controller fails to acknowledge the BTA command, it sends

 * the PANEL_ALIVE=0 status to HAL layer.

 */



struct dsi_status_data {

	struct notifier_block fb_notifier;

	struct delayed_work check_status;

	struct msm_fb_data_type *mfd;

	uint32_t check_interval;

};

static struct dsi_status_data *pstatus_data;

static uint32_t interval = STATUS_CHECK_INTERVAL;



static void check_dsi_ctrl_status(struct work_struct *work)

void mdp3_check_dsi_ctrl_status(struct work_struct *work,

				uint32_t interval)

{

	struct dsi_status_data *pdsi_status = NULL;

	struct mdss_panel_data *pdata = NULL;
@@ -62,26 +39,24 @@ static void check_dsi_ctrl_status(struct work_struct *work) 


	pdsi_status = container_of(to_delayed_work(work),

	struct dsi_status_data, check_status);

	if (!pdsi_status) {

		pr_err("%s: DSI status data not available\n", __func__);

		return;

	}



	pdata = dev_get_platdata(&pdsi_status->mfd->pdev->dev);

	if (!pdata) {

		pr_err("%s: Panel data not available\n", __func__);

		return;

	}



	ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,

							panel_data);



	if (!ctrl_pdata || !ctrl_pdata->check_status) {

		pr_err("%s: DSI ctrl or status_check callback not avilable\n",

		pr_err("%s: DSI ctrl or status_check callback not available\n",

								__func__);

		return;

	}



	mdp3_session = pdsi_status->mfd->mdp.private1;

	mutex_lock(&mdp3_session->lock);



	if (!mdp3_session->status) {

		pr_debug("%s: display off already\n", __func__);

		mutex_unlock(&mdp3_session->lock);
@@ -95,13 +70,12 @@ static void check_dsi_ctrl_status(struct work_struct *work) 
		ret = ctrl_pdata->check_status(ctrl_pdata);

	else

		pr_err("%s: wait_for_dma_done error\n", __func__);



	mutex_unlock(&mdp3_session->lock);



	if ((pdsi_status->mfd->panel_power_on)) {

		if (ret > 0) {

			schedule_delayed_work(&pdsi_status->check_status,

				msecs_to_jiffies(pdsi_status->check_interval));

						msecs_to_jiffies(interval));

		} else {

			char *envp[2] = {"PANEL_ALIVE=0", NULL};

			pdata->panel_info.panel_dead = true;
@@ -114,87 +88,3 @@ static void check_dsi_ctrl_status(struct work_struct *work) 
	}

}

/**

 * fb_notifier_callback() - Call back function for the fb_register_client()

 * notifying events

 * @self  : notifier block

 * @event : The event that was triggered

 * @data  : Of type struct fb_event

 *

 * - This function listens for FB_BLANK_UNBLANK and FB_BLANK_POWERDOWN events

 * - Based on the event the delayed work is either scheduled again after

 * PANEL_STATUS_CHECK_INTERVAL or cancelled

 */

static int fb_event_callback(struct notifier_block *self,

				unsigned long event, void *data)

{

	struct fb_event *evdata = (struct fb_event *)data;

	struct dsi_status_data *pdata = container_of(self,

				struct dsi_status_data, fb_notifier);

	pdata->mfd = (struct msm_fb_data_type *)evdata->info->par;



	if (event == FB_EVENT_BLANK && evdata) {

		int *blank = evdata->data;

		switch (*blank) {

		case FB_BLANK_UNBLANK:

			schedule_delayed_work(&pdata->check_status,

			msecs_to_jiffies(STATUS_CHECK_INTERVAL));

			break;

		case FB_BLANK_POWERDOWN:

			cancel_delayed_work(&pdata->check_status);

			break;

		}

	}

	return 0;

}



int __init mdss_dsi_status_init(void)

{

	int rc;



	pstatus_data = kzalloc(sizeof(struct dsi_status_data), GFP_KERNEL);

	if (!pstatus_data) {

		pr_err("%s: can't alloc mem\n", __func__);

		rc = -ENOMEM;

		return rc;

	}



	memset(pstatus_data, 0, sizeof(struct dsi_status_data));



	pstatus_data->fb_notifier.notifier_call = fb_event_callback;



	rc = fb_register_client(&pstatus_data->fb_notifier);

	if (rc < 0) {

		pr_err("%s: fb_register_client failed, returned with rc=%d\n",

								__func__, rc);

		kfree(pstatus_data);

		return -EPERM;

	}



	pstatus_data->check_interval = interval;

	pr_info("%s: DSI status check interval:%d\n", __func__, interval);



	INIT_DELAYED_WORK(&pstatus_data->check_status, check_dsi_ctrl_status);



	pr_debug("%s: DSI ctrl status thread initialized\n", __func__);



	return rc;

}



void __exit mdss_dsi_status_exit(void)

{

	fb_unregister_client(&pstatus_data->fb_notifier);

	cancel_delayed_work_sync(&pstatus_data->check_status);

	kfree(pstatus_data);

	pr_debug("%s: DSI ctrl status thread removed\n", __func__);

}



module_param(interval, uint, 0);

MODULE_PARM_DESC(interval,

	"Duration in milliseconds to send BTA command for checking"

	"DSI status periodically");



module_init(mdss_dsi_status_init);

module_exit(mdss_dsi_status_exit);



MODULE_LICENSE("GPL v2");

drivers/video/msm/mdss/mdp3.c

+1 −0
Original line number Diff line number Diff line
@@ -2209,6 +2209,7 @@ static int mdp3_probe(struct platform_device *pdev) 
	.panel_register_done = mdp3_panel_register_done,

	.fb_stride = mdp3_fb_stride,

	.fb_mem_alloc_fnc = mdp3_alloc,

	.check_dsi_status = mdp3_check_dsi_ctrl_status,

	};



	struct mdp3_intr_cb underrun_cb = {

drivers/video/msm/mdss/mdp3.h

+2 −0
Original line number Diff line number Diff line
@@ -206,6 +206,8 @@ int mdp3_put_mdp_dsi_clk(void); 
int mdp3_misr_set(struct mdp_misr *misr_req);

int mdp3_misr_get(struct mdp_misr *misr_resp);

void mdp3_enable_regulator(int enable);

void mdp3_check_dsi_ctrl_status(struct work_struct *work,

				uint32_t interval);



#define MDP3_REG_WRITE(addr, val) writel_relaxed(val, mdp3_res->mdp_base + addr)

#define MDP3_REG_READ(addr) readl_relaxed(mdp3_res->mdp_base + addr)