drm/msm/sde: update encoder dmesg logging to use sde macros

This change modifies the video and command mode encoders to use
local sde defined macros for debug and error logging rather than
standard drm ones. The local sde macros allow the logs to be
enabled both from the normal drm_debug and Linux dynamic debug
interfaces.

Change-Id: I25775dbe30f140f3833b3aa7c735f31bbc987f26
Signed-off-by: Clarence Ip <cip@codeaurora.org>

3 files changed, 375 insertions, 182 deletions

diff --git a/drivers/gpu/drm/msm/sde/sde_encoder.c b/drivers/gpu/drm/msm/sde/sde_encoder.c
index 67190a3448d0..69fbe3aa13ce 100644
--- a/drivers/gpu/drm/msm/sde/sde_encoder.c
+++ b/drivers/gpu/drm/msm/sde/sde_encoder.c
@@ -10,6 +10,7 @@
  * GNU General Public License for more details.
  */
 
+#define pr_fmt(fmt)	"[drm:%s:%d] " fmt, __func__, __LINE__
 #include "msm_drv.h"
 #include "sde_kms.h"
 #include "drm_crtc.h"
@@ -23,6 +24,12 @@
 #include "sde_encoder_phys.h"
 #include "display_manager.h"
 
+#define SDE_DEBUG_ENC(e, fmt, ...) SDE_DEBUG("enc%d " fmt,\
+		(e) ? (e)->base.base.id : -1, ##__VA_ARGS__)
+
+#define SDE_ERROR_ENC(e, fmt, ...) SDE_ERROR("enc%d " fmt,\
+		(e) ? (e)->base.base.id : -1, ##__VA_ARGS__)
+
 /*
  * Two to anticipate panels that can do cmd/vid dynamic switching
  * plan is to create all possible physical encoder types, and switch between
@@ -120,13 +127,24 @@ static struct msm_bus_scale_pdata mdp_bus_scale_table = {
 
 static void bs_init(struct sde_encoder_virt *sde_enc)
 {
+	if (!sde_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+
 	sde_enc->bus_scaling_client =
 	    msm_bus_scale_register_client(&mdp_bus_scale_table);
-	DBG("bus scale client: %08x", sde_enc->bus_scaling_client);
+	SDE_DEBUG_ENC(sde_enc, "bus scale client %08x\n",
+			sde_enc->bus_scaling_client);
 }
 
 static void bs_fini(struct sde_encoder_virt *sde_enc)
 {
+	if (!sde_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+
 	if (sde_enc->bus_scaling_client) {
 		msm_bus_scale_unregister_client(sde_enc->bus_scaling_client);
 		sde_enc->bus_scaling_client = 0;
@@ -135,8 +153,13 @@ static void bs_fini(struct sde_encoder_virt *sde_enc)
 
 static void bs_set(struct sde_encoder_virt *sde_enc, int idx)
 {
+	if (!sde_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+
 	if (sde_enc->bus_scaling_client) {
-		DBG("set bus scaling: %d", idx);
+		SDE_DEBUG_ENC(sde_enc, "set bus scaling to %d\n", idx);
 		idx = 1;
 		msm_bus_scale_client_update_request(sde_enc->bus_scaling_client,
 						    idx);
@@ -163,14 +186,14 @@ void sde_encoder_get_hw_resources(struct drm_encoder *drm_enc,
 	struct sde_encoder_virt *sde_enc = NULL;
 	int i = 0;
 
-	DBG("");
-
 	if (!hw_res || !drm_enc || !conn_state) {
-		DRM_ERROR("Invalid pointer");
+		SDE_ERROR("invalid argument(s), drm_enc %d, res %d, state %d\n",
+				drm_enc != 0, hw_res != 0, conn_state != 0);
 		return;
 	}
 
 	sde_enc = to_sde_encoder_virt(drm_enc);
+	SDE_DEBUG_ENC(sde_enc, "\n");
 
 	/* Query resources used by phys encs, expected to be without overlap */
 	memset(hw_res, 0, sizeof(*hw_res));
@@ -190,7 +213,7 @@ bool sde_encoder_needs_ctl_start(struct drm_encoder *drm_enc)
 	struct sde_encoder_phys *phys;
 
 	if (!drm_enc) {
-		DRM_ERROR("Invalid pointer");
+		SDE_ERROR("invalid pointer\n");
 		return false;
 	}
 	sde_enc = to_sde_encoder_virt(drm_enc);
@@ -207,14 +230,13 @@ static void sde_encoder_destroy(struct drm_encoder *drm_enc)
 	struct sde_encoder_virt *sde_enc = NULL;
 	int i = 0;
 
-	DBG("");
-
 	if (!drm_enc) {
-		DRM_ERROR("Invalid pointer");
+		SDE_ERROR("invalid encoder\n");
 		return;
 	}
 
 	sde_enc = to_sde_encoder_virt(drm_enc);
