msm: mdss: Mode switch panel clk ctrl uses dsi clk handle

As of commit be2f6d25bb77 ("msm: mdss: dsi: create dsi clock manager")
dsi clock management was split into two clients: mdp and dsi. Cmd mode
interface uses the mdp client handle and everything else using dsi
client handle. When transitioning from one dsi mode to another, clocks
need to be rebalanced. In order to rebalance properly, mode switch is
required to vote using the dsi client handle. Modified input argument to
MDSS_EVENT_PANEL_CLK_CTRL to allow for client handle selection.

Change-Id: Id54d72de603e2115451a49fed961d01f4440c517
Signed-off-by: Terence Hampson <thampson@codeaurora.org>
[cip@codeaurora.org: Resolved merge conflict]
Signed-off-by: Clarence Ip <cip@codeaurora.org>

drivers/video/fbdev/msm/dsi_v2.c

@@ -185,7 +185,8 @@ static int dsi_event_handler(struct mdss_panel_data *pdata,
 		rc = dsi_splash_on(pdata);
 		break;
 	case MDSS_EVENT_PANEL_CLK_CTRL:
-		rc = dsi_clk_ctrl(pdata, (int)arg);
+		rc = dsi_clk_ctrl(pdata,
+			(int)(((struct dsi_panel_clk_ctrl *)arg)->state));
 		break;
 	case MDSS_EVENT_DSI_UPDATE_PANEL_DATA:
 		rc = dsi_update_pconfig(pdata, (int)(unsigned long) arg);

drivers/video/fbdev/msm/mdp3_ctrl.c

@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2015, 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
@@ -346,6 +346,7 @@ static int mdp3_ctrl_clk_enable(struct msm_fb_data_type *mfd, int enable)
 {
 	struct mdp3_session_data *session;
 	struct mdss_panel_data *panel;
+	struct dsi_panel_clk_ctrl clk_ctrl;
 	int rc = 0;
 
 	pr_debug("mdp3_ctrl_clk_enable %d\n", enable);
@@ -358,8 +359,10 @@ static int mdp3_ctrl_clk_enable(struct msm_fb_data_type *mfd, int enable)
 
 	if ((enable && session->clk_on == 0) ||
 				(!enable && session->clk_on == 1)) {
+		clk_ctrl.client = DSI_CLK_REQ_MDP_CLIENT;
+		clk_ctrl.state = enable;
 		rc = panel->event_handler(panel,
-			MDSS_EVENT_PANEL_CLK_CTRL, (void *)enable);
+			MDSS_EVENT_PANEL_CLK_CTRL, (void *)&clk_ctrl);
 		rc |= mdp3_res_update(enable, 1, MDP3_CLIENT_DMA_P);
 	} else {
 		pr_debug("enable = %d, clk_on=%d\n", enable, session->clk_on);

drivers/video/fbdev/msm/mdss_dsi.c

@@ -2061,7 +2061,8 @@ static int mdss_dsi_event_handler(struct mdss_panel_data *pdata,
 		rc = mdss_dsi_cont_splash_on(pdata);
 		break;
 	case MDSS_EVENT_PANEL_CLK_CTRL:
-		mdss_dsi_clk_req(ctrl_pdata, (int) (unsigned long) arg);
+		mdss_dsi_clk_req(ctrl_pdata,
+			(struct dsi_panel_clk_ctrl *) arg);
 		break;
 	case MDSS_EVENT_DSI_CMDLIST_KOFF:
 		mdss_dsi_cmdlist_commit(ctrl_pdata, 1);

drivers/video/fbdev/msm/mdss_dsi.h

@@ -522,7 +522,7 @@ void mdss_dsi_ack_err_status(struct mdss_dsi_ctrl_pdata *ctrl);
 int mdss_dsi_clk_ctrl(struct mdss_dsi_ctrl_pdata *ctrl, void *clk_handle,
 	enum mdss_dsi_clk_type clk_type, enum mdss_dsi_clk_state clk_state);
 void mdss_dsi_clk_req(struct mdss_dsi_ctrl_pdata *ctrl,
-				int enable);
+	struct dsi_panel_clk_ctrl *clk_ctrl);
 void mdss_dsi_controller_cfg(int enable,
 				struct mdss_panel_data *pdata);
 void mdss_dsi_sw_reset(struct mdss_dsi_ctrl_pdata *ctrl_pdata, bool restore);

drivers/video/fbdev/msm/mdss_dsi_clk.h

@@ -27,6 +27,11 @@ enum mdss_dsi_clk_state {
 	MDSS_DSI_CLK_EARLY_GATE,
 };
 
+enum dsi_clk_req_client {
+	DSI_CLK_REQ_MDP_CLIENT = 0,
+	DSI_CLK_REQ_DSI_CLIENT,
+};
+
 enum mdss_dsi_link_clk_type {
 	MDSS_DSI_LINK_ESC_CLK,
 	MDSS_DSI_LINK_BYTE_CLK,
@@ -102,6 +107,11 @@ struct mdss_dsi_link_clk_info {
 	struct clk *pixel_clk;
 };
 
+struct dsi_panel_clk_ctrl {
+	enum mdss_dsi_clk_state state;
+	enum dsi_clk_req_client client;
+};
+
 /**
  * struct mdss_dsi_clk_info - clock information to initialize manager
  * @name: name for the clocks to identify debug logs.

drivers/video/fbdev/msm/mdss_dsi_host.c

@@ -139,9 +139,18 @@ static void mdss_dsi_set_reg(struct mdss_dsi_ctrl_pdata *ctrl, int off,
 	MIPI_OUTP(ctrl->ctrl_base + off, data);
 }
 
-void mdss_dsi_clk_req(struct mdss_dsi_ctrl_pdata *ctrl, int enable)
+void mdss_dsi_clk_req(struct mdss_dsi_ctrl_pdata *ctrl,
+	struct dsi_panel_clk_ctrl *clk_ctrl)
 {
-	MDSS_XLOG(ctrl->ndx, enable, ctrl->mdp_busy, current->pid);
+	enum dsi_clk_req_client client = clk_ctrl->client;
+	int enable = clk_ctrl->state;
+	void *clk_handle = ctrl->mdp_clk_handle;
+
+	if (clk_ctrl->client == DSI_CLK_REQ_DSI_CLIENT)
+		clk_handle = ctrl->dsi_clk_handle;
+
+	MDSS_XLOG(ctrl->ndx, enable, ctrl->mdp_busy, current->pid,
+		client);
 	if (enable == 0) {
 		/* need wait before disable */
 		mutex_lock(&ctrl->cmd_mutex);
@@ -149,8 +158,9 @@ void mdss_dsi_clk_req(struct mdss_dsi_ctrl_pdata *ctrl, int enable)
 		mutex_unlock(&ctrl->cmd_mutex);
 	}
 
-	MDSS_XLOG(ctrl->ndx, enable, ctrl->mdp_busy, current->pid);
+	MDSS_XLOG(ctrl->ndx, enable, ctrl->mdp_busy, current->pid,
-	mdss_dsi_clk_ctrl(ctrl, ctrl->mdp_clk_handle,
+		client);
+	mdss_dsi_clk_ctrl(ctrl, clk_handle,
 		  MDSS_DSI_ALL_CLKS, enable);
 }
 

drivers/video/fbdev/msm/mdss_mdp_intf_cmd.c

@@ -457,6 +457,7 @@ int mdss_mdp_resource_control(struct mdss_mdp_ctl *ctl, u32 sw_event)
 	struct mdss_data_type *mdata = mdss_mdp_get_mdata();
 	struct mdss_mdp_ctl *sctl = NULL;
 	struct mdss_mdp_cmd_ctx *ctx, *sctx = NULL;
+	struct dsi_panel_clk_ctrl clk_ctrl;
 	u32 status;
 	int rc = 0;
 
@@ -531,14 +532,16 @@ int mdss_mdp_resource_control(struct mdss_mdp_ctl *ctl, u32 sw_event)
 			/* Enable/Ungate DSI clocks and resources */
 			mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON);
 
+			clk_ctrl.state = MDSS_DSI_CLK_ON;
+			clk_ctrl.client = DSI_CLK_REQ_MDP_CLIENT;
 			mdss_mdp_ctl_intf_event /* enable master */
 				(ctx->ctl, MDSS_EVENT_PANEL_CLK_CTRL,
-				(void *)MDSS_DSI_CLK_ON, true);
+				(void *)&clk_ctrl, true);
 
 			if (sctx) /* then slave */
 				mdss_mdp_ctl_intf_event
 				 (sctx->ctl, MDSS_EVENT_PANEL_CLK_CTRL,
-				 (void *)MDSS_DSI_CLK_ON, true);
+				 (void *)&clk_ctrl, true);
 
 			if (mdp5_data->resources_state ==
 					MDP_RSRC_CTL_STATE_GATE)
