Merge "msm: mdss: Dynamically enabling ESD" (a8816441) · Commits · e / devices / android_kernel_sony_msm8994

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)