+	SDE_DEBUG_ENC(sde_enc, "\n");
 
 	for (i = 0; i < ARRAY_SIZE(sde_enc->phys_encs); i++) {
 		struct sde_encoder_phys *phys = sde_enc->phys_encs[i];
@@ -227,7 +249,7 @@ static void sde_encoder_destroy(struct drm_encoder *drm_enc)
 	}
 
 	if (sde_enc->num_phys_encs) {
-		DRM_ERROR("Expected num_phys_encs to be 0 not %d\n",
+		SDE_ERROR_ENC(sde_enc, "expected 0 num_phys_encs not %d\n",
 				sde_enc->num_phys_encs);
 	}
 
@@ -249,14 +271,15 @@ static int sde_encoder_virt_atomic_check(
 	int i = 0;
 	int ret = 0;
 
-	DBG("");
-
 	if (!drm_enc || !crtc_state || !conn_state) {
-		DRM_ERROR("Invalid pointer");
+		SDE_ERROR("invalid arg(s), drm_enc %d, crtc/conn state %d/%d\n",
+				drm_enc != 0, crtc_state != 0, conn_state != 0);
 		return -EINVAL;
 	}
 
 	sde_enc = to_sde_encoder_virt(drm_enc);
+	SDE_DEBUG_ENC(sde_enc, "\n");
+
 	priv = drm_enc->dev->dev_private;
 	sde_kms = to_sde_kms(priv->kms);
 	mode = &crtc_state->mode;
@@ -275,8 +298,8 @@ static int sde_encoder_virt_atomic_check(
 				ret = -EINVAL;
 
 		if (ret) {
-			SDE_ERROR("enc %d mode unsupported, phys %d\n",
-					drm_enc->base.id, i);
+			SDE_ERROR_ENC(sde_enc,
+					"mode unsupported, phys idx %d\n", i);
 			break;
 		}
 	}
@@ -305,14 +328,14 @@ static void sde_encoder_virt_mode_set(struct drm_encoder *drm_enc,
 	struct drm_connector *conn = NULL, *conn_iter;
 	int i = 0, ret;
 
-	DBG("");
-
 	if (!drm_enc) {
-		DRM_ERROR("Invalid pointer");
+		SDE_ERROR("invalid encoder\n");
 		return;
 	}
 
 	sde_enc = to_sde_encoder_virt(drm_enc);
+	SDE_DEBUG_ENC(sde_enc, "\n");
+
 	priv = drm_enc->dev->dev_private;
 	sde_kms = to_sde_kms(priv->kms);
 	connector_list = &sde_kms->dev->mode_config.connector_list;
@@ -324,8 +347,7 @@ static void sde_encoder_virt_mode_set(struct drm_encoder *drm_enc,
 			conn = conn_iter;
 
 	if (!conn) {
-		SDE_ERROR("enc %d failed to find attached connector\n",
-				drm_enc->base.id);
+		SDE_ERROR_ENC(sde_enc, "failed to find attached connector\n");
 		return;
 	}
 
@@ -333,8 +355,8 @@ static void sde_encoder_virt_mode_set(struct drm_encoder *drm_enc,
 	ret = sde_rm_reserve(&sde_kms->rm, drm_enc, drm_enc->crtc->state,
 			conn->state, false);
 	if (ret) {
-		SDE_ERROR("enc %d failed to reserve hw resources, ret %d\n",
-				drm_enc->base.id, ret);
+		SDE_ERROR_ENC(sde_enc,
+				"failed to reserve hw resources, %d\n", ret);
 		return;
 	}
 
@@ -351,14 +373,14 @@ static void sde_encoder_virt_enable(struct drm_encoder *drm_enc)
 	struct sde_encoder_virt *sde_enc = NULL;
 	int i = 0;
 
-	DBG("");
-
 	if (!drm_enc) {
-		DRM_ERROR("Invalid pointer");
+		SDE_ERROR("invalid encoder\n");
 		return;
 	}
 
 	sde_enc = to_sde_encoder_virt(drm_enc);
+	SDE_DEBUG_ENC(sde_enc, "\n");
+
 	MSM_EVT(drm_enc->dev, 0, 0);
 
 	bs_set(sde_enc, 1);
@@ -376,7 +398,8 @@ static void sde_encoder_virt_enable(struct drm_encoder *drm_enc)
 			 * the encoder role found at panel probe time
 			 */
 			if (phys->ops.is_master && phys->ops.is_master(phys)) {
-				DBG("phys enc master is now idx %d", i);
+				SDE_DEBUG_ENC(sde_enc,
+						"master is now idx %d\n", i);
 				sde_enc->cur_master = phys;
 			}
 		}
@@ -390,14 +413,14 @@ static void sde_encoder_virt_disable(struct drm_encoder *drm_enc)
 	struct sde_kms *sde_kms;
 	int i = 0;
 
-	DBG("");
-
 	if (!drm_enc) {
-		DRM_ERROR("Invalid pointer");
+		SDE_ERROR("invalid encoder\n");
 		return;
 	}
 
 	sde_enc = to_sde_encoder_virt(drm_enc);
+	SDE_DEBUG_ENC(sde_enc, "\n");
+
 	priv = drm_enc->dev->dev_private;
 	sde_kms = to_sde_kms(priv->kms);
 
@@ -411,7 +434,7 @@ static void sde_encoder_virt_disable(struct drm_encoder *drm_enc)
 	}
 
 	sde_enc->cur_master = NULL;
-	DBG("clear phys enc master");
+	SDE_DEBUG_ENC(sde_enc, "cleared master\n");
 
 	bs_set(sde_enc, 0);
 
@@ -434,8 +457,6 @@ static enum sde_intf sde_encoder_get_intf(struct sde_mdss_cfg *catalog,
 {
 	int i = 0;
 
-	DBG("");
-
 	for (i = 0; i < catalog->intf_count; i++) {
 		if (catalog->intf[i].type == type
 		    && catalog->intf[i].controller_id == controller_id) {
@@ -460,10 +481,8 @@ static void sde_encoder_vblank_callback(struct drm_encoder *drm_enc)
 	struct sde_encoder_virt *sde_enc = NULL;
 	unsigned long lock_flags;
 
-	if (!drm_enc) {
-		DRM_ERROR("Invalid pointer");
+	if (!drm_enc)
 		return;
-	}
 
 	sde_enc = to_sde_encoder_virt(drm_enc);
 
@@ -483,6 +502,11 @@ void sde_encoder_register_vblank_callback(struct drm_encoder *drm_enc,
 
 	enable = vbl_cb ? true : false;
 
+	if (!drm_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+	SDE_DEBUG_ENC(sde_enc, "\n");
 	MSM_EVT(drm_enc->dev, enable, 0);
 
 	spin_lock_irqsave(&sde_enc->spin_lock, lock_flags);
@@ -532,11 +556,12 @@ void sde_encoder_schedule_kickoff(struct drm_encoder *drm_enc,
 	int ret;
 
 	if (!drm_enc) {
-		DRM_ERROR("invalid arguments");
+		SDE_ERROR("invalid encoder\n");
 		return;
 	}
 	sde_enc = to_sde_encoder_virt(drm_enc);
 
+	SDE_DEBUG_ENC(sde_enc, "\n");
 	MSM_EVT(drm_enc->dev, 0, 0);
 
 	spin_lock_irqsave(&sde_enc->spin_lock, lock_flags);
@@ -572,7 +597,8 @@ void sde_encoder_schedule_kickoff(struct drm_encoder *drm_enc,
 				msecs_to_jiffies(WAIT_TIMEOUT_MSEC));
 		spin_unlock_irqrestore(&sde_enc->spin_lock, lock_flags);
 		if (!ret)
-			DBG("wait %u msec timed out", WAIT_TIMEOUT_MSEC);
+			SDE_DEBUG_ENC(sde_enc, "wait %ums timed out\n",
+					WAIT_TIMEOUT_MSEC);
 	}
 
 	/* All phys encs are ready to go, trigger the kickoff */
@@ -595,7 +621,7 @@ static int sde_encoder_virt_add_phys_encs(
 {
 	struct sde_encoder_phys *enc = NULL;
 
-	DBG("");
+	SDE_DEBUG_ENC(sde_enc, "\n");
 
 	/*
 	 * We may create up to NUM_PHYS_ENCODER_TYPES physical encoder types
@@ -603,7 +629,7 @@ static int sde_encoder_virt_add_phys_encs(
 	 */
 	if (sde_enc->num_phys_encs + NUM_PHYS_ENCODER_TYPES >=
 			ARRAY_SIZE(sde_enc->phys_encs)) {
-		DRM_ERROR("Too many physical encoders %d, unable to add\n",
+		SDE_ERROR_ENC(sde_enc, "too many physical encoders %d\n",
 			  sde_enc->num_phys_encs);
 		return -EINVAL;
 	}
@@ -612,7 +638,7 @@ static int sde_encoder_virt_add_phys_encs(
 		enc = sde_encoder_phys_vid_init(params);
 
 		if (IS_ERR_OR_NULL(enc)) {
-			DRM_ERROR("Failed to initialize phys vid enc: %ld\n",
+			SDE_ERROR_ENC(sde_enc, "failed to init vid enc: %ld\n",
 				PTR_ERR(enc));
 			return enc == 0 ? -EINVAL : PTR_ERR(enc);
 		}
@@ -625,7 +651,7 @@ static int sde_encoder_virt_add_phys_encs(
 		enc = sde_encoder_phys_cmd_init(params);
 
 		if (IS_ERR_OR_NULL(enc)) {
-			DRM_ERROR("Failed to initialize phys cmd enc: %ld\n",
+			SDE_ERROR_ENC(sde_enc, "failed to init cmd enc: %ld\n",
 				PTR_ERR(enc));
 			return enc == 0 ? -EINVAL : PTR_ERR(enc);
 		}
@@ -642,10 +668,15 @@ static int sde_encoder_virt_add_phys_enc_wb(struct sde_encoder_virt *sde_enc,
 {
 	struct sde_encoder_phys *enc = NULL;
 
-	DBG("");
+	if (!sde_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return -EINVAL;
+	}
+
+	SDE_DEBUG_ENC(sde_enc, "\n");
 
 	if (sde_enc->num_phys_encs + 1 >= ARRAY_SIZE(sde_enc->phys_encs)) {
-		DRM_ERROR("Too many physical encoders %d, unable to add\n",
+		SDE_ERROR_ENC(sde_enc, "too many physical encoders %d\n",
 			  sde_enc->num_phys_encs);
 		return -EINVAL;
 	}
@@ -653,7 +684,7 @@ static int sde_encoder_virt_add_phys_enc_wb(struct sde_encoder_virt *sde_enc,
 	enc = sde_encoder_phys_wb_init(params);
 
 	if (IS_ERR_OR_NULL(enc)) {
-		DRM_ERROR("Failed to initialize phys wb enc: %ld\n",
+		SDE_ERROR_ENC(sde_enc, "failed to init wb enc: %ld\n",
 			PTR_ERR(enc));
 		return enc == 0 ? -EINVAL : PTR_ERR(enc);
 	}
@@ -678,12 +709,18 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc,
 	};
 	struct sde_enc_phys_init_params phys_params;
 
+	if (!sde_enc || !sde_kms) {
+		SDE_ERROR("invalid arg(s), enc %d kms %d\n",
+				sde_enc != 0, sde_kms != 0);
+		return -EINVAL;
+	}
+
 	memset(&phys_params, 0, sizeof(phys_params));
 	phys_params.sde_kms = sde_kms;
 	phys_params.parent = &sde_enc->base;
 	phys_params.parent_ops = parent_ops;
 
-	DBG("");
+	SDE_DEBUG("\n");
 
 	if (disp_info->intf_type == DRM_MODE_CONNECTOR_DSI) {
 		*drm_enc_mode = DRM_MODE_ENCODER_DSI;
@@ -695,7 +732,7 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc,
 		*drm_enc_mode = DRM_MODE_ENCODER_VIRTUAL;
 		intf_type = INTF_WB;
 	} else {
-		DRM_ERROR("Unsupported display interface type");
+		SDE_ERROR_ENC(sde_enc, "unsupported display interface type\n");
 		return -EINVAL;
 	}
 
@@ -703,7 +740,7 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc,
 
 	sde_enc->display_num_of_h_tiles = disp_info->num_of_h_tiles;
 
-	DBG("dsi_info->num_of_h_tiles %d", disp_info->num_of_h_tiles);
+	SDE_DEBUG("dsi_info->num_of_h_tiles %d\n", disp_info->num_of_h_tiles);
 
 	for (i = 0; i < disp_info->num_of_h_tiles && !ret; i++) {
 		/*
@@ -722,7 +759,7 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc,
 			phys_params.split_role = ENC_ROLE_SOLO;
 		}
 
-		DBG("h_tile_instance %d = %d, split_role %d",
+		SDE_DEBUG("h_tile_instance %d = %d, split_role %d\n",
 				i, controller_id, phys_params.split_role);
 
 		if (intf_type == INTF_WB) {
@@ -731,8 +768,8 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc,
 					sde_kms->catalog,
 					intf_type, controller_id);
 			if (phys_params.wb_idx == WB_MAX) {
-				DRM_ERROR(
-					"Error: could not get writeback: type %d, id %d\n",
+				SDE_ERROR_ENC(sde_enc,
+					"could not get wb: type %d, id %d\n",
 					intf_type, controller_id);
 				ret = -EINVAL;
 			}
@@ -742,8 +779,8 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc,
 					sde_kms->catalog, intf_type,
 					controller_id);
 			if (phys_params.intf_idx == INTF_MAX) {
-				DRM_ERROR(
-					"Error: could not get writeback: type %d, id %d\n",
+				SDE_ERROR_ENC(sde_enc,
+					"could not get wb: type %d, id %d\n",
 					intf_type, controller_id);
 				ret = -EINVAL;
 			}
@@ -759,7 +796,8 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc,
 						sde_enc,
 						&phys_params);
 			if (ret)
-				DRM_ERROR("Failed to add phys encs\n");
+				SDE_ERROR_ENC(sde_enc,
+						"failed to add phys encs\n");
 		}
 	}
 
@@ -777,8 +815,6 @@ static struct drm_encoder *sde_encoder_virt_init(
 	int drm_enc_mode = DRM_MODE_ENCODER_NONE;
 	int ret = 0;
 
-	DBG("");
-
 	sde_enc = kzalloc(sizeof(*sde_enc), GFP_KERNEL);
 	if (!sde_enc) {
 		ret = -ENOMEM;
@@ -799,12 +835,12 @@ static struct drm_encoder *sde_encoder_virt_init(
 	sde_enc->pending_kickoff_mask = 0;
 	init_waitqueue_head(&sde_enc->pending_kickoff_wq);
 
-	DBG("Created encoder");
+	SDE_DEBUG_ENC(sde_enc, "created\n");
 
 	return drm_enc;
 
 fail:
-	DRM_ERROR("Failed to create encoder\n");
+	SDE_ERROR("failed to create encoder\n");
 	if (drm_enc)
 		sde_encoder_destroy(drm_enc);
 
@@ -816,13 +852,12 @@ int sde_encoder_wait_for_commit_done(struct drm_encoder *drm_enc)
 	struct sde_encoder_virt *sde_enc = NULL;
 	int i, ret = 0;
 
-	DBG("");
-
 	if (!drm_enc) {
-		DRM_ERROR("Invalid pointer");
+		SDE_ERROR("invalid encoder\n");
 		return -EINVAL;
 	}
 	sde_enc = to_sde_encoder_virt(drm_enc);
+	SDE_DEBUG_ENC(sde_enc, "\n");
 
 	for (i = 0; i < sde_enc->num_phys_encs; i++) {
 		struct sde_encoder_phys *phys = sde_enc->phys_encs[i];
@@ -847,27 +882,28 @@ void sde_encoders_init(struct drm_device *dev)
 	u32 i = 0;
 	u32 num_displays = 0;
 
-	DBG("");
+	SDE_DEBUG("\n");
 
 	if (!dev || !dev->dev_private) {
-		DRM_ERROR("Invalid pointer");
+		SDE_ERROR("invalid device %d\n", dev != 0);
 		return;
 	}
 
 	priv = dev->dev_private;
 	priv->num_encoders = 0;
 	if (!priv->kms || !priv->dm) {
-		DRM_ERROR("Invalid pointer");
+		SDE_ERROR("invalid priv pointer, kms %d dm %d\n",
+				priv->kms != 0, priv->dm != 0);
 		return;
 	}
 	disp_man = priv->dm;
 
 	num_displays = display_manager_get_count(disp_man);
-	DBG("num_displays %d", num_displays);
+	SDE_DEBUG("num_displays %d\n", num_displays);
 
 	if (num_displays > ARRAY_SIZE(priv->encoders)) {
 		num_displays = ARRAY_SIZE(priv->encoders);
-		DRM_ERROR("Too many displays found, capping to %d",
+		SDE_ERROR("too many displays found, capping to %d\n",
 				num_displays);
 	}
 
@@ -878,19 +914,19 @@ void sde_encoders_init(struct drm_device *dev)
 
 		ret = display_manager_get_info_by_index(disp_man, i, &info);
 		if (ret) {
-			DRM_ERROR("Failed to get display info, %d", ret);
+			SDE_ERROR("failed to get display info, %d\n", ret);
 			return;
 		}
 
 		enc = sde_encoder_virt_init(dev, &info);
 		if (IS_ERR_OR_NULL(enc)) {
-			DRM_ERROR("Encoder initialization failed");
+			SDE_ERROR("encoder initialization failed\n");
 			return;
 		}
 
 		ret = display_manager_drm_init_by_index(disp_man, i, enc);
 		if (ret) {
-			DRM_ERROR("Display drm_init failed, %d", ret);
+			SDE_ERROR("display drm_init failed, %d\n", ret);
 			return;
 		}
 
diff --git a/drivers/gpu/drm/msm/sde/sde_encoder_phys_cmd.c b/drivers/gpu/drm/msm/sde/sde_encoder_phys_cmd.c
index 95011d963528..477afcf91aea 100644
--- a/drivers/gpu/drm/msm/sde/sde_encoder_phys_cmd.c
+++ b/drivers/gpu/drm/msm/sde/sde_encoder_phys_cmd.c
@@ -12,6 +12,7 @@
  *
  */
 
+#define pr_fmt(fmt)	"[drm:%s:%d] " fmt, __func__, __LINE__
 #include <linux/jiffies.h>
 
 #include "sde_encoder_phys.h"
@@ -19,6 +20,16 @@
 #include "sde_core_irq.h"
 #include "sde_formats.h"
 
+#define SDE_DEBUG_CMDENC(e, fmt, ...) SDE_DEBUG("enc%d intf%d " fmt, \
+		(e) && (e)->base.parent ? \
+		(e)->base.parent->base.id : -1, \
+		(e) ? (e)->intf_idx - INTF_0 : -1, ##__VA_ARGS__)
+
+#define SDE_ERROR_CMDENC(e, fmt, ...) SDE_ERROR("enc%d intf%d " fmt, \
+		(e) && (e)->base.parent ? \
+		(e)->base.parent->base.id : -1, \
+		(e) ? (e)->intf_idx - INTF_0 : -1, ##__VA_ARGS__)
+
 #define to_sde_encoder_phys_cmd(x) \
 	container_of(x, struct sde_encoder_phys_cmd, base)
 
@@ -45,6 +56,8 @@ static bool sde_encoder_phys_cmd_mode_fixup(
 		const struct drm_display_mode *mode,
 		struct drm_display_mode *adj_mode)
 {
+	if (phys_enc)
+		SDE_DEBUG_CMDENC(to_sde_encoder_phys_cmd(phys_enc), "\n");
 	return true;
 }
 
@@ -59,8 +72,13 @@ static void sde_encoder_phys_cmd_mode_set(
 	struct sde_rm_hw_iter iter;
 	int i, instance;
 
+	if (!phys_enc || !mode || !adj_mode) {
+		SDE_ERROR("invalid arg(s), enc %d mode %d adj_mode %d\n",
+				phys_enc != 0, mode != 0, adj_mode != 0);
+		return;
+	}
 	phys_enc->cached_mode = *adj_mode;
-	SDE_DEBUG("intf %d, caching mode:\n", cmd_enc->intf_idx);
+	SDE_DEBUG_CMDENC(cmd_enc, "caching mode:\n");
 	drm_mode_debug_printmodeline(adj_mode);
 
 	instance = phys_enc->split_role == ENC_ROLE_SLAVE ? 1 : 0;
@@ -74,7 +92,8 @@ static void sde_encoder_phys_cmd_mode_set(
 	}
 
 	if (IS_ERR_OR_NULL(phys_enc->hw_ctl)) {
-		SDE_ERROR("failed init ctl: %ld\n", PTR_ERR(phys_enc->hw_ctl));
+		SDE_ERROR_CMDENC(cmd_enc, "failed to init ctl: %ld\n",
+				PTR_ERR(phys_enc->hw_ctl));
 		phys_enc->hw_ctl = NULL;
 		return;
 	}
@@ -88,7 +107,7 @@ static void sde_encoder_phys_cmd_mode_set(
 	}
 
 	if (IS_ERR_OR_NULL(cmd_enc->hw_pp)) {
-		SDE_ERROR("failed init pingpong: %ld\n",
+		SDE_ERROR_CMDENC(cmd_enc, "failed to init pingpong: %ld\n",
 				PTR_ERR(cmd_enc->hw_pp));
 		cmd_enc->hw_pp = NULL;
 		phys_enc->hw_ctl = NULL;
@@ -100,9 +119,13 @@ static void sde_encoder_phys_cmd_mode_set(
 static void sde_encoder_phys_cmd_pp_tx_done_irq(void *arg, int irq_idx)
 {
 	struct sde_encoder_phys_cmd *cmd_enc = arg;
-	struct sde_encoder_phys *phys_enc = &cmd_enc->base;
+	struct sde_encoder_phys *phys_enc;
 	int new_pending_cnt;
 
+	if (!cmd_enc)
+		return;
+
+	phys_enc = &cmd_enc->base;
 	new_pending_cnt = atomic_dec_return(&cmd_enc->pending_cnt);
 	MSM_EVT(DEV(phys_enc), cmd_enc->hw_pp->idx, new_pending_cnt);
 
@@ -119,6 +142,9 @@ static void sde_encoder_phys_cmd_pp_rd_ptr_irq(void *arg, int irq_idx)
 	struct sde_encoder_phys_cmd *cmd_enc = arg;
 	struct sde_encoder_phys *phys_enc = &cmd_enc->base;
 
+	if (!cmd_enc)
+		return;
+
 	phys_enc->parent_ops.handle_vblank_virt(phys_enc->parent);
 }
 
@@ -134,13 +160,17 @@ static int sde_encoder_phys_cmd_register_pp_irq(
 	struct sde_irq_callback irq_cb;
 	int ret = 0;
 
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return -EINVAL;
+	}
 	*irq_idx = sde_core_irq_idx_lookup(phys_enc->sde_kms, intr_type,
 			cmd_enc->hw_pp->idx);
 	if (*irq_idx < 0) {
-		DRM_ERROR(
-			"Failed to lookup IRQ index for %s with pp=%d",
+		SDE_ERROR_CMDENC(cmd_enc,
+			"failed to lookup IRQ index for %s with pp=%d\n",
 			irq_name,
-			cmd_enc->hw_pp->idx);
+			cmd_enc->hw_pp->idx - PINGPONG_0);
 		return -EINVAL;
 	}
 
@@ -149,16 +179,18 @@ static int sde_encoder_phys_cmd_register_pp_irq(
 	ret = sde_core_irq_register_callback(phys_enc->sde_kms, *irq_idx,
 			&irq_cb);
 	if (ret) {
-		DRM_ERROR("Failed to register IRQ callback %s", irq_name);
+		SDE_ERROR_CMDENC(cmd_enc,
+				"failed to register IRQ callback %s\n",
+				irq_name);
 		return ret;
 	}
 
 	ret = sde_core_irq_enable(phys_enc->sde_kms, irq_idx, 1);
 	if (ret) {
-		DRM_ERROR(
-			"Failed to enable IRQ for %s, pp %d, irq_idx=%d",
+		SDE_ERROR_CMDENC(cmd_enc,
+			"failed to enable IRQ for %s, pp %d, irq_idx %d\n",
 			irq_name,
-			cmd_enc->hw_pp->idx,
+			cmd_enc->hw_pp->idx - PINGPONG_0,
 			*irq_idx);
 		*irq_idx = -EINVAL;
 
@@ -168,9 +200,9 @@ static int sde_encoder_phys_cmd_register_pp_irq(
 		return ret;
 	}
 
-	DBG("registered IRQ %s for pp %d, irq_idx=%d",
+	SDE_DEBUG_CMDENC(cmd_enc, "registered IRQ %s for pp %d, irq_idx %d\n",
 			irq_name,
-			cmd_enc->hw_pp->idx,
+			cmd_enc->hw_pp->idx - PINGPONG_0,
 			*irq_idx);
 
 	return ret;
@@ -183,12 +215,17 @@ static int sde_encoder_phys_cmd_unregister_pp_irq(
 	struct sde_encoder_phys_cmd *cmd_enc =
 			to_sde_encoder_phys_cmd(phys_enc);
 
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return -EINVAL;
+	}
+
 	sde_core_irq_disable(phys_enc->sde_kms, &irq_idx, 1);
 	sde_core_irq_register_callback(phys_enc->sde_kms, irq_idx,
 			NULL);
 
-	DBG("unregister IRQ for pp %d, irq_idx=%d\n",
-			cmd_enc->hw_pp->idx,
+	SDE_DEBUG_CMDENC(cmd_enc, "unregistered IRQ for pp %d, irq_idx %d\n",
+			cmd_enc->hw_pp->idx - PINGPONG_0,
 			irq_idx);
 
 	return 0;
@@ -206,11 +243,16 @@ static void sde_encoder_phys_cmd_tearcheck_config(
 	struct msm_drm_private *priv;
 	struct sde_kms *sde_kms;
 
-	DBG("intf %d, pp %d", cmd_enc->intf_idx, cmd_enc->hw_pp->idx);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+
+	SDE_DEBUG_CMDENC(cmd_enc, "pp %d\n", cmd_enc->hw_pp->idx - PINGPONG_0);
 
 	if (!cmd_enc->hw_pp->ops.setup_tearcheck ||
 		!cmd_enc->hw_pp->ops.enable_tearcheck) {
-		DBG("tearcheck unsupported");
+		SDE_DEBUG_CMDENC(cmd_enc, "tearcheck not supported\n");
 		return;
 	}
 
@@ -227,7 +269,7 @@ static void sde_encoder_phys_cmd_tearcheck_config(
 	 */
 	vsync_hz = sde_power_clk_get_rate(&priv->phandle, "vsync_clk");
 	if (!vsync_hz) {
-		DBG("invalid vsync clock rate");
+		SDE_DEBUG_CMDENC(cmd_enc, "invalid vsync clock rate\n");
 		return;
 	}
 
@@ -246,16 +288,21 @@ static void sde_encoder_phys_cmd_tearcheck_config(
 	tc_cfg.start_pos = mode->vdisplay;
 	tc_cfg.rd_ptr_irq = mode->vdisplay + 1;
 
-	DBG("tc %d vsync_clk_speed_hz %u mode->vtotal %u mode->vrefresh %u",
-		cmd_enc->hw_pp->idx, vsync_hz, mode->vtotal, mode->vrefresh);
-	DBG("tc %d enable %u start_pos %u rd_ptr_irq %u",
-		tc_enable, cmd_enc->hw_pp->idx, tc_cfg.start_pos,
+	SDE_DEBUG_CMDENC(cmd_enc,
+		"tc %d vsync_clk_speed_hz %u vtotal %u vrefresh %u\n",
+		cmd_enc->hw_pp->idx - PINGPONG_0, vsync_hz,
+		mode->vtotal, mode->vrefresh);
+	SDE_DEBUG_CMDENC(cmd_enc,
+		"tc %d enable %u start_pos %u rd_ptr_irq %u\n",
+		cmd_enc->hw_pp->idx - PINGPONG_0, tc_enable, tc_cfg.start_pos,
 		tc_cfg.rd_ptr_irq);
-	DBG("tc %d hw_vsync_mode %u vsync_count %u vsync_init_val %u",
-		cmd_enc->hw_pp->idx, tc_cfg.hw_vsync_mode, tc_cfg.vsync_count,
-		tc_cfg.vsync_init_val);
-	DBG("tc %d sync_cfgheight %u sync_thresh_start %u sync_thresh_cont %u",
-		cmd_enc->hw_pp->idx, tc_cfg.sync_cfg_height,
+	SDE_DEBUG_CMDENC(cmd_enc,
+		"tc %d hw_vsync_mode %u vsync_count %u vsync_init_val %u\n",
+		cmd_enc->hw_pp->idx - PINGPONG_0, tc_cfg.hw_vsync_mode,
+		tc_cfg.vsync_count, tc_cfg.vsync_init_val);
+	SDE_DEBUG_CMDENC(cmd_enc,
+		"tc %d cfgheight %u thresh_start %u thresh_cont %u\n",
+		cmd_enc->hw_pp->idx - PINGPONG_0, tc_cfg.sync_cfg_height,
 		tc_cfg.sync_threshold_start, tc_cfg.sync_threshold_continue);
 
 	cmd_enc->hw_pp->ops.setup_tearcheck(cmd_enc->hw_pp, &tc_cfg);
@@ -269,11 +316,14 @@ static void sde_encoder_phys_cmd_pingpong_config(
 		to_sde_encoder_phys_cmd(phys_enc);
 	struct sde_hw_intf_cfg intf_cfg = { 0 };
 
-	if (!phys_enc->hw_ctl->ops.setup_intf_cfg)
+	if (!phys_enc || !phys_enc->hw_ctl ||
+			!phys_enc->hw_ctl->ops.setup_intf_cfg) {
+		SDE_ERROR("invalid arg(s), enc %d\n", phys_enc != 0);
 		return;
+	}
 
-	DBG("intf %d pp %d, enabling mode:", cmd_enc->intf_idx,
-			cmd_enc->hw_pp->idx);
+	SDE_DEBUG_CMDENC(cmd_enc, "pp %d, enabling mode:\n",
+			cmd_enc->hw_pp->idx - PINGPONG_0);
 	drm_mode_debug_printmodeline(&phys_enc->cached_mode);
 
 	intf_cfg.intf = cmd_enc->intf_idx;
@@ -293,7 +343,11 @@ static void sde_encoder_phys_cmd_split_config(
 	struct sde_hw_mdp *hw_mdptop = phys_enc->hw_mdptop;
 	struct split_pipe_cfg cfg = { 0 };
 
-	DBG("enable %d", enable);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+	SDE_DEBUG_CMDENC(cmd_enc, "enable %d\n", enable);
 
 	cfg.en = enable;
 	cfg.mode = INTF_MODE_CMD;
@@ -312,7 +366,11 @@ static int sde_encoder_phys_cmd_control_vblank_irq(
 		to_sde_encoder_phys_cmd(phys_enc);
 	int ret = 0;
 
-	DBG("enable %d", enable);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return -EINVAL;
+	}
+	SDE_DEBUG_CMDENC(cmd_enc, "enable %d\n", enable);
 
 	/* Slave encoders don't report vblank */
 	if (sde_encoder_phys_cmd_is_master(phys_enc)) {
@@ -328,8 +386,9 @@ static int sde_encoder_phys_cmd_control_vblank_irq(
 	}
 
 	if (ret)
-		DRM_ERROR("control vblank irq error %d, enable %d\n", ret,
-				enable);
+		SDE_ERROR_CMDENC(cmd_enc,
+				"control vblank irq error %d, enable %d\n",
+				ret, enable);
 
 	return ret;
 }
@@ -338,14 +397,18 @@ static void sde_encoder_phys_cmd_enable(struct sde_encoder_phys *phys_enc)
 {
 	struct sde_encoder_phys_cmd *cmd_enc =
 		to_sde_encoder_phys_cmd(phys_enc);
-	struct sde_hw_ctl *ctl = phys_enc->hw_ctl;
+	struct sde_hw_ctl *ctl;
 	u32 flush_mask;
 	int ret = 0;
 
-	if (WARN_ON(phys_enc->enable_state == SDE_ENC_ENABLED))
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
 		return;
+	}
+	SDE_DEBUG_CMDENC(cmd_enc, "pp %d\n", cmd_enc->hw_pp->idx - PINGPONG_0);
 
-	DBG("intf %d, pp %d", cmd_enc->intf_idx, cmd_enc->hw_pp->idx);
+	if (WARN_ON(phys_enc->enable_state == SDE_ENC_ENABLED))
+		return;
 
 	/*
 	 * Only master configures master/slave configuration, so no slave check
@@ -375,12 +438,13 @@ static void sde_encoder_phys_cmd_enable(struct sde_encoder_phys *phys_enc)
 		return;
 	}
 
+	ctl = phys_enc->hw_ctl;
 	ctl->ops.get_bitmask_intf(ctl, &flush_mask, cmd_enc->intf_idx);
 	ctl->ops.update_pending_flush(ctl, flush_mask);
 	phys_enc->enable_state = SDE_ENC_ENABLED;
 
-	DBG("Update pending flush CTL_ID %d flush_mask %x, INTF %d",
-			ctl->idx, flush_mask, cmd_enc->intf_idx);
+	SDE_DEBUG_CMDENC(cmd_enc, "update pending flush ctl %d flush_mask %x\n",
+			ctl->idx - CTL_0, flush_mask);
 }
 
 static void sde_encoder_phys_cmd_disable(struct sde_encoder_phys *phys_enc)
@@ -388,7 +452,11 @@ static void sde_encoder_phys_cmd_disable(struct sde_encoder_phys *phys_enc)
 	struct sde_encoder_phys_cmd *cmd_enc =
 		to_sde_encoder_phys_cmd(phys_enc);
 
-	DBG("intf %d, pp %d", cmd_enc->intf_idx, cmd_enc->hw_pp->idx);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+	SDE_DEBUG_CMDENC(cmd_enc, "pp %d\n", cmd_enc->hw_pp->idx - PINGPONG_0);
 
 	if (WARN_ON(phys_enc->enable_state == SDE_ENC_DISABLED))
 		return;
@@ -407,6 +475,10 @@ static void sde_encoder_phys_cmd_destroy(struct sde_encoder_phys *phys_enc)
 	struct sde_encoder_phys_cmd *cmd_enc =
 		to_sde_encoder_phys_cmd(phys_enc);
 
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
 	kfree(cmd_enc);
 }
 
@@ -418,7 +490,11 @@ static void sde_encoder_phys_cmd_get_hw_resources(
 	struct sde_encoder_phys_cmd *cmd_enc =
 		to_sde_encoder_phys_cmd(phys_enc);
 
-	DBG("intf %d", cmd_enc->intf_idx);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+	SDE_DEBUG_CMDENC(cmd_enc, "\n");
 	hw_res->intfs[cmd_enc->intf_idx - INTF_0] = INTF_MODE_CMD;
 }
 
@@ -442,7 +518,11 @@ static void sde_encoder_phys_cmd_prepare_for_kickoff(
 			to_sde_encoder_phys_cmd(phys_enc);
 	int new_pending_cnt;
 
-	DBG("intf %d, pp %d", cmd_enc->intf_idx, cmd_enc->hw_pp->idx);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+	SDE_DEBUG_CMDENC(cmd_enc, "pp %d\n", cmd_enc->hw_pp->idx - PINGPONG_0);
 
 	/*
 	 * Mark kickoff request as outstanding. If there are more than one,
@@ -452,8 +532,9 @@ static void sde_encoder_phys_cmd_prepare_for_kickoff(
 	*need_to_wait = new_pending_cnt != 1;
 
 	if (*need_to_wait)
-		SDE_DEBUG("intf %d pp %d needs to wait, new_pending_cnt %d",
-				cmd_enc->intf_idx, cmd_enc->hw_pp->idx,
+		SDE_DEBUG_CMDENC(cmd_enc,
+				"pp %d needs to wait, new_pending_cnt %d",
+				cmd_enc->hw_pp->idx - PINGPONG_0,
 				new_pending_cnt);
 	MSM_EVT(DEV(phys_enc), cmd_enc->hw_pp->idx, new_pending_cnt);
 }
@@ -488,11 +569,12 @@ struct sde_encoder_phys *sde_encoder_phys_cmd_init(
 	struct sde_hw_mdp *hw_mdp;
 	int ret = 0;
 
-	DBG("intf %d", p->intf_idx);
+	SDE_DEBUG("intf %d\n", p->intf_idx - INTF_0);
 
 	cmd_enc = kzalloc(sizeof(*cmd_enc), GFP_KERNEL);
 	if (!cmd_enc) {
 		ret = -ENOMEM;
+		SDE_ERROR("failed to allocate\n");
 		goto fail;
 	}
 	phys_enc = &cmd_enc->base;
@@ -521,7 +603,7 @@ struct sde_encoder_phys *sde_encoder_phys_cmd_init(
 
 	init_waitqueue_head(&cmd_enc->pp_tx_done_wq);
 
-	DBG("Created sde_encoder_phys_cmd for intf %d", cmd_enc->intf_idx);
+	SDE_DEBUG_CMDENC(cmd_enc, "created\n");
 
 	return phys_enc;
 
diff --git a/drivers/gpu/drm/msm/sde/sde_encoder_phys_vid.c b/drivers/gpu/drm/msm/sde/sde_encoder_phys_vid.c
index 0432b04d4a81..9f1127349b1e 100644
--- a/drivers/gpu/drm/msm/sde/sde_encoder_phys_vid.c
+++ b/drivers/gpu/drm/msm/sde/sde_encoder_phys_vid.c
@@ -10,6 +10,7 @@
  * GNU General Public License for more details.
  */
 
+#define pr_fmt(fmt)	"[drm:%s:%d] " fmt, __func__, __LINE__
 #include <linux/jiffies.h>
 
 #include "sde_encoder_phys.h"
@@ -17,6 +18,18 @@
 #include "sde_core_irq.h"
 #include "sde_formats.h"
 
+#define SDE_DEBUG_VIDENC(e, fmt, ...) SDE_DEBUG("enc%d intf%d " fmt, \
+		(e) && (e)->base.parent ? \
+		(e)->base.parent->base.id : -1, \
+		(e) && (e)->hw_intf ? \
+		(e)->hw_intf->idx - INTF_0 : -1, ##__VA_ARGS__)
+
+#define SDE_ERROR_VIDENC(e, fmt, ...) SDE_ERROR("enc%d intf%d " fmt, \
+		(e) && (e)->base.parent ? \
+		(e)->base.parent->base.id : -1, \
+		(e) && (e)->hw_intf ? \
+		(e)->hw_intf->idx - INTF_0 : -1, ##__VA_ARGS__)
+
 #define VBLANK_TIMEOUT msecs_to_jiffies(100)
 
 #define to_sde_encoder_phys_vid(x) \
@@ -42,11 +55,15 @@ static void sde_encoder_phys_vid_wait_for_vblank(
 {
 	int rc = 0;
 
-	DBG("intf %d", vid_enc->hw_intf->idx);
+	if (!vid_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+	SDE_DEBUG_VIDENC(vid_enc, "\n");
 	rc = wait_for_completion_timeout(&vid_enc->vblank_completion,
 			VBLANK_TIMEOUT);
 	if (rc == 0)
-		DRM_ERROR("timed out waiting for vblank irq\n");
+		SDE_ERROR_VIDENC(vid_enc, "timed out waiting for vblank irq\n");
 }
 
 static void drm_mode_to_intf_timing_params(
@@ -143,26 +160,29 @@ static u32 programmable_fetch_get_num_lines(
 	u32 actual_vfp_lines = 0;
 
 	/* Fetch must be outside active lines, otherwise undefined. */
-
 	if (start_of_frame_lines >= worst_case_needed_lines) {
-		DBG("Programmable fetch is not needed due to large vbp+vsw");
+		SDE_DEBUG_VIDENC(vid_enc,
+				"prog fetch is not needed, large vbp+vsw\n");
 		actual_vfp_lines = 0;
 	} else if (timing->v_front_porch < needed_vfp_lines) {
 		/* Warn fetch needed, but not enough porch in panel config */
 		pr_warn_once
 			("low vbp+vfp may lead to perf issues in some cases\n");
-		DBG("Less vfp than fetch requires, using entire vfp");
+		SDE_DEBUG_VIDENC(vid_enc,
+				"less vfp than fetch req, using entire vfp\n");
 		actual_vfp_lines = timing->v_front_porch;
 	} else {
-		DBG("Room in vfp for needed prefetch");
+		SDE_DEBUG_VIDENC(vid_enc, "room in vfp for needed prefetch\n");
 		actual_vfp_lines = needed_vfp_lines;
 	}
 
-	DBG("v_front_porch %u v_back_porch %u vsync_pulse_width %u",
-	    timing->v_front_porch, timing->v_back_porch,
-	    timing->vsync_pulse_width);
-	DBG("wc_lines %u needed_vfp_lines %u actual_vfp_lines %u",
-	    worst_case_needed_lines, needed_vfp_lines, actual_vfp_lines);
+	SDE_DEBUG_VIDENC(vid_enc,
+		"v_front_porch %u v_back_porch %u vsync_pulse_width %u\n",
+		timing->v_front_porch, timing->v_back_porch,
+		timing->vsync_pulse_width);
+	SDE_DEBUG_VIDENC(vid_enc,
+		"wc_lines %u needed_vfp_lines %u actual_vfp_lines %u\n",
+		worst_case_needed_lines, needed_vfp_lines, actual_vfp_lines);
 
 	return actual_vfp_lines;
 }
@@ -202,8 +222,9 @@ static void programmable_fetch_config(struct sde_encoder_phys *phys_enc,
 		f.fetch_start = vfp_fetch_start_vsync_counter;
 	}
 
-	DBG("vfp_fetch_lines %u vfp_fetch_start_vsync_counter %u",
-	    vfp_fetch_lines, vfp_fetch_start_vsync_counter);
+	SDE_DEBUG_VIDENC(vid_enc,
+		"vfp_fetch_lines %u vfp_fetch_start_vsync_counter %u\n",
+		vfp_fetch_lines, vfp_fetch_start_vsync_counter);
 
 	spin_lock_irqsave(&phys_enc->spin_lock, lock_flags);
 	vid_enc->hw_intf->ops.setup_prg_fetch(vid_enc->hw_intf, &f);
@@ -215,7 +236,8 @@ static bool sde_encoder_phys_vid_mode_fixup(
 		const struct drm_display_mode *mode,
 		struct drm_display_mode *adj_mode)
 {
-	DBG("");
+	if (phys_enc)
+		SDE_DEBUG_VIDENC(to_sde_encoder_phys_vid(phys_enc), "\n");
 
 	/*
 	 * Modifying mode has consequences when the mode comes back to us
@@ -235,13 +257,14 @@ static void sde_encoder_phys_vid_setup_timing_engine(
 	unsigned long lock_flags;
 	struct sde_hw_intf_cfg intf_cfg = { 0 };
 
-	if (WARN_ON(!vid_enc->hw_intf->ops.setup_timing_gen))
-		return;
-
-	if (WARN_ON(!phys_enc->hw_ctl->ops.setup_intf_cfg))
+	if (!phys_enc ||
+			!vid_enc->hw_intf->ops.setup_timing_gen ||
+			!phys_enc->hw_ctl->ops.setup_intf_cfg) {
+		SDE_ERROR("invalid encoder %d\n", phys_enc != 0);
 		return;
+	}
 
-	DBG("intf %d, enabling mode:", vid_enc->hw_intf->idx);
+	SDE_DEBUG_VIDENC(vid_enc, "enabling mode:\n");
 	drm_mode_debug_printmodeline(&mode);
 
 	if (phys_enc->split_role != ENC_ROLE_SOLO) {
@@ -250,16 +273,17 @@ static void sde_encoder_phys_vid_setup_timing_engine(
 		mode.hsync_start >>= 1;
 		mode.hsync_end >>= 1;
 
-		DBG("split_role %d, halve horizontal: %d %d %d %d",
-				phys_enc->split_role,
-				mode.hdisplay, mode.htotal,
-				mode.hsync_start, mode.hsync_end);
+		SDE_DEBUG_VIDENC(vid_enc,
+			"split_role %d, halve horizontal %d %d %d %d\n",
+			phys_enc->split_role,
+			mode.hdisplay, mode.htotal,
+			mode.hsync_start, mode.hsync_end);
 	}
 
 	drm_mode_to_intf_timing_params(vid_enc, &mode, &timing_params);
 
 	fmt = sde_get_sde_format(fmt_fourcc);
-	DBG("fmt_fourcc %d", fmt_fourcc);
+	SDE_DEBUG_VIDENC(vid_enc, "fmt_fourcc 0x%X\n", fmt_fourcc);
 
 	intf_cfg.intf = vid_enc->hw_intf->idx;
 	intf_cfg.wb = SDE_NONE;
@@ -279,15 +303,19 @@ static void sde_encoder_phys_vid_setup_timing_engine(
 static void sde_encoder_phys_vid_vblank_irq(void *arg, int irq_idx)
 {
 	struct sde_encoder_phys_vid *vid_enc = arg;
-	struct sde_encoder_phys *phys_enc = &vid_enc->base;
+	struct sde_encoder_phys *phys_enc;
+
+	if (!vid_enc)
+		return;
 
+	phys_enc = &vid_enc->base;
 	phys_enc->parent_ops.handle_vblank_virt(phys_enc->parent);
 
 	/* signal VBLANK completion */
 	complete_all(&vid_enc->vblank_completion);
 }
 
-static void sde_encoder_phys_vid_split_config(
+static void _sde_encoder_phys_vid_split_config(
 		struct sde_encoder_phys *phys_enc, bool enable)
 {
 	struct sde_encoder_phys_vid *vid_enc =
@@ -295,7 +323,7 @@ static void sde_encoder_phys_vid_split_config(
 	struct sde_hw_mdp *hw_mdptop = phys_enc->hw_mdptop;
 	struct split_pipe_cfg cfg = { 0 };
 
-	DBG("enable %d", enable);
+	SDE_DEBUG_VIDENC(vid_enc, "enable %d\n", enable);
 
 	cfg.en = enable;
 	cfg.mode = INTF_MODE_VIDEO;
@@ -319,12 +347,16 @@ static int sde_encoder_phys_vid_register_irq(struct sde_encoder_phys *phys_enc)
 	struct sde_irq_callback irq_cb;
 	int ret = 0;
 
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return -EINVAL;
+	}
+
 	vid_enc->irq_idx = sde_core_irq_idx_lookup(phys_enc->sde_kms,
 			SDE_IRQ_TYPE_INTF_VSYNC, vid_enc->hw_intf->idx);
 	if (vid_enc->irq_idx < 0) {
-		DRM_ERROR(
-			"Failed to lookup IRQ index for INTF_VSYNC with intf=%d\n",
-			vid_enc->hw_intf->idx);
+		SDE_ERROR_VIDENC(vid_enc,
+				"failed to lookup IRQ index for INTF_VSYNC\n");
 		return -EINVAL;
 	}
 
@@ -333,15 +365,15 @@ static int sde_encoder_phys_vid_register_irq(struct sde_encoder_phys *phys_enc)
 	ret = sde_core_irq_register_callback(phys_enc->sde_kms,
 			vid_enc->irq_idx, &irq_cb);
 	if (ret) {
-		DRM_ERROR("failed to register IRQ callback INTF_VSYNC");
+		SDE_ERROR_VIDENC(vid_enc,
+				"failed to register IRQ callback INTF_VSYNC");
 		return ret;
 	}
 
 	ret = sde_core_irq_enable(phys_enc->sde_kms, &vid_enc->irq_idx, 1);
 	if (ret) {
-		DRM_ERROR(
-			"failed to enable IRQ for INTF_VSYNC, intf %d, irq_idx=%d",
-				vid_enc->hw_intf->idx,
+		SDE_ERROR_VIDENC(vid_enc,
+			"enable IRQ for INTF_VSYNC failed, irq_idx %d\n",
 				vid_enc->irq_idx);
 		vid_enc->irq_idx = -EINVAL;
 
@@ -351,9 +383,7 @@ static int sde_encoder_phys_vid_register_irq(struct sde_encoder_phys *phys_enc)
 		return ret;
 	}
 
-	DBG("registered IRQ for intf %d, irq_idx=%d",
-			vid_enc->hw_intf->idx,
-			vid_enc->irq_idx);
+	SDE_DEBUG_VIDENC(vid_enc, "registered %d\n", vid_enc->irq_idx);
 
 	return ret;
 }
@@ -364,13 +394,16 @@ static int sde_encoder_phys_vid_unregister_irq(
 	struct sde_encoder_phys_vid *vid_enc =
 			to_sde_encoder_phys_vid(phys_enc);
 
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return -EINVAL;
+	}
+
 	sde_core_irq_register_callback(phys_enc->sde_kms, vid_enc->irq_idx,
 			NULL);
 	sde_core_irq_disable(phys_enc->sde_kms, &vid_enc->irq_idx, 1);
 
-	DBG("unregister IRQ for intf %d, irq_idx=%d",
-			vid_enc->hw_intf->idx,
-			vid_enc->irq_idx);
+	SDE_DEBUG_VIDENC(vid_enc, "unregistered %d\n", vid_enc->irq_idx);
 
 	return 0;
 }
@@ -386,8 +419,13 @@ static void sde_encoder_phys_vid_mode_set(
 	struct sde_rm_hw_iter iter;
 	int i, instance;
 
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+
 	phys_enc->cached_mode = *adj_mode;
-	SDE_DEBUG("intf %d, caching mode:\n", vid_enc->hw_intf->idx);
+	SDE_DEBUG_VIDENC(vid_enc, "caching mode:\n");
 	drm_mode_debug_printmodeline(adj_mode);
 
 	instance = phys_enc->split_role == ENC_ROLE_SLAVE ? 1 : 0;
@@ -401,7 +439,8 @@ static void sde_encoder_phys_vid_mode_set(
 	}
 
 	if (IS_ERR_OR_NULL(phys_enc->hw_ctl)) {
-		SDE_ERROR("failed init ctl: %ld\n", PTR_ERR(phys_enc->hw_ctl));
+		SDE_ERROR_VIDENC(vid_enc, "failed to init ctl, %ld\n",
+				PTR_ERR(phys_enc->hw_ctl));
 		phys_enc->hw_ctl = NULL;
 		return;
 	}
@@ -411,9 +450,16 @@ static int sde_encoder_phys_vid_control_vblank_irq(
 		struct sde_encoder_phys *phys_enc,
 		bool enable)
 {
+	struct sde_encoder_phys_vid *vid_enc =
+		to_sde_encoder_phys_vid(phys_enc);
 	int ret = 0;
 
-	DBG("enable %d", enable);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return -EINVAL;
+	}
+
+	SDE_DEBUG_VIDENC(vid_enc, "enable %d\n", enable);
 
 	/* Slave encoders don't report vblank */
 	if (sde_encoder_phys_vid_is_master(phys_enc)) {
@@ -424,8 +470,9 @@ static int sde_encoder_phys_vid_control_vblank_irq(
 	}
 
 	if (ret)
-		DRM_ERROR("control vblank irq error %d, enable %d\n", ret,
-				enable);
+		SDE_ERROR_VIDENC(vid_enc,
+				"control vblank irq error %d, enable %d\n",
+				ret, enable);
 
 	return ret;
 }
@@ -438,21 +485,24 @@ static void sde_encoder_phys_vid_enable(struct sde_encoder_phys *phys_enc)
 	struct sde_hw_ctl *ctl = phys_enc->hw_ctl;
 	u32 flush_mask = 0;
 
-	if (!vid_enc->hw_intf || !phys_enc->hw_ctl) {
-		SDE_ERROR("invalid hw: intf %pK ctl %pK\n", vid_enc->hw_intf,
-				phys_enc->hw_ctl);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	} else if (!vid_enc->hw_intf || !phys_enc->hw_ctl) {
+		SDE_ERROR("invalid hw_intf %d hw_ctl %d\n",
+				vid_enc->hw_intf != 0, phys_enc->hw_ctl != 0);
 		return;
 	}
 
-	DBG("intf %d", vid_enc->hw_intf->idx);
+	SDE_DEBUG_VIDENC(vid_enc, "\n");
 
 	if (WARN_ON(!vid_enc->hw_intf->ops.enable_timing))
 		return;
 
 	if (phys_enc->split_role == ENC_ROLE_MASTER)
-		sde_encoder_phys_vid_split_config(phys_enc, true);
+		_sde_encoder_phys_vid_split_config(phys_enc, true);
 	else if (phys_enc->split_role == ENC_ROLE_SOLO)
-		sde_encoder_phys_vid_split_config(phys_enc, false);
+		_sde_encoder_phys_vid_split_config(phys_enc, false);
 
 	sde_encoder_phys_vid_setup_timing_engine(phys_enc);
 	sde_encoder_phys_vid_control_vblank_irq(phys_enc, true);
@@ -460,8 +510,8 @@ static void sde_encoder_phys_vid_enable(struct sde_encoder_phys *phys_enc)
 	ctl->ops.get_bitmask_intf(ctl, &flush_mask, intf->idx);
 	ctl->ops.update_pending_flush(ctl, flush_mask);
 
-	DBG("Update pending flush CTL_ID %d flush_mask %x, INTF %d",
-		ctl->idx, flush_mask, intf->idx);
+	SDE_DEBUG_VIDENC(vid_enc, "update pending flush ctl %d flush_mask %x\n",
+		ctl->idx - CTL_0, flush_mask);
 
 	/* ctl_flush & timing engine enable will be triggered by framework */
 	if (phys_enc->enable_state == SDE_ENC_DISABLED)
@@ -474,19 +524,24 @@ static void sde_encoder_phys_vid_disable(struct sde_encoder_phys *phys_enc)
 	struct sde_encoder_phys_vid *vid_enc =
 			to_sde_encoder_phys_vid(phys_enc);
 
-	if (!vid_enc->hw_intf || !phys_enc->hw_ctl) {
-		SDE_ERROR("invalid hw: intf %pK ctl %pK\n", vid_enc->hw_intf,
-				phys_enc->hw_ctl);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	} else if (!vid_enc->hw_intf || !phys_enc->hw_ctl) {
+		SDE_ERROR("invalid hw_intf %d hw_ctl %d\n",
+				vid_enc->hw_intf != 0, phys_enc->hw_ctl != 0);
 		return;
 	}
 
-	DBG("intf %d", vid_enc->hw_intf->idx);
+	SDE_DEBUG_VIDENC(vid_enc, "\n");
 
 	if (WARN_ON(!vid_enc->hw_intf->ops.enable_timing))
 		return;
 
-	if (WARN_ON(phys_enc->enable_state == SDE_ENC_DISABLED))
+	if (phys_enc->enable_state == SDE_ENC_DISABLED) {
+		SDE_ERROR("already disabled\n");
 		return;
+	}
 
 	spin_lock_irqsave(&phys_enc->spin_lock, lock_flags);
 	vid_enc->hw_intf->ops.enable_timing(vid_enc->hw_intf, 0);
@@ -513,7 +568,11 @@ static void sde_encoder_phys_vid_destroy(struct sde_encoder_phys *phys_enc)
 	struct sde_encoder_phys_vid *vid_enc =
 	    to_sde_encoder_phys_vid(phys_enc);
 
-	DBG("intf %d", vid_enc->hw_intf->idx);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+	SDE_DEBUG_VIDENC(vid_enc, "\n");
 	kfree(vid_enc);
 }
 
@@ -525,7 +584,12 @@ static void sde_encoder_phys_vid_get_hw_resources(
 	struct sde_encoder_phys_vid *vid_enc =
 		to_sde_encoder_phys_vid(phys_enc);
 
-	DBG("intf %d", vid_enc->hw_intf->idx);
+	if (!phys_enc || !hw_res || !vid_enc->hw_intf) {
+		SDE_ERROR("invalid arg(s), enc %d hw_res %d conn_state %d\n",
+				phys_enc != 0, hw_res != 0, conn_state != 0);
+		return;
+	}
+	SDE_DEBUG_VIDENC(vid_enc, "\n");
 	hw_res->intfs[vid_enc->hw_intf->idx - INTF_0] = INTF_MODE_VIDEO;
 }
 
@@ -539,15 +603,18 @@ static int sde_encoder_phys_vid_wait_for_commit_done(
 	if (!sde_encoder_phys_vid_is_master(phys_enc))
 		return 0;
 
-	if (phys_enc->enable_state != SDE_ENC_ENABLED)
+	if (phys_enc->enable_state != SDE_ENC_ENABLED) {
+		SDE_ERROR("encoder not enabled\n");
 		return -EWOULDBLOCK;
+	}
 
 	MSM_EVTMSG(DEV(phys_enc), "waiting", 0, 0);
 
 	ret = wait_for_completion_timeout(&vid_enc->vblank_completion,
 			msecs_to_jiffies(WAIT_TIMEOUT_MSEC));
 	if (!ret) {
-		DBG("wait %u msec timed out", WAIT_TIMEOUT_MSEC);
+		SDE_DEBUG_VIDENC(vid_enc, "wait %u ms timed out\n",
+				WAIT_TIMEOUT_MSEC);
 		MSM_EVTMSG(DEV(phys_enc), "wait_timeout", 0, 0);
 		return -ETIMEDOUT;
 	}
@@ -578,7 +645,11 @@ static void sde_encoder_phys_vid_handle_post_kickoff(
 	struct sde_encoder_phys_vid *vid_enc =
 			to_sde_encoder_phys_vid(phys_enc);
 
-	DBG("enable_state %d", phys_enc->enable_state);
+	if (!phys_enc) {
+		SDE_ERROR("invalid encoder\n");
+		return;
+	}
+	SDE_DEBUG_VIDENC(vid_enc, "enable_state %d\n", phys_enc->enable_state);
 
 	/*
 	 * Video mode must flush CTL before enabling timing engine
@@ -624,7 +695,10 @@ struct sde_encoder_phys *sde_encoder_phys_vid_init(
 	struct sde_hw_mdp *hw_mdp;
 	int ret = 0;
 
-	DBG("intf %d", p->intf_idx);
+	if (!p) {
+		ret = -EINVAL;
+		goto fail;
+	}
 
 	vid_enc = kzalloc(sizeof(*vid_enc), GFP_KERNEL);
 	if (!vid_enc) {
@@ -660,10 +734,12 @@ struct sde_encoder_phys *sde_encoder_phys_vid_init(
 
 	if (!vid_enc->hw_intf) {
 		ret = -EINVAL;
-		DRM_ERROR("failed to get hw_intf\n");
+		SDE_ERROR("failed to get hw_intf\n");
 		goto fail;
 	}
 
+	SDE_DEBUG_VIDENC(vid_enc, "\n");
+
 	sde_encoder_phys_vid_init_ops(&phys_enc->ops);
 	phys_enc->parent = p->parent;
 	phys_enc->parent_ops = p->parent_ops;
@@ -679,13 +755,12 @@ struct sde_encoder_phys *sde_encoder_phys_vid_init(
 
 	phys_enc->enable_state = SDE_ENC_DISABLED;
 
-
-	DBG("Created sde_encoder_phys_vid for intf %d", vid_enc->hw_intf->idx);
+	SDE_DEBUG_VIDENC(vid_enc, "created\n");
 
 	return phys_enc;
 
 fail:
-	DRM_ERROR("Failed to create encoder\n");
+	SDE_ERROR("failed to create encoder\n");
 	if (vid_enc)
 		sde_encoder_phys_vid_destroy(phys_enc);