@@ -720,14 +723,16 @@ int mdss_mdp_resource_control(struct mdss_mdp_ctl *ctl, u32 sw_event)
 		MDSS_XLOG(ctl->num, mdp5_data->resources_state, sw_event, 0x44);
 		if (mdp5_data->resources_state == MDP_RSRC_CTL_STATE_OFF) {
 			mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON);
+			clk_ctrl.state = MDSS_DSI_CLK_ON;
+			clk_ctrl.client = DSI_CLK_REQ_MDP_CLIENT;
 			mdss_mdp_ctl_intf_event(ctx->ctl,
 						MDSS_EVENT_PANEL_CLK_CTRL,
-						(void *)MDSS_DSI_CLK_ON,
+						(void *)&clk_ctrl,
 						true);
 			if (sctx)
 				mdss_mdp_ctl_intf_event(sctx->ctl,
 						      MDSS_EVENT_PANEL_CLK_CTRL,
-						      (void *)MDSS_DSI_CLK_ON,
+						      (void *)&clk_ctrl,
 						      true);
 
 			mdss_mdp_cmd_clk_on(ctx);
@@ -773,6 +778,7 @@ static inline void mdss_mdp_cmd_clk_on(struct mdss_mdp_cmd_ctx *ctx)
 static inline void mdss_mdp_cmd_clk_off(struct mdss_mdp_cmd_ctx *ctx)
 {
 	struct mdss_data_type *mdata = mdss_mdp_get_mdata();
+	struct dsi_panel_clk_ctrl clk_ctrl;
 
 	if (ctx->autorefresh_init) {
 		/* Do not turn off clocks if aurtorefresh is on. */
@@ -786,9 +792,11 @@ static inline void mdss_mdp_cmd_clk_off(struct mdss_mdp_cmd_ctx *ctx)
 
 	/* Power off DSI, is caller responsibility to do slave then master  */
 	if (ctx->ctl) {
+		clk_ctrl.state = MDSS_DSI_CLK_OFF;
+		clk_ctrl.client = DSI_CLK_REQ_MDP_CLIENT;
 		mdss_mdp_ctl_intf_event
 			(ctx->ctl, MDSS_EVENT_PANEL_CLK_CTRL,
-			(void *) MDSS_DSI_CLK_OFF, true);
+			(void *)&clk_ctrl, true);
 	} else {
 		pr_err("OFF with ctl:NULL\n");
 	}
@@ -1049,6 +1057,7 @@ static void clk_ctrl_gate_work(struct work_struct *work)
 		container_of(work, typeof(*ctx), gate_clk_work);
 	struct mdss_mdp_ctl *ctl, *sctl;
 	struct mdss_mdp_cmd_ctx *sctx = NULL;
+	struct dsi_panel_clk_ctrl clk_ctrl;
 
 	if (!ctx) {
 		pr_err("%s: invalid ctx\n", __func__);
@@ -1108,16 +1117,18 @@ static void clk_ctrl_gate_work(struct work_struct *work)
 		goto exit;
 	}
 
+	clk_ctrl.state = MDSS_DSI_CLK_EARLY_GATE;
+	clk_ctrl.client = DSI_CLK_REQ_MDP_CLIENT;
 	/* First gate the DSI clocks for the slave controller (if present) */
 	if (sctx)
 		mdss_mdp_ctl_intf_event
 			(sctx->ctl, MDSS_EVENT_PANEL_CLK_CTRL,
-			(void *)MDSS_DSI_CLK_EARLY_GATE, true);
+			(void *)&clk_ctrl, true);
 
 	/* Now gate DSI clocks for the master */
 	mdss_mdp_ctl_intf_event
 		(ctx->ctl, MDSS_EVENT_PANEL_CLK_CTRL,
-		(void *)MDSS_DSI_CLK_EARLY_GATE, true);
+		(void *)&clk_ctrl, true);
 
 	/* Gate mdp clocks */
 	mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF);
@@ -1279,16 +1290,19 @@ int mdss_mdp_cmd_reconfigure_splash_done(struct mdss_mdp_ctl *ctl,
 {
 	struct mdss_panel_data *pdata;
 	struct mdss_mdp_ctl *sctl = mdss_mdp_get_split_ctl(ctl);
+	struct dsi_panel_clk_ctrl clk_ctrl;
 	int ret = 0;
 
 	pdata = ctl->panel_data;
 
+	clk_ctrl.state = MDSS_DSI_CLK_OFF;
+	clk_ctrl.client = DSI_CLK_REQ_MDP_CLIENT;
 	if (sctl)
 		mdss_mdp_ctl_intf_event(sctl, MDSS_EVENT_PANEL_CLK_CTRL,
-			(void *)MDSS_DSI_CLK_OFF, true);
+			(void *)&clk_ctrl, true);
 
 	mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_PANEL_CLK_CTRL,
-		(void *)MDSS_DSI_CLK_OFF, true);
+		(void *)&clk_ctrl, true);
 
 	pdata->panel_info.cont_splash_enabled = 0;
 	if (sctl)
@@ -2192,19 +2206,28 @@ void mdss_mdp_switch_roi_reset(struct mdss_mdp_ctl *ctl)
 
 void mdss_mdp_switch_to_vid_mode(struct mdss_mdp_ctl *ctl, int prep)
 {
+	struct mdss_mdp_ctl *sctl = mdss_mdp_get_split_ctl(ctl);
+	struct dsi_panel_clk_ctrl clk_ctrl;
 	long int mode = MIPI_VIDEO_PANEL;
-	int rc = 0;
 
 	pr_debug("%s start, prep = %d\n", __func__, prep);
 
 	if (prep) {
 		/*
 		 * In dsi_on there is an explicit decrement to dsi clk refcount
-		 * if we are in cmd mode. We need to rebalance clock in order
+		 * if we are in cmd mode, using the dsi client handle. We need
-		 * to properly enable vid mode compnents
+		 * to rebalance clock in order to properly enable vid mode
+		 * compnents.
 		 */
-		rc = mdss_mdp_ctl_intf_event
+		clk_ctrl.state = MDSS_DSI_CLK_ON;
-			(ctl, MDSS_EVENT_PANEL_CLK_CTRL, (void *)1, false);
+		clk_ctrl.client = DSI_CLK_REQ_DSI_CLIENT;
+		if (sctl)
+			mdss_mdp_ctl_intf_event(sctl,
+				MDSS_EVENT_PANEL_CLK_CTRL,
+				(void *)&clk_ctrl, true);
+
+		mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_PANEL_CLK_CTRL,
+			(void *)&clk_ctrl, true);
 
 		return;
 	}
@@ -2216,6 +2239,7 @@ void mdss_mdp_switch_to_vid_mode(struct mdss_mdp_ctl *ctl, int prep)
 static int mdss_mdp_cmd_reconfigure(struct mdss_mdp_ctl *ctl,
 		enum dynamic_switch_modes mode, bool prep)
 {
+	struct dsi_panel_clk_ctrl clk_ctrl;
 	int ret, rc = 0;
 
 	if (mdss_mdp_ctl_is_power_off(ctl))
@@ -2242,9 +2266,11 @@ static int mdss_mdp_cmd_reconfigure(struct mdss_mdp_ctl *ctl,
 			if (IS_ERR_VALUE(rc))
 				pr_err("IOMMU attach failed\n");
 
+			clk_ctrl.state = MDSS_DSI_CLK_ON;
+			clk_ctrl.client = DSI_CLK_REQ_MDP_CLIENT;
 			mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON);
 			mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_PANEL_CLK_CTRL,
-					(void *)1, false);
+					(void *)&clk_ctrl, false);
 
 			mdss_mdp_ctl_stop(ctl, MDSS_PANEL_POWER_OFF);
 			mdss_mdp_ctl_intf_event(ctl,
@@ -2252,8 +2278,10 @@ static int mdss_mdp_cmd_reconfigure(struct mdss_mdp_ctl *ctl,
 					(void *) mode, false);
 		} else {
 			/* release ref count after switch is complete */
+			clk_ctrl.state = MDSS_DSI_CLK_OFF;
+			clk_ctrl.client = DSI_CLK_REQ_MDP_CLIENT;
 			mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_PANEL_CLK_CTRL,
-					(void *)0, false);
+					(void *)&clk_ctrl, false);
 			mdss_iommu_ctrl(0);
 			mdss_bus_bandwidth_ctrl(false);
 			mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF);

drivers/video/fbdev/msm/mdss_mdp_overlay.c

@@ -37,6 +37,7 @@
 #include "mdss_mdp_rotator.h"
 #include "mdss_smmu.h"
 #include "mdss_mdp_wfd.h"
+#include "mdss_dsi_clk.h"
 
 #define VSYNC_PERIOD 16
 #define BORDERFILL_NDX	0x0BF000BF
@@ -1719,7 +1720,8 @@ int mdss_mode_switch(struct msm_fb_data_type *mfd, u32 mode)
 int mdss_mode_switch_post(struct msm_fb_data_type *mfd, u32 mode)
 {
 	struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);
-	struct mdss_mdp_ctl *sctl;
+	struct mdss_mdp_ctl *sctl = mdss_mdp_get_split_ctl(ctl);
+	struct dsi_panel_clk_ctrl clk_ctrl;
 	int rc = 0;
 	u32 frame_rate = 0;
 
@@ -1747,15 +1749,20 @@ int mdss_mode_switch_post(struct msm_fb_data_type *mfd, u32 mode)
 		 * from video to command. This allows for idle
 		 * power collapse to work as intended.
 		 */
-		mdss_mdp_ctl_intf_event(ctl,
+		clk_ctrl.state = MDSS_DSI_CLK_OFF;
-			MDSS_EVENT_PANEL_CLK_CTRL, (void *)0,
+		clk_ctrl.client = DSI_CLK_REQ_DSI_CLIENT;
-			false);
+		if (sctl)
+			mdss_mdp_ctl_intf_event(sctl,
+				MDSS_EVENT_PANEL_CLK_CTRL,
+				(void *)&clk_ctrl, true);
+
+		mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_PANEL_CLK_CTRL,
+			(void *)&clk_ctrl, true);
 	} else if (mode == SWITCH_RESOLUTION) {
 		if (ctl->ops.reconfigure)
 			rc = ctl->ops.reconfigure(ctl, mode, 0);
 	}
 	ctl->pending_mode_switch = 0;
-	sctl = mdss_mdp_get_split_ctl(ctl);
 	if (sctl)
 		sctl->pending_mode_switch = 0;