disp: msm: dp: adding prefix for logs

Adding prefixes for error, debug and info
messages in dp files. To enable debug logs
run "echo 0x100 > /sys/module/drm/parameters/debug"

CRs-Fixed: 2493739
Change-Id: Ibf509e837f527be6bff6b7a1c34b0cde2921b388
Signed-off-by: Satya Rama Aditya Pinapala <[email protected]>

msm/dp/dp_audio.c

@@ -3,8 +3,6 @@
  * Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/of_platform.h>
 #include <linux/msm_ext_display.h>
 
@@ -13,6 +11,7 @@
 #include "dp_catalog.h"
 #include "dp_audio.h"
 #include "dp_panel.h"
+#include "dp_debug.h"
 
 struct dp_audio_private {
 	struct platform_device *ext_pdev;
@@ -74,7 +73,7 @@ static void dp_audio_stream_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_1_BIT)
 			| (parity_byte << PARITY_BYTE_1_BIT));
-	pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_1);
@@ -87,7 +86,7 @@ static void dp_audio_stream_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_2_BIT)
 			| (parity_byte << PARITY_BYTE_2_BIT));
-	pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 
 	dp_audio_set_header(catalog, value,
@@ -102,7 +101,7 @@ static void dp_audio_stream_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_3_BIT)
 			| (parity_byte << PARITY_BYTE_3_BIT));
-	pr_debug("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n",
 		value, parity_byte);
 
 	dp_audio_set_header(catalog, value,
@@ -124,7 +123,7 @@ static void dp_audio_timestamp_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_1_BIT)
 			| (parity_byte << PARITY_BYTE_1_BIT));
-	pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
 		value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_1);
@@ -138,7 +137,7 @@ static void dp_audio_timestamp_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_2_BIT)
 			| (parity_byte << PARITY_BYTE_2_BIT));
-	pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_2);
@@ -152,7 +151,7 @@ static void dp_audio_timestamp_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_3_BIT)
 			| (parity_byte << PARITY_BYTE_3_BIT));
-	pr_debug("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_3);
@@ -173,7 +172,7 @@ static void dp_audio_infoframe_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_1_BIT)
 			| (parity_byte << PARITY_BYTE_1_BIT));
-	pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_1);
@@ -187,7 +186,7 @@ static void dp_audio_infoframe_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_2_BIT)
 			| (parity_byte << PARITY_BYTE_2_BIT));
-	pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_2);
@@ -201,7 +200,7 @@ static void dp_audio_infoframe_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_3_BIT)
 			| (parity_byte << PARITY_BYTE_3_BIT));
-	pr_debug("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n",
 			new_value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_3);
@@ -222,7 +221,7 @@ static void dp_audio_copy_management_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_1_BIT)
 			| (parity_byte << PARITY_BYTE_1_BIT));
-	pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_1);
@@ -236,7 +235,7 @@ static void dp_audio_copy_management_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_2_BIT)
 			| (parity_byte << PARITY_BYTE_2_BIT));
-	pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_2);
@@ -250,7 +249,7 @@ static void dp_audio_copy_management_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_3_BIT)
 			| (parity_byte << PARITY_BYTE_3_BIT));
-	pr_debug("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_3);
@@ -271,7 +270,7 @@ static void dp_audio_isrc_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_1_BIT)
 			| (parity_byte << PARITY_BYTE_1_BIT));
-	pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_ISRC, DP_AUDIO_SDP_HEADER_1);
@@ -285,7 +284,7 @@ static void dp_audio_isrc_sdp(struct dp_audio_private *audio)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_2_BIT)
 			| (parity_byte << PARITY_BYTE_2_BIT));
-	pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_audio_set_header(catalog, value,
 		DP_AUDIO_SDP_ISRC, DP_AUDIO_SDP_HEADER_2);
@@ -294,7 +293,7 @@ static void dp_audio_isrc_sdp(struct dp_audio_private *audio)
 static void dp_audio_setup_sdp(struct dp_audio_private *audio)
 {
 	if (!atomic_read(&audio->session_on)) {
-		pr_warn("session inactive\n");
+		DP_WARN("session inactive\n");
 		return;
 	}
 
@@ -320,7 +319,7 @@ static void dp_audio_setup_acr(struct dp_audio_private *audio)
 	struct dp_catalog_audio *catalog = audio->catalog;
 
 	if (!atomic_read(&audio->session_on)) {
-		pr_warn("session inactive\n");
+		DP_WARN("session inactive\n");
 		return;
 	}
 
@@ -338,7 +337,7 @@ static void dp_audio_setup_acr(struct dp_audio_private *audio)
 		select = 3;
 		break;
 	default:
-		pr_debug("Unknown link rate\n");
+		DP_DEBUG("Unknown link rate\n");
 		select = 0;
 		break;
 	}
@@ -353,7 +352,7 @@ static void dp_audio_enable(struct dp_audio_private *audio, bool enable)
 
 	audio->engine_on = enable;
 	if (!atomic_read(&audio->session_on)) {
-		pr_warn("session inactive. enable=%d\n", enable);
+		DP_WARN("session inactive. enable=%d\n", enable);
 		return;
 	}
 	catalog->data = enable;
@@ -367,19 +366,19 @@ static struct dp_audio_private *dp_audio_get_data(struct platform_device *pdev)
 	struct dp_audio *dp_audio;
 
 	if (!pdev) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return ERR_PTR(-ENODEV);
 	}
 
 	ext_data = platform_get_drvdata(pdev);
 	if (!ext_data) {
-		pr_err("invalid ext disp data\n");
+		DP_ERR("invalid ext disp data\n");
 		return ERR_PTR(-EINVAL);
 	}
 
 	dp_audio = ext_data->intf_data;
 	if (!ext_data) {
-		pr_err("invalid intf data\n");
+		DP_ERR("invalid intf data\n");
 		return ERR_PTR(-EINVAL);
 	}
 
@@ -403,7 +402,8 @@ static int dp_audio_info_setup(struct platform_device *pdev,
 	audio->channels = params->num_of_channels;
 
 	if (audio->panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream id: %d\n", audio->panel->stream_id);
+		DP_ERR("invalid stream id: %d\n",
+				audio->panel->stream_id);
 		rc = -EINVAL;
 		mutex_unlock(&audio->ops_lock);
 		return rc;
@@ -431,7 +431,7 @@ static int dp_audio_get_edid_blk(struct platform_device *pdev,
 	}
 
 	if (!audio->panel || !audio->panel->edid_ctrl) {
-		pr_err("invalid panel data\n");
+		DP_ERR("invalid panel data\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -494,7 +494,7 @@ static void dp_audio_teardown_done(struct platform_device *pdev)
 	atomic_set(&audio->acked, 1);
 	complete_all(&audio->hpd_comp);
 
-	pr_debug("audio engine disabled\n");
+	DP_DEBUG("audio engine disabled\n");
 }
 
 static int dp_audio_ack_done(struct platform_device *pdev, u32 ack)
@@ -512,7 +512,7 @@ static int dp_audio_ack_done(struct platform_device *pdev, u32 ack)
 		audio->ack_enabled = ack & AUDIO_ACK_ENABLE ?
 			true : false;
 
-		pr_debug("audio ack feature %s\n",
+		DP_DEBUG("audio ack feature %s\n",
 			audio->ack_enabled ? "enabled" : "disabled");
 		goto end;
 	}
@@ -522,7 +522,7 @@ static int dp_audio_ack_done(struct platform_device *pdev, u32 ack)
 
 	ack_hpd = ack & AUDIO_ACK_CONNECT;
 
-	pr_debug("acknowledging audio (%d)\n", ack_hpd);
+	DP_DEBUG("acknowledging audio (%d)\n", ack_hpd);
 
 	if (!audio->engine_on) {
 		atomic_set(&audio->acked, 1);
@@ -539,7 +539,7 @@ static int dp_audio_codec_ready(struct platform_device *pdev)
 
 	audio = dp_audio_get_data(pdev);
 	if (IS_ERR(audio)) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = PTR_ERR(audio);
 		goto end;
 	}
@@ -576,28 +576,28 @@ static int dp_audio_register_ext_disp(struct dp_audio_private *audio)
 	ops->ready              = dp_audio_codec_ready;
 
 	if (!audio->pdev->dev.of_node) {
-		pr_err("cannot find audio dev.of_node\n");
+		DP_ERR("cannot find audio dev.of_node\n");
 		rc = -ENODEV;
 		goto end;
 	}
 
 	pd = of_parse_phandle(audio->pdev->dev.of_node, phandle, 0);
 	if (!pd) {
-		pr_err("cannot parse %s handle\n", phandle);
+		DP_ERR("cannot parse %s handle\n", phandle);
 		rc = -ENODEV;
 		goto end;
 	}
 
 	audio->ext_pdev = of_find_device_by_node(pd);
 	if (!audio->ext_pdev) {
-		pr_err("cannot find %s pdev\n", phandle);
+		DP_ERR("cannot find %s pdev\n", phandle);
 		rc = -ENODEV;
 		goto end;
 	}
 #if defined(CONFIG_MSM_EXT_DISPLAY)
 	rc = msm_ext_disp_register_intf(audio->ext_pdev, ext);
 	if (rc)
-		pr_err("failed to register disp\n");
+		DP_ERR("failed to register disp\n");
 #endif
 end:
 	if (pd)
@@ -616,21 +616,21 @@ static int dp_audio_deregister_ext_disp(struct dp_audio_private *audio)
 	ext = &audio->ext_audio_data;
 
 	if (!audio->pdev->dev.of_node) {
-		pr_err("cannot find audio dev.of_node\n");
+		DP_ERR("cannot find audio dev.of_node\n");
 		rc = -ENODEV;
 		goto end;
 	}
 
 	pd = of_parse_phandle(audio->pdev->dev.of_node, phandle, 0);
 	if (!pd) {
-		pr_err("cannot parse %s handle\n", phandle);
+		DP_ERR("cannot parse %s handle\n", phandle);
 		rc = -ENODEV;
 		goto end;
 	}
 
 	audio->ext_pdev = of_find_device_by_node(pd);
 	if (!audio->ext_pdev) {
-		pr_err("cannot find %s pdev\n", phandle);
+		DP_ERR("cannot find %s pdev\n", phandle);
 		rc = -ENODEV;
 		goto end;
 	}
@@ -638,7 +638,7 @@ static int dp_audio_deregister_ext_disp(struct dp_audio_private *audio)
 #if defined(CONFIG_MSM_EXT_DISPLAY)
 	rc = msm_ext_disp_deregister_intf(audio->ext_pdev, ext);
 	if (rc)
-		pr_err("failed to deregister disp\n");
+		DP_ERR("failed to deregister disp\n");
 #endif
 
 end:
@@ -653,7 +653,7 @@ static int dp_audio_notify(struct dp_audio_private *audio, u32 state)
 	atomic_set(&audio->acked, 0);
 
 	if (!ext->intf_ops.audio_notify) {
-		pr_err("audio notify not defined\n");
+		DP_ERR("audio notify not defined\n");
 		goto end;
 	}
 
@@ -671,12 +671,12 @@ static int dp_audio_notify(struct dp_audio_private *audio, u32 state)
 
 	rc = wait_for_completion_timeout(&audio->hpd_comp, HZ * 4);
 	if (!rc) {
-		pr_err("timeout. state=%d err=%d\n", state, rc);
+		DP_ERR("timeout. state=%d err=%d\n", state, rc);
 		rc = -ETIMEDOUT;
 		goto end;
 	}
 
-	pr_debug("success\n");
+	DP_DEBUG("success\n");
 end:
 	return rc;
 }
@@ -687,7 +687,7 @@ static int dp_audio_config(struct dp_audio_private *audio, u32 state)
 	struct msm_ext_disp_init_data *ext = &audio->ext_audio_data;
 
 	if (!ext || !ext->intf_ops.audio_config) {
-		pr_err("audio_config not defined\n");
+		DP_ERR("audio_config not defined\n");
 		goto end;
 	}
 
@@ -699,7 +699,8 @@ static int dp_audio_config(struct dp_audio_private *audio, u32 state)
 		rc = ext->intf_ops.audio_config(audio->ext_pdev,
 				&ext->codec, state);
 		if (rc)
-			pr_err("failed to config audio, err=%d\n", rc);
+			DP_ERR("failed to config audio, err=%d\n",
+					rc);
 	}
 end:
 	return rc;
@@ -712,13 +713,13 @@ static int dp_audio_on(struct dp_audio *dp_audio)
 	struct msm_ext_disp_init_data *ext;
 
 	if (!dp_audio) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
 	audio = container_of(dp_audio, struct dp_audio_private, dp_audio);
 	if (IS_ERR(audio)) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -736,7 +737,7 @@ static int dp_audio_on(struct dp_audio *dp_audio)
 	if (rc)
 		goto end;
 
-	pr_debug("success\n");
+	DP_DEBUG("success\n");
 end:
 	return rc;
 }
@@ -749,7 +750,7 @@ static int dp_audio_off(struct dp_audio *dp_audio)
 	bool work_pending = false;
 
 	if (!dp_audio) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -758,13 +759,13 @@ static int dp_audio_off(struct dp_audio *dp_audio)
 
 	work_pending = cancel_delayed_work_sync(&audio->notify_delayed_work);
 	if (work_pending)
-		pr_debug("pending notification work completed\n");
+		DP_DEBUG("pending notification work completed\n");
 
 	rc = dp_audio_notify(audio, EXT_DISPLAY_CABLE_DISCONNECT);
 	if (rc)
 		goto end;
 
-	pr_debug("success\n");
+	DP_DEBUG("success\n");
 end:
 	dp_audio_config(audio, EXT_DISPLAY_CABLE_DISCONNECT);
 
@@ -790,7 +791,7 @@ static int dp_audio_create_notify_workqueue(struct dp_audio_private *audio)
 {
 	audio->notify_workqueue = create_workqueue("sdm_dp_audio_notify");
 	if (IS_ERR_OR_NULL(audio->notify_workqueue)) {
-		pr_err("Error creating notify_workqueue\n");
+		DP_ERR("Error creating notify_workqueue\n");
 		return -EPERM;
 	}
 
@@ -814,7 +815,7 @@ struct dp_audio *dp_audio_get(struct platform_device *pdev,
 	struct dp_audio *dp_audio;
 
 	if (!pdev || !panel || !catalog) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}

msm/dp/dp_aux.c

@@ -3,13 +3,12 @@
  * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/soc/qcom/fsa4480-i2c.h>
 #include <linux/usb/usbpd.h>
 #include <linux/delay.h>
 
 #include "dp_aux.h"
+#include "dp_debug.h"
 
 #define DP_AUX_ENUM_STR(x)		#x
 
@@ -68,7 +67,7 @@ static void dp_aux_hex_dump(struct drm_dp_aux *drm_aux,
 		hex_dump_to_buffer(msg->buffer + i, linelen, rowsize, 1,
 			linebuf, sizeof(linebuf), false);
 
-		pr_debug("%s%s\n", prefix, linebuf);
+		DP_DEBUG("%s%s\n", prefix, linebuf);
 	}
 }
 #else
@@ -116,7 +115,7 @@ static u32 dp_aux_write(struct dp_aux_private *aux,
 	 * limit buf length to 128 bytes here
 	 */
 	if (len > aux_cmd_fifo_len) {
-		pr_err("buf len error\n");
+		DP_ERR("buf len error\n");
 		return 0;
 	}
 
@@ -169,13 +168,13 @@ static int dp_aux_cmd_fifo_tx(struct dp_aux_private *aux,
 
 	len = dp_aux_write(aux, msg);
 	if (len == 0) {
-		pr_err("DP AUX write failed\n");
+		DP_ERR("DP AUX write failed\n");
 		return -EINVAL;
 	}
 
 	timeout = wait_for_completion_timeout(&aux->comp, aux_timeout_ms);
 	if (!timeout) {
-		pr_err("aux %s timeout\n", (aux->read ? "read" : "write"));
+		DP_ERR("aux %s timeout\n", (aux->read ? "read" : "write"));
 		return -ETIMEDOUT;
 	}
 
@@ -219,7 +218,7 @@ static void dp_aux_cmd_fifo_rx(struct dp_aux_private *aux,
 
 		actual_i = (data >> 16) & 0xFF;
 		if (i != actual_i)
-			pr_warn("Index mismatch: expected %d, found %d\n",
+			DP_WARN("Index mismatch: expected %d, found %d\n",
 				i, actual_i);
 	}
 }
@@ -278,7 +277,7 @@ static void dp_aux_isr(struct dp_aux *dp_aux)
 	struct dp_aux_private *aux;
 
 	if (!dp_aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -300,7 +299,7 @@ static void dp_aux_reconfig(struct dp_aux *dp_aux)
 	struct dp_aux_private *aux;
 
 	if (!dp_aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -316,7 +315,7 @@ static void dp_aux_abort_transaction(struct dp_aux *dp_aux)
 	struct dp_aux_private *aux;
 
 	if (!dp_aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -443,7 +442,7 @@ static int dp_aux_transfer_ready(struct dp_aux_private *aux,
 	/* msg sanity check */
 	if ((aux->native && (msg->size > aux_cmd_native_max)) ||
 		(msg->size > aux_cmd_i2c_max)) {
-		pr_err("%s: invalid msg: size(%zu), request(%x)\n",
+		DP_ERR("%s: invalid msg: size(%zu), request(%x)\n",
 			__func__, msg->size, msg->request);
 		ret = -EINVAL;
 		goto error;
@@ -485,12 +484,12 @@ static ssize_t dp_aux_transfer_debug(struct drm_dp_aux *drm_aux,
 	aux->aux_error_num = DP_AUX_ERR_NONE;
 
 	if (!aux->dpcd || !aux->edid) {
-		pr_err("invalid aux/dpcd structure\n");
+		DP_ERR("invalid aux/dpcd structure\n");
 		goto end;
 	}
 
 	if ((msg->address + msg->size) > SZ_4K) {
-		pr_debug("invalid dpcd access: addr=0x%x, size=0x%lx\n",
+		DP_DEBUG("invalid dpcd access: addr=0x%x, size=0x%lx\n",
 				msg->address, msg->size);
 		goto address_error;
 	}
@@ -505,7 +504,7 @@ static ssize_t dp_aux_transfer_debug(struct drm_dp_aux *drm_aux,
 		if (aux->read) {
 			timeout = wait_for_completion_timeout(&aux->comp, HZ);
 			if (!timeout) {
-				pr_err("read timeout: 0x%x\n", msg->address);
+				DP_ERR("read timeout: 0x%x\n", msg->address);
 				atomic_set(&aux->aborted, 1);
 				ret = -ETIMEDOUT;
 				goto end;
@@ -519,7 +518,7 @@ static ssize_t dp_aux_transfer_debug(struct drm_dp_aux *drm_aux,
 
 			timeout = wait_for_completion_timeout(&aux->comp, HZ);
 			if (!timeout) {
-				pr_err("write timeout: 0x%x\n", msg->address);
+				DP_ERR("write timeout: 0x%x\n", msg->address);
 				atomic_set(&aux->aborted, 1);
 				ret = -ETIMEDOUT;
 				goto end;
@@ -639,7 +638,7 @@ static void dp_aux_init(struct dp_aux *dp_aux, struct dp_aux_cfg *aux_cfg)
 	struct dp_aux_private *aux;
 
 	if (!dp_aux || !aux_cfg) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -662,7 +661,7 @@ static void dp_aux_deinit(struct dp_aux *dp_aux)
 	struct dp_aux_private *aux;
 
 	if (!dp_aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -682,7 +681,7 @@ static int dp_aux_register(struct dp_aux *dp_aux)
 	int ret = 0;
 
 	if (!dp_aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		ret = -EINVAL;
 		goto exit;
 	}
@@ -694,7 +693,7 @@ static int dp_aux_register(struct dp_aux *dp_aux)
 	aux->drm_aux.transfer = dp_aux_transfer;
 	ret = drm_dp_aux_register(&aux->drm_aux);
 	if (ret) {
-		pr_err("%s: failed to register drm aux: %d\n", __func__, ret);
+		DP_ERR("%s: failed to register drm aux: %d\n", __func__, ret);
 		goto exit;
 	}
 	dp_aux->drm_aux = &aux->drm_aux;
@@ -707,7 +706,7 @@ static void dp_aux_deregister(struct dp_aux *dp_aux)
 	struct dp_aux_private *aux;
 
 	if (!dp_aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -720,7 +719,7 @@ static void dp_aux_dpcd_updated(struct dp_aux *dp_aux)
 	struct dp_aux_private *aux;
 
 	if (!dp_aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -735,7 +734,7 @@ static void dp_aux_set_sim_mode(struct dp_aux *dp_aux, bool en,
 	struct dp_aux_private *aux;
 
 	if (!dp_aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -764,7 +763,7 @@ static int dp_aux_configure_aux_switch(struct dp_aux *dp_aux,
 	enum fsa_function event = FSA_USBC_DISPLAYPORT_DISCONNECTED;
 
 	if (!dp_aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -772,7 +771,7 @@ static int dp_aux_configure_aux_switch(struct dp_aux *dp_aux,
 	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
 
 	if (!aux->aux_switch_node) {
-		pr_debug("undefined fsa4480 handle\n");
+		DP_DEBUG("undefined fsa4480 handle\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -786,18 +785,18 @@ static int dp_aux_configure_aux_switch(struct dp_aux *dp_aux,
 			event = FSA_USBC_ORIENTATION_CC2;
 			break;
 		default:
-			pr_err("invalid orientation\n");
+			DP_ERR("invalid orientation\n");
 			rc = -EINVAL;
 			goto end;
 		}
 	}
 
-	pr_debug("enable=%d, orientation=%d, event=%d\n",
+	DP_DEBUG("enable=%d, orientation=%d, event=%d\n",
 			enable, orientation, event);
 
 	rc = fsa4480_switch_event(aux->aux_switch_node, event);
 	if (rc)
-		pr_err("failed to configure fsa4480 i2c device (%d)\n", rc);
+		DP_ERR("failed to configure fsa4480 i2c device (%d)\n", rc);
 end:
 	return rc;
 }
@@ -813,7 +812,7 @@ struct dp_aux *dp_aux_get(struct device *dev, struct dp_catalog_aux *catalog,
 			(!parser->no_aux_switch &&
 				!aux_switch &&
 				!parser->gpio_aux_switch)) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -ENODEV;
 		goto error;
 	}

msm/dp/dp_catalog.c

@@ -3,7 +3,6 @@
  * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
 
 #include <linux/delay.h>
 #include <linux/iopoll.h>
@@ -11,6 +10,7 @@
 
 #include "dp_catalog.h"
 #include "dp_reg.h"
+#include "dp_debug.h"
 
 #define DP_GET_MSB(x)	(x >> 8)
 #define DP_GET_LSB(x)	(x & 0xff)
@@ -107,7 +107,7 @@ static u32 dp_catalog_aux_read_data(struct dp_catalog_aux *aux)
 	struct dp_io_data *io_data;
 
 	if (!aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		goto end;
 	}
 
@@ -126,7 +126,7 @@ static int dp_catalog_aux_write_data(struct dp_catalog_aux *aux)
 	struct dp_io_data *io_data;
 
 	if (!aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -146,7 +146,7 @@ static int dp_catalog_aux_write_trans(struct dp_catalog_aux *aux)
 	struct dp_io_data *io_data;
 
 	if (!aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -167,7 +167,7 @@ static int dp_catalog_aux_clear_trans(struct dp_catalog_aux *aux, bool read)
 	struct dp_io_data *io_data;
 
 	if (!aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -193,7 +193,7 @@ static void dp_catalog_aux_clear_hw_interrupts(struct dp_catalog_aux *aux)
 	u32 data = 0;
 
 	if (!aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -217,7 +217,7 @@ static void dp_catalog_aux_reset(struct dp_catalog_aux *aux)
 	struct dp_io_data *io_data;
 
 	if (!aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -243,7 +243,7 @@ static void dp_catalog_aux_enable(struct dp_catalog_aux *aux, bool enable)
 	struct dp_io_data *io_data;
 
 	if (!aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -273,7 +273,7 @@ static void dp_catalog_aux_update_cfg(struct dp_catalog_aux *aux,
 	struct dp_io_data *io_data;
 
 	if (!aux || !cfg || (type >= PHY_AUX_CFG_MAX)) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -283,7 +283,7 @@ static void dp_catalog_aux_update_cfg(struct dp_catalog_aux *aux,
 
 	current_index = cfg[type].current_index;
 	new_index = (current_index + 1) % cfg[type].cfg_cnt;
-	pr_debug("Updating %s from 0x%08x to 0x%08x\n",
+	DP_DEBUG("Updating %s from 0x%08x to 0x%08x\n",
 		dp_phy_aux_config_type_to_string(type),
 	cfg[type].lut[current_index], cfg[type].lut[new_index]);
 
@@ -300,7 +300,7 @@ static void dp_catalog_aux_setup(struct dp_catalog_aux *aux,
 	int i = 0;
 
 	if (!aux || !cfg) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -342,7 +342,7 @@ static void dp_catalog_aux_get_irq(struct dp_catalog_aux *aux, bool cmd_busy)
 	struct dp_io_data *io_data;
 
 	if (!aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -369,7 +369,7 @@ static bool dp_catalog_ctrl_wait_for_phy_ready(
 	if (readl_poll_timeout_atomic((base + reg), state,
 			((state & DP_PHY_READY) > 0),
 			poll_sleep_us, pll_timeout_us)) {
-		pr_err("PHY status failed, status=%x\n", state);
+		DP_ERR("PHY status failed, status=%x\n", state);
 
 		success = false;
 	}
@@ -387,7 +387,7 @@ static int dp_catalog_ctrl_late_phy_init(struct dp_catalog_ctrl *ctrl,
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -468,7 +468,7 @@ static u32 dp_catalog_ctrl_read_hdcp_status(struct dp_catalog_ctrl *ctrl)
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -488,7 +488,7 @@ static void dp_catalog_panel_setup_vsif_infoframe_sdp(
 	u8 buf[SZ_64], off = 0;
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -543,7 +543,7 @@ static void dp_catalog_panel_setup_hdr_infoframe_sdp(
 	u8 buf[SZ_64], off = 0;
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -665,12 +665,12 @@ static void dp_catalog_panel_setup_vsc_sdp(struct dp_catalog_panel *panel)
 	u8 buf[SZ_128];
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -788,12 +788,12 @@ static void dp_catalog_panel_config_hdr(struct dp_catalog_panel *panel, bool en,
 	u32 misc1_misc0_off = 0;
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -843,9 +843,9 @@ static void dp_catalog_panel_config_hdr(struct dp_catalog_panel *panel, bool en,
 		misc |= BIT(14);
 
 		if (panel->hdr_data.hdr_meta.eotf)
-			pr_debug("Enabled\n");
+			DP_DEBUG("Enabled\n");
 		else
-			pr_debug("Reset\n");
+			DP_DEBUG("Reset\n");
 	} else {
 		/* VSCEXT_SDP_EN, GEN0_SDP_EN */
 		cfg &= ~BIT(16) & ~BIT(17) & ~BIT(19);
@@ -865,7 +865,7 @@ static void dp_catalog_panel_config_hdr(struct dp_catalog_panel *panel, bool en,
 		/* switch back to MSA */
 		misc &= ~BIT(14);
 
-		pr_debug("Disabled\n");
+		DP_DEBUG("Disabled\n");
 	}
 
 	dp_write(catalog->exe_mode, io_data, DP_MISC1_MISC0 + misc1_misc0_off,
@@ -884,7 +884,7 @@ static void dp_catalog_panel_update_transfer_unit(
 	struct dp_io_data *io_data;
 
 	if (!panel || panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -904,7 +904,7 @@ static void dp_catalog_ctrl_state_ctrl(struct dp_catalog_ctrl *ctrl, u32 state)
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -923,7 +923,7 @@ static void dp_catalog_ctrl_config_ctrl(struct dp_catalog_ctrl *ctrl, u8 ln_cnt)
 	u32 cfg;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -939,7 +939,7 @@ static void dp_catalog_ctrl_config_ctrl(struct dp_catalog_ctrl *ctrl, u8 ln_cnt)
 	cfg |= 0x02000000;
 	dp_write(catalog->exe_mode, io_data, DP_MAINLINK_CTRL, cfg);
 
-	pr_debug("DP_MAINLINK_CTRL=0x%x\n", cfg);
+	DP_DEBUG("DP_MAINLINK_CTRL=0x%x\n", cfg);
 }
 
 static void dp_catalog_panel_config_ctrl(struct dp_catalog_panel *panel,
@@ -950,12 +950,12 @@ static void dp_catalog_panel_config_ctrl(struct dp_catalog_panel *panel,
 	u32 strm_reg_off = 0, mainlink_ctrl;
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -965,7 +965,7 @@ static void dp_catalog_panel_config_ctrl(struct dp_catalog_panel *panel,
 	if (panel->stream_id == DP_STREAM_1)
 		strm_reg_off = DP1_CONFIGURATION_CTRL - DP_CONFIGURATION_CTRL;
 
-	pr_debug("DP_CONFIGURATION_CTRL=0x%x\n", cfg);
+	DP_DEBUG("DP_CONFIGURATION_CTRL=0x%x\n", cfg);
 
 	dp_write(catalog->exe_mode, io_data,
 			DP_CONFIGURATION_CTRL + strm_reg_off, cfg);
@@ -993,12 +993,12 @@ static void dp_catalog_panel_config_dto(struct dp_catalog_panel *panel,
 	u32 dsc_dto;
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -1013,7 +1013,7 @@ static void dp_catalog_panel_config_dto(struct dp_catalog_panel *panel,
 		io_data = catalog->io.dp_p1;
 		break;
 	default:
-		pr_err("invalid stream id\n");
+		DP_ERR("invalid stream id\n");
 		return;
 	}
 
@@ -1032,7 +1032,7 @@ static void dp_catalog_ctrl_lane_mapping(struct dp_catalog_ctrl *ctrl,
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1075,7 +1075,7 @@ static void dp_catalog_ctrl_mainlink_ctrl(struct dp_catalog_ctrl *ctrl,
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1116,12 +1116,12 @@ static void dp_catalog_panel_config_misc(struct dp_catalog_panel *panel)
 	u32 reg_offset = 0;
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -1131,7 +1131,7 @@ static void dp_catalog_panel_config_misc(struct dp_catalog_panel *panel)
 	if (panel->stream_id == DP_STREAM_1)
 		reg_offset = DP1_MISC1_MISC0 - DP_MISC1_MISC0;
 
-	pr_debug("misc settings = 0x%x\n", panel->misc_val);
+	DP_DEBUG("misc settings = 0x%x\n", panel->misc_val);
 	dp_write(catalog->exe_mode, io_data, DP_MISC1_MISC0 + reg_offset,
 			panel->misc_val);
 }
@@ -1150,12 +1150,12 @@ static void dp_catalog_panel_config_msa(struct dp_catalog_panel *panel,
 	u32 mvid_reg_off = 0, nvid_reg_off = 0;
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -1169,7 +1169,7 @@ static void dp_catalog_panel_config_msa(struct dp_catalog_panel *panel,
 			MMSS_DP_PIXEL_M + strm_reg_off);
 	pixel_n = dp_read(catalog->exe_mode, io_data,
 			MMSS_DP_PIXEL_N + strm_reg_off);
-	pr_debug("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
+	DP_DEBUG("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
 
 	mvid = (pixel_m & 0xFFFF) * 5;
 	nvid = (0xFFFF & (~pixel_n)) + (pixel_m & 0xFFFF);
@@ -1182,7 +1182,7 @@ static void dp_catalog_panel_config_msa(struct dp_catalog_panel *panel,
 		nvid = temp;
 	}
 
-	pr_debug("rate = %d\n", rate);
+	DP_DEBUG("rate = %d\n", rate);
 
 	if (panel->widebus_en)
 		mvid <<= 1;
@@ -1200,7 +1200,7 @@ static void dp_catalog_panel_config_msa(struct dp_catalog_panel *panel,
 		nvid_reg_off = DP1_SOFTWARE_NVID - DP_SOFTWARE_NVID;
 	}
 
-	pr_debug("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
+	DP_DEBUG("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
 	dp_write(catalog->exe_mode, io_data, DP_SOFTWARE_MVID + mvid_reg_off,
 			mvid);
 	dp_write(catalog->exe_mode, io_data, DP_SOFTWARE_NVID + nvid_reg_off,
@@ -1216,7 +1216,7 @@ static void dp_catalog_ctrl_set_pattern(struct dp_catalog_ctrl *ctrl,
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1225,7 +1225,7 @@ static void dp_catalog_ctrl_set_pattern(struct dp_catalog_ctrl *ctrl,
 
 	bit = 1;
 	bit <<= (pattern - 1);
-	pr_debug("hw: bit=%d train=%d\n", bit, pattern);
+	DP_DEBUG("hw: bit=%d train=%d\n", bit, pattern);
 	dp_write(catalog->exe_mode, io_data, DP_STATE_CTRL, bit);
 
 	bit = 8;
@@ -1238,7 +1238,7 @@ static void dp_catalog_ctrl_set_pattern(struct dp_catalog_ctrl *ctrl,
 	}
 
 	if (cnt == 0)
-		pr_err("set link_train=%d failed\n", pattern);
+		DP_ERR("set link_train=%d failed\n", pattern);
 }
 
 static void dp_catalog_ctrl_usb_reset(struct dp_catalog_ctrl *ctrl, bool flip)
@@ -1247,7 +1247,7 @@ static void dp_catalog_ctrl_usb_reset(struct dp_catalog_ctrl *ctrl, bool flip)
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1287,12 +1287,12 @@ static void dp_catalog_panel_tpg_cfg(struct dp_catalog_panel *panel,
 	struct dp_io_data *io_data;
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -1355,12 +1355,12 @@ static void dp_catalog_panel_dsc_cfg(struct dp_catalog_panel *panel)
 	int i;
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -1413,7 +1413,7 @@ static void dp_catalog_panel_dsc_cfg(struct dp_catalog_panel *panel)
 	dp_write(catalog->exe_mode, io_data,
 			DP_COMPRESSION_MODE_CTRL + offset, reg);
 
-	pr_debug("compression:0x%x for stream:%d\n",
+	DP_DEBUG("compression:0x%x for stream:%d\n",
 			reg, panel->stream_id);
 }
 
@@ -1425,12 +1425,12 @@ static void dp_catalog_panel_dp_flush(struct dp_catalog_panel *panel,
 	u32 dp_flush, offset;
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -1450,13 +1450,13 @@ static void dp_catalog_panel_dp_flush(struct dp_catalog_panel *panel,
 static void dp_catalog_panel_pps_flush(struct dp_catalog_panel *panel)
 {
 	dp_catalog_panel_dp_flush(panel, DP_PPS_FLUSH);
-	pr_debug("pps flush for stream:%d\n", panel->stream_id);
+	DP_DEBUG("pps flush for stream:%d\n", panel->stream_id);
 }
 
 static void dp_catalog_panel_dhdr_flush(struct dp_catalog_panel *panel)
 {
 	dp_catalog_panel_dp_flush(panel, DP_DHDR_FLUSH);
-	pr_debug("dhdr flush for stream:%d\n", panel->stream_id);
+	DP_DEBUG("dhdr flush for stream:%d\n", panel->stream_id);
 }
 
 
@@ -1467,7 +1467,7 @@ static bool dp_catalog_panel_dhdr_busy(struct dp_catalog_panel *panel)
 	u32 dp_flush, offset;
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return false;
 	}
 
@@ -1491,7 +1491,7 @@ static void dp_catalog_ctrl_reset(struct dp_catalog_ctrl *ctrl)
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1516,7 +1516,7 @@ static bool dp_catalog_ctrl_mainlink_ready(struct dp_catalog_ctrl *ctrl)
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		goto end;
 	}
 
@@ -1531,7 +1531,7 @@ static bool dp_catalog_ctrl_mainlink_ready(struct dp_catalog_ctrl *ctrl)
 
 		usleep_range(1000, 1010); /* 1ms wait before next reg read */
 	}
-	pr_err("mainlink not ready\n");
+	DP_ERR("mainlink not ready\n");
 end:
 	return false;
 }
@@ -1543,7 +1543,7 @@ static void dp_catalog_ctrl_enable_irq(struct dp_catalog_ctrl *ctrl,
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1571,7 +1571,7 @@ static void dp_catalog_ctrl_get_interrupt(struct dp_catalog_ctrl *ctrl)
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1599,7 +1599,7 @@ static void dp_catalog_ctrl_phy_reset(struct dp_catalog_ctrl *ctrl)
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1621,7 +1621,7 @@ static void dp_catalog_ctrl_phy_lane_cfg(struct dp_catalog_ctrl *ctrl,
 	u8 orientation = BIT(!!flipped);
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1631,7 +1631,7 @@ static void dp_catalog_ctrl_phy_lane_cfg(struct dp_catalog_ctrl *ctrl,
 
 	info |= (ln_cnt & 0x0F);
 	info |= ((orientation & 0x0F) << 4);
-	pr_debug("Shared Info = 0x%x\n", info);
+	DP_DEBUG("Shared Info = 0x%x\n", info);
 
 	dp_write(catalog->exe_mode, io_data, DP_PHY_SPARE0, info);
 }
@@ -1644,13 +1644,13 @@ static void dp_catalog_ctrl_update_vx_px(struct dp_catalog_ctrl *ctrl,
 	u8 value0, value1;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	catalog = dp_catalog_get_priv(ctrl);
 
-	pr_debug("hw: v=%d p=%d\n", v_level, p_level);
+	DP_DEBUG("hw: v=%d p=%d\n", v_level, p_level);
 
 	value0 = vm_voltage_swing[v_level][p_level];
 	value1 = vm_pre_emphasis[v_level][p_level];
@@ -1681,10 +1681,10 @@ static void dp_catalog_ctrl_update_vx_px(struct dp_catalog_ctrl *ctrl,
 		dp_write(catalog->exe_mode, io_data, TXn_TX_EMP_POST1_LVL,
 				value1);
 
-		pr_debug("hw: vx_value=0x%x px_value=0x%x\n",
+		DP_DEBUG("hw: vx_value=0x%x px_value=0x%x\n",
 			value0, value1);
 	} else {
-		pr_err("invalid vx (0x%x=0x%x), px (0x%x=0x%x\n",
+		DP_ERR("invalid vx (0x%x=0x%x), px (0x%x=0x%x\n",
 			v_level, value0, p_level, value1);
 	}
 }
@@ -1697,7 +1697,7 @@ static void dp_catalog_ctrl_send_phy_pattern(struct dp_catalog_ctrl *ctrl,
 	struct dp_io_data *io_data = NULL;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1759,7 +1759,7 @@ static void dp_catalog_ctrl_send_phy_pattern(struct dp_catalog_ctrl *ctrl,
 		dp_write(catalog->exe_mode, io_data, DP_STATE_CTRL, 0x8);
 		break;
 	default:
-		pr_debug("No valid test pattern requested: 0x%x\n", pattern);
+		DP_DEBUG("No valid test pattern requested: 0x%x\n", pattern);
 		return;
 	}
 
@@ -1773,7 +1773,7 @@ static u32 dp_catalog_ctrl_read_phy_pattern(struct dp_catalog_ctrl *ctrl)
 	struct dp_io_data *io_data = NULL;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return 0;
 	}
 
@@ -1792,7 +1792,7 @@ static void dp_catalog_ctrl_fec_config(struct dp_catalog_ctrl *ctrl,
 	u32 reg;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1828,7 +1828,7 @@ static int dp_catalog_reg_dump(struct dp_catalog *dp_catalog,
 	struct dp_parser *parser;
 
 	if (!dp_catalog) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -1839,7 +1839,7 @@ static int dp_catalog_reg_dump(struct dp_catalog *dp_catalog,
 	parser->get_io_buf(parser, name);
 	io_data = parser->get_io(parser, name);
 	if (!io_data) {
-		pr_err("IO %s not found\n", name);
+		DP_ERR("IO %s not found\n", name);
 		ret = -EINVAL;
 		goto end;
 	}
@@ -1848,7 +1848,7 @@ static int dp_catalog_reg_dump(struct dp_catalog *dp_catalog,
 	len = io_data->io.len;
 
 	if (!buf || !len) {
-		pr_err("no buffer available\n");
+		DP_ERR("no buffer available\n");
 		ret = -ENOMEM;
 		goto end;
 	}
@@ -1886,7 +1886,7 @@ static void dp_catalog_ctrl_mst_config(struct dp_catalog_ctrl *ctrl,
 	u32 reg;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1911,7 +1911,7 @@ static void dp_catalog_ctrl_trigger_act(struct dp_catalog_ctrl *ctrl)
 	struct dp_io_data *io_data = NULL;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1932,7 +1932,7 @@ static void dp_catalog_ctrl_read_act_complete_sts(struct dp_catalog_ctrl *ctrl,
 	u32 reg;
 
 	if (!ctrl || !sts) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1958,13 +1958,13 @@ static void dp_catalog_ctrl_channel_alloc(struct dp_catalog_ctrl *ctrl,
 	int const num_slots_per_reg = 32;
 
 	if (!ctrl || ch >= DP_STREAM_MAX) {
-		pr_err("invalid input. ch %d\n", ch);
+		DP_ERR("invalid input. ch %d\n", ch);
 		return;
 	}
 
 	if (ch_start_slot > DP_MAX_TIME_SLOTS ||
 			(ch_start_slot + tot_slot_cnt > DP_MAX_TIME_SLOTS)) {
-		pr_err("invalid slots start %d, tot %d\n",
+		DP_ERR("invalid slots start %d, tot %d\n",
 			ch_start_slot, tot_slot_cnt);
 		return;
 	}
@@ -1973,7 +1973,7 @@ static void dp_catalog_ctrl_channel_alloc(struct dp_catalog_ctrl *ctrl,
 
 	io_data = catalog->io.dp_link;
 
-	pr_debug("ch %d, start_slot %d, tot_slot %d\n",
+	DP_DEBUG("ch %d, start_slot %d, tot_slot %d\n",
 			ch, ch_start_slot, tot_slot_cnt);
 
 	if (ch == DP_STREAM_1)
@@ -1995,7 +1995,7 @@ static void dp_catalog_ctrl_channel_alloc(struct dp_catalog_ctrl *ctrl,
 		}
 	}
 
-	pr_debug("ch:%d slot_reg_1:%d, slot_reg_2:%d\n", ch,
+	DP_DEBUG("ch:%d slot_reg_1:%d, slot_reg_2:%d\n", ch,
 			slot_reg_1, slot_reg_2);
 
 	dp_write(catalog->exe_mode, io_data, DP_DP0_TIMESLOT_1_32 + reg_off,
@@ -2013,13 +2013,13 @@ static void dp_catalog_ctrl_channel_dealloc(struct dp_catalog_ctrl *ctrl,
 	u32 reg_off = 0;
 
 	if (!ctrl || ch >= DP_STREAM_MAX) {
-		pr_err("invalid input. ch %d\n", ch);
+		DP_ERR("invalid input. ch %d\n", ch);
 		return;
 	}
 
 	if (ch_start_slot > DP_MAX_TIME_SLOTS ||
 			(ch_start_slot + tot_slot_cnt > DP_MAX_TIME_SLOTS)) {
-		pr_err("invalid slots start %d, tot %d\n",
+		DP_ERR("invalid slots start %d, tot %d\n",
 			ch_start_slot, tot_slot_cnt);
 		return;
 	}
@@ -2028,7 +2028,7 @@ static void dp_catalog_ctrl_channel_dealloc(struct dp_catalog_ctrl *ctrl,
 
 	io_data = catalog->io.dp_link;
 
-	pr_debug("dealloc ch %d, start_slot %d, tot_slot %d\n",
+	DP_DEBUG("dealloc ch %d, start_slot %d, tot_slot %d\n",
 			ch, ch_start_slot, tot_slot_cnt);
 
 	if (ch == DP_STREAM_1)
@@ -2050,7 +2050,7 @@ static void dp_catalog_ctrl_channel_dealloc(struct dp_catalog_ctrl *ctrl,
 		ch_start_slot++;
 	}
 
-	pr_debug("dealloc ch:%d slot_reg_1:%d, slot_reg_2:%d\n", ch,
+	DP_DEBUG("dealloc ch:%d slot_reg_1:%d, slot_reg_2:%d\n", ch,
 			slot_reg_1, slot_reg_2);
 
 	dp_write(catalog->exe_mode, io_data, DP_DP0_TIMESLOT_1_32 + reg_off,
@@ -2067,7 +2067,7 @@ static void dp_catalog_ctrl_update_rg(struct dp_catalog_ctrl *ctrl, u32 ch,
 	u32 rg, reg_off = 0;
 
 	if (!ctrl || ch >= DP_STREAM_MAX) {
-		pr_err("invalid input. ch %d\n", ch);
+		DP_ERR("invalid input. ch %d\n", ch);
 		return;
 	}
 
@@ -2078,7 +2078,7 @@ static void dp_catalog_ctrl_update_rg(struct dp_catalog_ctrl *ctrl, u32 ch,
 	rg = y_frac_enum;
 	rg |= (x_int << 16);
 
-	pr_debug("ch: %d x_int:%d y_frac_enum:%d rg:%d\n", ch, x_int,
+	DP_DEBUG("ch: %d x_int:%d y_frac_enum:%d rg:%d\n", ch, x_int,
 			y_frac_enum, rg);
 
 	if (ch == DP_STREAM_1)
@@ -2109,7 +2109,7 @@ static void dp_catalog_ctrl_mainlink_levels(struct dp_catalog_ctrl *ctrl,
 		safe_to_exit_level = 5;
 		break;
 	default:
-		pr_debug("setting the default safe_to_exit_level = %u\n",
+		DP_DEBUG("setting the default safe_to_exit_level = %u\n",
 				safe_to_exit_level);
 		break;
 	}
@@ -2119,7 +2119,7 @@ static void dp_catalog_ctrl_mainlink_levels(struct dp_catalog_ctrl *ctrl,
 	mainlink_levels &= 0xFE0;
 	mainlink_levels |= safe_to_exit_level;
 
-	pr_debug("mainlink_level = 0x%x, safe_to_exit_level = 0x%x\n",
+	DP_DEBUG("mainlink_level = 0x%x, safe_to_exit_level = 0x%x\n",
 			mainlink_levels, safe_to_exit_level);
 
 	dp_write(catalog->exe_mode, io_data, DP_MAINLINK_LEVELS,
@@ -2135,12 +2135,12 @@ static int dp_catalog_panel_timing_cfg(struct dp_catalog_panel *panel)
 	u32 offset = 0, reg;
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		goto end;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		goto end;
 	}
 
@@ -2182,7 +2182,7 @@ static void dp_catalog_hpd_config_hpd(struct dp_catalog_hpd *hpd, bool en)
 	struct dp_io_data *io_data;
 
 	if (!hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -2224,7 +2224,7 @@ static u32 dp_catalog_hpd_get_interrupt(struct dp_catalog_hpd *hpd)
 	struct dp_io_data *io_data;
 
 	if (!hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return isr;
 	}
 
@@ -2287,7 +2287,7 @@ static void dp_catalog_audio_config_sdp(struct dp_catalog_audio *audio)
 		return;
 
 	if (audio->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream id:%d\n", audio->stream_id);
+		DP_ERR("invalid stream id:%d\n", audio->stream_id);
 		return;
 	}
 
@@ -2313,7 +2313,7 @@ static void dp_catalog_audio_config_sdp(struct dp_catalog_audio *audio)
 	/* AUDIO_INFOFRAME_SDP_EN  */
 	sdp_cfg |= BIT(20);
 
-	pr_debug("sdp_cfg = 0x%x\n", sdp_cfg);
+	DP_DEBUG("sdp_cfg = 0x%x\n", sdp_cfg);
 	dp_write(catalog->exe_mode, io_data, MMSS_DP_SDP_CFG + sdp_cfg_off,
 			sdp_cfg);
 
@@ -2324,7 +2324,7 @@ static void dp_catalog_audio_config_sdp(struct dp_catalog_audio *audio)
 	/* AUDIO_STREAM_HB3_REGSRC-> Do not use reg values */
 	sdp_cfg2 &= ~BIT(1);
 
-	pr_debug("sdp_cfg2 = 0x%x\n", sdp_cfg2);
+	DP_DEBUG("sdp_cfg2 = 0x%x\n", sdp_cfg2);
 	dp_write(catalog->exe_mode, io_data, MMSS_DP_SDP_CFG2 + sdp_cfg_off,
 			sdp_cfg2);
 }
@@ -2386,7 +2386,7 @@ static void dp_catalog_audio_config_acr(struct dp_catalog_audio *audio)
 
 	acr_ctrl = select << 4 | BIT(31) | BIT(8) | BIT(14);
 
-	pr_debug("select = 0x%x, acr_ctrl = 0x%x\n", select, acr_ctrl);
+	DP_DEBUG("select = 0x%x, acr_ctrl = 0x%x\n", select, acr_ctrl);
 
 	dp_write(catalog->exe_mode, io_data, MMSS_DP_AUDIO_ACR_CTRL, acr_ctrl);
 }
@@ -2410,7 +2410,7 @@ static void dp_catalog_audio_enable(struct dp_catalog_audio *audio)
 	else
 		audio_ctrl &= ~BIT(0);
 
-	pr_debug("dp_audio_cfg = 0x%x\n", audio_ctrl);
+	DP_DEBUG("dp_audio_cfg = 0x%x\n", audio_ctrl);
 	dp_write(catalog->exe_mode, io_data, MMSS_DP_AUDIO_CFG, audio_ctrl);
 
 	/* make sure audio engine is disabled */
@@ -2441,7 +2441,7 @@ static void dp_catalog_config_spd_header(struct dp_catalog_panel *panel)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_1_BIT)
 			| (parity_byte << PARITY_BYTE_1_BIT));
-	pr_debug("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 1: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_write(catalog->exe_mode, io_data, MMSS_DP_GENERIC1_0 + offset,
 			value);
@@ -2454,7 +2454,7 @@ static void dp_catalog_config_spd_header(struct dp_catalog_panel *panel)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_2_BIT)
 			| (parity_byte << PARITY_BYTE_2_BIT));
-	pr_debug("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 2: value = 0x%x, parity_byte = 0x%x\n",
 			value, parity_byte);
 	dp_write(catalog->exe_mode, io_data, MMSS_DP_GENERIC1_1 + offset,
 			value);
@@ -2467,7 +2467,7 @@ static void dp_catalog_config_spd_header(struct dp_catalog_panel *panel)
 	parity_byte = dp_header_get_parity(new_value);
 	value |= ((new_value << HEADER_BYTE_3_BIT)
 			| (parity_byte << PARITY_BYTE_3_BIT));
-	pr_debug("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n",
+	DP_DEBUG("Header Byte 3: value = 0x%x, parity_byte = 0x%x\n",
 			new_value, parity_byte);
 	dp_write(catalog->exe_mode, io_data, MMSS_DP_GENERIC1_1 + offset,
 			value);
@@ -2621,7 +2621,7 @@ static void dp_catalog_set_exe_mode(struct dp_catalog *dp_catalog, char *mode)
 	struct dp_catalog_private *catalog;
 
 	if (!dp_catalog) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -2747,7 +2747,7 @@ struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_parser *parser)
 	};
 
 	if (!dev || !parser) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}

msm/dp/dp_catalog_v200.c

@@ -3,12 +3,11 @@
  * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/delay.h>
 
 #include "dp_catalog.h"
 #include "dp_reg.h"
+#include "dp_debug.h"
 
 #define dp_catalog_get_priv_v200(x) ({ \
 	struct dp_catalog *dp_catalog; \
@@ -46,7 +45,7 @@ static void dp_catalog_aux_clear_hw_interrupts_v200(struct dp_catalog_aux *aux)
 	u32 data = 0;
 
 	if (!aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -75,7 +74,7 @@ static void dp_catalog_aux_setup_v200(struct dp_catalog_aux *aux,
 	int i = 0, sw_reset = 0;
 
 	if (!aux || !cfg) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -131,12 +130,12 @@ static void dp_catalog_panel_config_msa_v200(struct dp_catalog_panel *panel,
 	u32 mvid_reg_off = 0, nvid_reg_off = 0;
 
 	if (!panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream_id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -151,7 +150,7 @@ static void dp_catalog_panel_config_msa_v200(struct dp_catalog_panel *panel,
 			MMSS_DP_PIXEL_M_V200 + strm_reg_off);
 	pixel_n = dp_read(catalog->exe_mode, io_data,
 			MMSS_DP_PIXEL_N_V200 + strm_reg_off);
-	pr_debug("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
+	DP_DEBUG("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
 
 	mvid = (pixel_m & 0xFFFF) * 5;
 	nvid = (0xFFFF & (~pixel_n)) + (pixel_m & 0xFFFF);
@@ -164,7 +163,7 @@ static void dp_catalog_panel_config_msa_v200(struct dp_catalog_panel *panel,
 		nvid = temp;
 	}
 
-	pr_debug("rate = %d\n", rate);
+	DP_DEBUG("rate = %d\n", rate);
 
 	if (panel->widebus_en)
 		mvid <<= 1;
@@ -182,7 +181,7 @@ static void dp_catalog_panel_config_msa_v200(struct dp_catalog_panel *panel,
 		nvid_reg_off = DP1_SOFTWARE_NVID - DP_SOFTWARE_NVID;
 	}
 
-	pr_debug("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
+	DP_DEBUG("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
 	dp_write(catalog->exe_mode, io_data, DP_SOFTWARE_MVID + mvid_reg_off,
 			mvid);
 	dp_write(catalog->exe_mode, io_data, DP_SOFTWARE_NVID + nvid_reg_off,
@@ -198,7 +197,7 @@ static void dp_catalog_ctrl_lane_mapping_v200(struct dp_catalog_ctrl *ctrl,
 	u32 lane_map_reg = 0;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -273,7 +272,7 @@ int dp_catalog_get_v200(struct device *dev, struct dp_catalog *catalog,
 	struct dp_catalog_private_v200 *catalog_priv;
 
 	if (!dev || !catalog) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 

msm/dp/dp_catalog_v420.c

@@ -3,10 +3,10 @@
  * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
 
 #include "dp_catalog.h"
 #include "dp_reg.h"
+#include "dp_debug.h"
 
 #define dp_catalog_get_priv_v420(x) ({ \
 	struct dp_catalog *dp_catalog; \
@@ -90,7 +90,7 @@ static void dp_catalog_aux_setup_v420(struct dp_catalog_aux *aux,
 	int i = 0;
 
 	if (!aux || !cfg) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -109,7 +109,7 @@ static void dp_catalog_aux_setup_v420(struct dp_catalog_aux *aux,
 	io_data = catalog->io->dp_phy;
 	/* DP AUX CFG register programming */
 	for (i = 0; i < PHY_AUX_CFG_MAX; i++) {
-		pr_debug("%s: offset=0x%08x, value=0x%08x\n",
+		DP_DEBUG("%s: offset=0x%08x, value=0x%08x\n",
 			dp_phy_aux_config_type_to_string(i),
 			cfg[i].offset, cfg[i].lut[cfg[i].current_index]);
 		dp_write(catalog->exe_mode, io_data, cfg[i].offset,
@@ -128,7 +128,7 @@ static void dp_catalog_aux_clear_hw_interrupts_v420(struct dp_catalog_aux *aux)
 	u32 data = 0;
 
 	if (!aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -161,12 +161,12 @@ static void dp_catalog_panel_config_msa_v420(struct dp_catalog_panel *panel,
 	struct dp_io_data *io_data;
 
 	if (!panel || !rate) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream id:%d\n", panel->stream_id);
+		DP_ERR("invalid stream id:%d\n", panel->stream_id);
 		return;
 	}
 
@@ -180,7 +180,7 @@ static void dp_catalog_panel_config_msa_v420(struct dp_catalog_panel *panel,
 			MMSS_DP_PIXEL_M_V420 + reg_off);
 	pixel_n = dp_read(catalog->exe_mode, io_data,
 			MMSS_DP_PIXEL_N_V420 + reg_off);
-	pr_debug("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
+	DP_DEBUG("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
 
 	mvid = (pixel_m & 0xFFFF) * 5;
 	nvid = (0xFFFF & (~pixel_n)) + (pixel_m & 0xFFFF);
@@ -193,7 +193,7 @@ static void dp_catalog_panel_config_msa_v420(struct dp_catalog_panel *panel,
 		nvid = temp;
 	}
 
-	pr_debug("rate = %d\n", rate);
+	DP_DEBUG("rate = %d\n", rate);
 
 	if (panel->widebus_en)
 		mvid <<= 1;
@@ -211,7 +211,7 @@ static void dp_catalog_panel_config_msa_v420(struct dp_catalog_panel *panel,
 		nvid_off = DP1_SOFTWARE_NVID - DP_SOFTWARE_NVID;
 	}
 
-	pr_debug("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
+	DP_DEBUG("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
 	dp_write(catalog->exe_mode, io_data, DP_SOFTWARE_MVID + mvid_off, mvid);
 	dp_write(catalog->exe_mode, io_data, DP_SOFTWARE_NVID + nvid_off, nvid);
 }
@@ -225,7 +225,7 @@ static void dp_catalog_ctrl_phy_lane_cfg_v420(struct dp_catalog_ctrl *ctrl,
 	struct dp_io_data *io_data;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -234,7 +234,7 @@ static void dp_catalog_ctrl_phy_lane_cfg_v420(struct dp_catalog_ctrl *ctrl,
 
 	info |= (ln_cnt & 0x0F);
 	info |= ((orientation & 0x0F) << 4);
-	pr_debug("Shared Info = 0x%x\n", info);
+	DP_DEBUG("Shared Info = 0x%x\n", info);
 
 	dp_write(catalog->exe_mode, io_data, DP_PHY_SPARE0_V420, info);
 }
@@ -249,11 +249,11 @@ static void dp_catalog_ctrl_update_vx_px_v420(struct dp_catalog_ctrl *ctrl,
 
 	if (!ctrl || !((v_level < MAX_VOLTAGE_LEVELS)
 		&& (p_level < MAX_PRE_EMP_LEVELS))) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
-	pr_debug("hw: v=%d p=%d, high=%d\n", v_level, p_level, high);
+	DP_DEBUG("hw: v=%d p=%d, high=%d\n", v_level, p_level, high);
 
 	catalog = dp_catalog_get_priv_v420(ctrl);
 
@@ -300,10 +300,10 @@ static void dp_catalog_ctrl_update_vx_px_v420(struct dp_catalog_ctrl *ctrl,
 		dp_write(catalog->exe_mode, io_data, TXn_TX_EMP_POST1_LVL,
 				value1);
 
-		pr_debug("hw: vx_value=0x%x px_value=0x%x\n",
+		DP_DEBUG("hw: vx_value=0x%x px_value=0x%x\n",
 			value0, value1);
 	} else {
-		pr_err("invalid vx (0x%x=0x%x), px (0x%x=0x%x\n",
+		DP_ERR("invalid vx (0x%x=0x%x), px (0x%x=0x%x\n",
 			v_level, value0, p_level, value1);
 	}
 }
@@ -361,7 +361,7 @@ int dp_catalog_get_v420(struct device *dev, struct dp_catalog *catalog,
 	struct dp_catalog_private_v420 *catalog_priv;
 
 	if (!dev || !catalog) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 

msm/dp/dp_ctrl.c

@@ -3,16 +3,15 @@
  * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/types.h>
 #include <linux/completion.h>
 #include <linux/delay.h>
 #include <drm/drm_fixed.h>
 
 #include "dp_ctrl.h"
+#include "dp_debug.h"
 
-#define DP_MST_DEBUG(fmt, ...) pr_debug(fmt, ##__VA_ARGS__)
+#define DP_MST_DEBUG(fmt, ...) DP_DEBUG(fmt, ##__VA_ARGS__)
 
 #define DP_CTRL_INTR_READY_FOR_VIDEO     BIT(0)
 #define DP_CTRL_INTR_IDLE_PATTERN_SENT  BIT(3)
@@ -91,13 +90,13 @@ enum notification_status {
 
 static void dp_ctrl_idle_patterns_sent(struct dp_ctrl_private *ctrl)
 {
-	pr_debug("idle_patterns_sent\n");
+	DP_DEBUG("idle_patterns_sent\n");
 	complete(&ctrl->idle_comp);
 }
 
 static void dp_ctrl_video_ready(struct dp_ctrl_private *ctrl)
 {
-	pr_debug("dp_video_ready\n");
+	DP_DEBUG("dp_video_ready\n");
 	complete(&ctrl->video_comp);
 }
 
@@ -106,7 +105,7 @@ static void dp_ctrl_abort(struct dp_ctrl *dp_ctrl)
 	struct dp_ctrl_private *ctrl;
 
 	if (!dp_ctrl) {
-		pr_err("Invalid input data\n");
+		DP_ERR("Invalid input data\n");
 		return;
 	}
 
@@ -135,7 +134,7 @@ static void dp_ctrl_push_idle(struct dp_ctrl_private *ctrl,
 	}
 
 	if (strm >= DP_STREAM_MAX) {
-		pr_err("mst push idle, invalid stream:%d\n", strm);
+		DP_ERR("mst push idle, invalid stream:%d\n", strm);
 		return;
 	}
 
@@ -147,9 +146,9 @@ trigger_idle:
 
 	if (!wait_for_completion_timeout(&ctrl->idle_comp,
 			idle_pattern_completion_timeout_ms))
-		pr_warn("time out\n");
+		DP_WARN("time out\n");
 	else
-		pr_debug("mainlink off done\n");
+		DP_DEBUG("mainlink off done\n");
 }
 
 /**
@@ -182,7 +181,7 @@ static void dp_ctrl_configure_source_link_params(struct dp_ctrl_private *ctrl,
 static void dp_ctrl_wait4video_ready(struct dp_ctrl_private *ctrl)
 {
 	if (!wait_for_completion_timeout(&ctrl->video_comp, HZ / 2))
-		pr_warn("SEND_VIDEO time out\n");
+		DP_WARN("SEND_VIDEO time out\n");
 }
 
 static int dp_ctrl_update_sink_vx_px(struct dp_ctrl_private *ctrl)
@@ -195,12 +194,12 @@ static int dp_ctrl_update_sink_vx_px(struct dp_ctrl_private *ctrl)
 	u32 max_level_reached = 0;
 
 	if (v_level == DP_LINK_VOLTAGE_MAX) {
-		pr_debug("max voltage swing level reached %d\n", v_level);
+		DP_DEBUG("max voltage swing level reached %d\n", v_level);
 		max_level_reached |= DP_TRAIN_MAX_SWING_REACHED;
 	}
 
 	if (p_level == DP_LINK_PRE_EMPHASIS_MAX) {
-		pr_debug("max pre-emphasis level reached %d\n", p_level);
+		DP_DEBUG("max pre-emphasis level reached %d\n", p_level);
 		max_level_reached |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
 	}
 
@@ -209,7 +208,7 @@ static int dp_ctrl_update_sink_vx_px(struct dp_ctrl_private *ctrl)
 	for (i = 0; i < size; i++)
 		buf[i] = v_level | p_level | max_level_reached;
 
-	pr_debug("lanes: %d, swing: 0x%x, pre-emp: 0x%x\n",
+	DP_DEBUG("lanes: %d, swing: 0x%x, pre-emp: 0x%x\n",
 			size, v_level, p_level);
 
 	ret = drm_dp_dpcd_write(ctrl->aux->drm_aux,
@@ -236,7 +235,7 @@ static int dp_ctrl_update_sink_pattern(struct dp_ctrl_private *ctrl, u8 pattern)
 	u8 buf = pattern;
 	int ret;
 
-	pr_debug("sink: pattern=%x\n", pattern);
+	DP_DEBUG("sink: pattern=%x\n", pattern);
 
 	if (pattern && pattern != DP_TRAINING_PATTERN_4)
 		buf |= DP_LINK_SCRAMBLING_DISABLE;
@@ -258,7 +257,7 @@ static int dp_ctrl_read_link_status(struct dp_ctrl_private *ctrl,
 		len = drm_dp_dpcd_read_link_status(ctrl->aux->drm_aux,
 			link_status);
 		if (len != DP_LINK_STATUS_SIZE) {
-			pr_err("DP link status read failed, err: %d\n", len);
+			DP_ERR("DP link status read failed, err: %d\n", len);
 			ret = len;
 			break;
 		}
@@ -291,7 +290,7 @@ static int dp_ctrl_lane_count_down_shift(struct dp_ctrl_private *ctrl)
 		break;
 	}
 
-	pr_debug("new lane count=%d\n", ctrl->link->link_params.lane_count);
+	DP_DEBUG("new lane count=%d\n", ctrl->link->link_params.lane_count);
 
 	return ret;
 }
@@ -371,7 +370,7 @@ static int dp_ctrl_link_training_1(struct dp_ctrl_private *ctrl)
 
 		if (old_v_level == ctrl->link->phy_params.v_level) {
 			if (++tries >= maximum_retries) {
-				pr_err("max tries reached\n");
+				DP_ERR("max tries reached\n");
 				ret = -ETIMEDOUT;
 				break;
 			}
@@ -380,7 +379,7 @@ static int dp_ctrl_link_training_1(struct dp_ctrl_private *ctrl)
 			old_v_level = ctrl->link->phy_params.v_level;
 		}
 
-		pr_debug("clock recovery not done, adjusting vx px\n");
+		DP_DEBUG("clock recovery not done, adjusting vx px\n");
 
 		ctrl->link->adjust_levels(ctrl->link, link_status);
 	}
@@ -428,7 +427,7 @@ static int dp_ctrl_link_rate_down_shift(struct dp_ctrl_private *ctrl)
 		break;
 	}
 
-	pr_debug("new bw code=0x%x\n", ctrl->link->link_params.bw_code);
+	DP_DEBUG("new bw code=0x%x\n", ctrl->link->link_params.bw_code);
 
 	return ret;
 }
@@ -550,21 +549,21 @@ static int dp_ctrl_link_train(struct dp_ctrl_private *ctrl)
 
 	ret = dp_ctrl_link_training_1(ctrl);
 	if (ret) {
-		pr_err("link training #1 failed\n");
+		DP_ERR("link training #1 failed\n");
 		goto end;
 	}
 
 	/* print success info as this is a result of user initiated action */
-	pr_info("link training #1 successful\n");
+	DP_INFO("link training #1 successful\n");
 
 	ret = dp_ctrl_link_training_2(ctrl);
 	if (ret) {
-		pr_err("link training #2 failed\n");
+		DP_ERR("link training #2 failed\n");
 		goto end;
 	}
 
 	/* print success info as this is a result of user initiated action */
-	pr_info("link training #2 successful\n");
+	DP_INFO("link training #2 successful\n");
 
 end:
 	dp_ctrl_state_ctrl(ctrl, 0);
@@ -610,12 +609,12 @@ static void dp_ctrl_set_clock_rate(struct dp_ctrl_private *ctrl,
 		cfg++;
 	}
 
-	pr_debug("setting rate=%d on clk=%s\n", rate, name);
+	DP_DEBUG("setting rate=%d on clk=%s\n", rate, name);
 
 	if (num)
 		cfg->rate = rate;
 	else
-		pr_err("%s clock could not be set with rate %d\n", name, rate);
+		DP_ERR("%s clock could not be set with rate %d\n", name, rate);
 }
 
 static int dp_ctrl_enable_link_clock(struct dp_ctrl_private *ctrl)
@@ -624,13 +623,13 @@ static int dp_ctrl_enable_link_clock(struct dp_ctrl_private *ctrl)
 	u32 rate = drm_dp_bw_code_to_link_rate(ctrl->link->link_params.bw_code);
 	enum dp_pm_type type = DP_LINK_PM;
 
-	pr_debug("rate=%d\n", rate);
+	DP_DEBUG("rate=%d\n", rate);
 
 	dp_ctrl_set_clock_rate(ctrl, "link_clk", type, rate);
 
 	ret = ctrl->power->clk_enable(ctrl->power, type, true);
 	if (ret) {
-		pr_err("Unabled to start link clocks\n");
+		DP_ERR("Unabled to start link clocks\n");
 		ret = -EINVAL;
 	}
 
@@ -656,7 +655,7 @@ static int dp_ctrl_link_setup(struct dp_ctrl_private *ctrl, bool shallow)
 				link_params->lane_count);
 
 	while (1) {
-		pr_debug("bw_code=%d, lane_count=%d\n",
+		DP_DEBUG("bw_code=%d, lane_count=%d\n",
 			link_params->bw_code, link_params->lane_count);
 
 		rc = dp_ctrl_enable_link_clock(ctrl);
@@ -722,7 +721,7 @@ static int dp_ctrl_enable_stream_clocks(struct dp_ctrl_private *ctrl,
 		clk_type = DP_STREAM1_PM;
 		strlcpy(clk_name, "strm1_pixel_clk", 32);
 	} else {
-		pr_err("Invalid stream:%d for clk enable\n",
+		DP_ERR("Invalid stream:%d for clk enable\n",
 				dp_panel->stream_id);
 		return -EINVAL;
 	}
@@ -735,7 +734,7 @@ static int dp_ctrl_enable_stream_clocks(struct dp_ctrl_private *ctrl,
 
 	ret = ctrl->power->clk_enable(ctrl->power, clk_type, true);
 	if (ret) {
-		pr_err("Unabled to start stream:%d clocks\n",
+		DP_ERR("Unabled to start stream:%d clocks\n",
 				dp_panel->stream_id);
 		ret = -EINVAL;
 	}
@@ -755,7 +754,7 @@ static int dp_ctrl_disable_stream_clocks(struct dp_ctrl_private *ctrl,
 		return ctrl->power->clk_enable(ctrl->power,
 				DP_STREAM1_PM, false);
 	} else {
-		pr_err("Invalid stream:%d for clk disable\n",
+		DP_ERR("Invalid stream:%d for clk disable\n",
 				dp_panel->stream_id);
 		ret = -EINVAL;
 	}
@@ -767,7 +766,7 @@ static int dp_ctrl_host_init(struct dp_ctrl *dp_ctrl, bool flip, bool reset)
 	struct dp_catalog_ctrl *catalog;
 
 	if (!dp_ctrl) {
-		pr_err("Invalid input data\n");
+		DP_ERR("Invalid input data\n");
 		return -EINVAL;
 	}
 
@@ -798,7 +797,7 @@ static void dp_ctrl_host_deinit(struct dp_ctrl *dp_ctrl)
 	struct dp_ctrl_private *ctrl;
 
 	if (!dp_ctrl) {
-		pr_err("Invalid input data\n");
+		DP_ERR("Invalid input data\n");
 		return;
 	}
 
@@ -806,7 +805,7 @@ static void dp_ctrl_host_deinit(struct dp_ctrl *dp_ctrl)
 
 	ctrl->catalog->enable_irq(ctrl->catalog, false);
 
-	pr_debug("Host deinitialized successfully\n");
+	DP_DEBUG("Host deinitialized successfully\n");
 }
 
 static void dp_ctrl_send_video(struct dp_ctrl_private *ctrl)
@@ -820,7 +819,7 @@ static int dp_ctrl_link_maintenance(struct dp_ctrl *dp_ctrl)
 	struct dp_ctrl_private *ctrl;
 
 	if (!dp_ctrl) {
-		pr_err("Invalid input data\n");
+		DP_ERR("Invalid input data\n");
 		return -EINVAL;
 	}
 
@@ -830,7 +829,7 @@ static int dp_ctrl_link_maintenance(struct dp_ctrl *dp_ctrl)
 	ctrl->aux->state &= ~DP_STATE_LINK_MAINTENANCE_FAILED;
 
 	if (!ctrl->power_on) {
-		pr_err("ctrl off\n");
+		DP_ERR("ctrl off\n");
 		ret = -EINVAL;
 		goto end;
 	}
@@ -863,18 +862,18 @@ static void dp_ctrl_process_phy_test_request(struct dp_ctrl *dp_ctrl)
 	struct dp_ctrl_private *ctrl;
 
 	if (!dp_ctrl) {
-		pr_err("Invalid input data\n");
+		DP_ERR("Invalid input data\n");
 		return;
 	}
 
 	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
 
 	if (!ctrl->link->phy_params.phy_test_pattern_sel) {
-		pr_debug("no test pattern selected by sink\n");
+		DP_DEBUG("no test pattern selected by sink\n");
 		return;
 	}
 
-	pr_debug("start\n");
+	DP_DEBUG("start\n");
 
 	/*
 	 * The global reset will need DP link ralated clocks to be
@@ -891,10 +890,10 @@ static void dp_ctrl_process_phy_test_request(struct dp_ctrl *dp_ctrl)
 	ret = ctrl->dp_ctrl.on(&ctrl->dp_ctrl, ctrl->mst_mode,
 					ctrl->fec_mode, false);
 	if (ret)
-		pr_err("failed to enable DP controller\n");
+		DP_ERR("failed to enable DP controller\n");
 
 	ctrl->dp_ctrl.stream_on(&ctrl->dp_ctrl, ctrl->panel);
-	pr_debug("end\n");
+	DP_DEBUG("end\n");
 }
 
 static void dp_ctrl_send_phy_test_pattern(struct dp_ctrl_private *ctrl)
@@ -909,7 +908,7 @@ static void dp_ctrl_send_phy_test_pattern(struct dp_ctrl_private *ctrl)
 	ctrl->link->send_test_response(ctrl->link);
 
 	pattern_sent = ctrl->catalog->read_phy_pattern(ctrl->catalog);
-	pr_debug("pattern_request: %s. pattern_sent: 0x%x\n",
+	DP_DEBUG("pattern_request: %s. pattern_sent: 0x%x\n",
 			dp_link_get_phy_test_pattern(pattern_requested),
 			pattern_sent);
 
@@ -945,7 +944,7 @@ static void dp_ctrl_send_phy_test_pattern(struct dp_ctrl_private *ctrl)
 		break;
 	}
 
-	pr_debug("%s: %s\n", success ? "success" : "failed",
+	DP_DEBUG("%s: %s\n", success ? "success" : "failed",
 			dp_link_get_phy_test_pattern(pattern_requested));
 }
 
@@ -982,8 +981,8 @@ static void dp_ctrl_mst_calculate_rg(struct dp_ctrl_private *ctrl,
 	denominator = drm_fixp_from_fraction(2, 1);
 	raw_target_sc = drm_fixp_div(numerator, denominator);
 
-	pr_debug("raw_target_sc before overhead:0x%llx\n", raw_target_sc);
-	pr_debug("dsc_overhead_fp:0x%llx\n", panel->pinfo.dsc_overhead_fp);
+	DP_DEBUG("raw_target_sc before overhead:0x%llx\n", raw_target_sc);
+	DP_DEBUG("dsc_overhead_fp:0x%llx\n", panel->pinfo.dsc_overhead_fp);
 
 	/* apply fec and dsc overhead factor */
 	if (panel->pinfo.dsc_overhead_fp)
@@ -994,7 +993,7 @@ static void dp_ctrl_mst_calculate_rg(struct dp_ctrl_private *ctrl,
 		raw_target_sc = drm_fixp_mul(raw_target_sc,
 					panel->fec_overhead_fp);
 
-	pr_debug("raw_target_sc after overhead:0x%llx\n", raw_target_sc);
+	DP_DEBUG("raw_target_sc after overhead:0x%llx\n", raw_target_sc);
 
 	/* target_sc */
 	temp = drm_fixp_from_fraction(256 * lanes, 1);
@@ -1039,7 +1038,7 @@ static void dp_ctrl_mst_calculate_rg(struct dp_ctrl_private *ctrl,
 	*p_x_int = x_int;
 	*p_y_frac_enum = y_frac_enum;
 
-	pr_debug("x_int: %d, y_frac_enum: %d\n", x_int, y_frac_enum);
+	DP_DEBUG("x_int: %d, y_frac_enum: %d\n", x_int, y_frac_enum);
 }
 
 static int dp_ctrl_mst_send_act(struct dp_ctrl_private *ctrl)
@@ -1055,7 +1054,7 @@ static int dp_ctrl_mst_send_act(struct dp_ctrl_private *ctrl)
 	ctrl->catalog->read_act_complete_sts(ctrl->catalog, &act_complete);
 
 	if (!act_complete)
-		pr_err("mst act trigger complete failed\n");
+		DP_ERR("mst act trigger complete failed\n");
 	else
 		DP_MST_DEBUG("mst ACT trigger complete SUCCESS\n");
 
@@ -1111,13 +1110,13 @@ static void dp_ctrl_fec_dsc_setup(struct dp_ctrl_private *ctrl)
 	/* wait for controller to start fec sequence */
 	usleep_range(900, 1000);
 	drm_dp_dpcd_readb(ctrl->aux->drm_aux, fec_sts_dpcd, &fec_sts);
-	pr_debug("sink fec status:%d\n", fec_sts);
+	DP_DEBUG("sink fec status:%d\n", fec_sts);
 
 	dsc_enable = ctrl->fec_mode ? 1 : 0;
 	rlen = drm_dp_dpcd_writeb(ctrl->aux->drm_aux, DP_DSC_ENABLE,
 			dsc_enable);
 	if (rlen < 1)
-		pr_debug("failed to enable sink dsc\n");
+		DP_DEBUG("failed to enable sink dsc\n");
 }
 
 static int dp_ctrl_stream_on(struct dp_ctrl *dp_ctrl, struct dp_panel *panel)
@@ -1133,7 +1132,7 @@ static int dp_ctrl_stream_on(struct dp_ctrl *dp_ctrl, struct dp_panel *panel)
 
 	rc = dp_ctrl_enable_stream_clocks(ctrl, panel);
 	if (rc) {
-		pr_err("failure on stream clock enable\n");
+		DP_ERR("failure on stream clock enable\n");
 		return rc;
 	}
 
@@ -1159,7 +1158,7 @@ static int dp_ctrl_stream_on(struct dp_ctrl *dp_ctrl, struct dp_panel *panel)
 	ctrl->stream_count++;
 
 	link_ready = ctrl->catalog->mainlink_ready(ctrl->catalog);
-	pr_debug("mainlink %s\n", link_ready ? "READY" : "NOT READY");
+	DP_DEBUG("mainlink %s\n", link_ready ? "READY" : "NOT READY");
 
 	return rc;
 }
@@ -1188,7 +1187,7 @@ static void dp_ctrl_mst_stream_pre_off(struct dp_ctrl *dp_ctrl,
 	ctrl->catalog->read_act_complete_sts(ctrl->catalog, &act_complete);
 
 	if (!act_complete)
-		pr_err("mst stream_off act trigger complete failed\n");
+		DP_ERR("mst stream_off act trigger complete failed\n");
 	else
 		DP_MST_DEBUG("mst stream_off ACT trigger complete SUCCESS\n");
 }
@@ -1199,7 +1198,7 @@ static void dp_ctrl_stream_pre_off(struct dp_ctrl *dp_ctrl,
 	struct dp_ctrl_private *ctrl;
 
 	if (!dp_ctrl || !panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1252,7 +1251,7 @@ static int dp_ctrl_on(struct dp_ctrl *dp_ctrl, bool mst_mode,
 	rate = ctrl->panel->link_info.rate;
 
 	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN) {
-		pr_debug("using phy test link parameters\n");
+		DP_DEBUG("using phy test link parameters\n");
 	} else {
 		ctrl->link->link_params.bw_code =
 			drm_dp_link_rate_to_bw_code(rate);
@@ -1260,7 +1259,7 @@ static int dp_ctrl_on(struct dp_ctrl *dp_ctrl, bool mst_mode,
 			ctrl->panel->link_info.num_lanes;
 	}
 
-	pr_debug("bw_code=%d, lane_count=%d\n",
+	DP_DEBUG("bw_code=%d, lane_count=%d\n",
 		ctrl->link->link_params.bw_code,
 		ctrl->link->link_params.lane_count);
 
@@ -1298,7 +1297,7 @@ static void dp_ctrl_off(struct dp_ctrl *dp_ctrl)
 	ctrl->fec_mode = false;
 	ctrl->power_on = false;
 	memset(&ctrl->mst_ch_info, 0, sizeof(ctrl->mst_ch_info));
-	pr_debug("DP off done\n");
+	DP_DEBUG("DP off done\n");
 }
 
 static void dp_ctrl_set_mst_channel_info(struct dp_ctrl *dp_ctrl,
@@ -1308,7 +1307,7 @@ static void dp_ctrl_set_mst_channel_info(struct dp_ctrl *dp_ctrl,
 	struct dp_ctrl_private *ctrl;
 
 	if (!dp_ctrl || strm >= DP_STREAM_MAX) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1350,7 +1349,7 @@ struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in)
 
 	if (!in->dev || !in->panel || !in->aux ||
 	    !in->link || !in->catalog) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}

msm/dp/dp_debug.c

@@ -3,8 +3,6 @@
  * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/debugfs.h>
 #include <linux/slab.h>
 
@@ -115,7 +113,7 @@ static ssize_t dp_debug_write_edid(struct file *file,
 		goto bail;
 
 	if (edid_size != debug->edid_size) {
-		pr_debug("realloc debug edid\n");
+		DP_DEBUG("realloc debug edid\n");
 
 		if (debug->edid) {
 			devm_kfree(debug->dev, debug->edid);
@@ -143,7 +141,7 @@ static ssize_t dp_debug_write_edid(struct file *file,
 		t[char_to_nib] = '\0';
 
 		if (kstrtoint(t, 16, &d)) {
-			pr_err("kstrtoint error\n");
+			DP_ERR("kstrtoint error\n");
 			goto bail;
 		}
 
@@ -163,7 +161,7 @@ bail:
 	 * only while running in debug mode which is manually
 	 * triggered by a tester or a script.
 	 */
-	pr_info("[%s]\n", edid ? "SET" : "CLEAR");
+	DP_INFO("[%s]\n", edid ? "SET" : "CLEAR");
 
 	mutex_unlock(&debug->lock);
 	return rc;
@@ -208,7 +206,7 @@ static ssize_t dp_debug_write_dpcd(struct file *file,
 	offset_ch[4] = '\0';
 
 	if (kstrtoint(offset_ch, 16, &offset)) {
-		pr_err("offset kstrtoint error\n");
+		DP_ERR("offset kstrtoint error\n");
 		goto bail;
 	}
 
@@ -216,7 +214,7 @@ static ssize_t dp_debug_write_dpcd(struct file *file,
 		goto bail;
 
 	if (offset == 0xFFFF) {
-		pr_err("clearing dpcd\n");
+		DP_ERR("clearing dpcd\n");
 		memset(debug->dpcd, 0, debug->dpcd_size);
 		goto bail;
 	}
@@ -237,7 +235,7 @@ static ssize_t dp_debug_write_dpcd(struct file *file,
 		t[char_to_nib] = '\0';
 
 		if (kstrtoint(t, 16, &d)) {
-			pr_err("kstrtoint error\n");
+			DP_ERR("kstrtoint error\n");
 			goto bail;
 		}
 
@@ -263,7 +261,7 @@ bail:
 		 * only while running in debug mode which is manually
 		 * triggered by a tester or a script.
 		 */
-		pr_info("[%s]\n", dpcd ? "SET" : "CLEAR");
+		DP_INFO("[%s]\n", dpcd ? "SET" : "CLEAR");
 	} else
 		debug->aux->dpcd_updated(debug->aux);
 
@@ -348,7 +346,7 @@ static ssize_t dp_debug_write_hpd(struct file *file,
 	 * only while running in debug mode which is manually
 	 * triggered by a tester or a script.
 	 */
-	pr_info("%s\n", debug->hotplug ? "[CONNECT]" : "[DISCONNECT]");
+	DP_INFO("%s\n", debug->hotplug ? "[CONNECT]" : "[DISCONNECT]");
 
 	debug->hpd->simulate_connect(debug->hpd, debug->hotplug);
 end:
@@ -390,7 +388,7 @@ static ssize_t dp_debug_write_edid_modes(struct file *file,
 	debug->dp_debug.aspect_ratio = aspect_ratio;
 	goto end;
 clear:
-	pr_debug("clearing debug modes\n");
+	DP_DEBUG("clearing debug modes\n");
 	debug->dp_debug.debug_en = false;
 end:
 	return len;
@@ -440,7 +438,7 @@ static ssize_t dp_debug_write_edid_modes_mst(struct file *file,
 		}
 
 		if (!in_list)
-			pr_debug("dp connector id %d is invalid\n", con_id);
+			DP_DEBUG("dp connector id %d is invalid\n", con_id);
 
 		in_list = false;
 		read_buf += offset;
@@ -497,7 +495,7 @@ static ssize_t dp_debug_write_mst_con_id(struct file *file,
 	mutex_unlock(&debug->dp_debug.dp_mst_connector_list.lock);
 
 	if (!in_list)
-		pr_err("invalid connector id %u\n", con_id);
+		DP_ERR("invalid connector id %u\n", con_id);
 	else if (status != connector_status_unknown) {
 		debug->dp_debug.mst_hpd_sim = true;
 		debug->hpd->simulate_attention(debug->hpd, vdo);
@@ -505,7 +503,7 @@ static ssize_t dp_debug_write_mst_con_id(struct file *file,
 
 	goto end;
 clear:
-	pr_debug("clearing mst_con_id\n");
+	DP_DEBUG("clearing mst_con_id\n");
 	debug->mst_con_id = 0;
 end:
 	return len;
@@ -620,11 +618,11 @@ static ssize_t dp_debug_bw_code_write(struct file *file,
 		return 0;
 
 	if (!is_link_rate_valid(max_bw_code)) {
-		pr_err("Unsupported bw code %d\n", max_bw_code);
+		DP_ERR("Unsupported bw code %d\n", max_bw_code);
 		return len;
 	}
 	debug->panel->max_bw_code = max_bw_code;
-	pr_debug("max_bw_code: %d\n", max_bw_code);
+	DP_DEBUG("max_bw_code: %d\n", max_bw_code);
 
 	return len;
 }
@@ -668,7 +666,7 @@ static ssize_t dp_debug_mst_mode_write(struct file *file,
 		return 0;
 
 	debug->parser->has_mst = mst_mode ? true : false;
-	pr_debug("mst_enable: %d\n", mst_mode);
+	DP_DEBUG("mst_enable: %d\n", mst_mode);
 
 	return len;
 }
@@ -697,12 +695,12 @@ static ssize_t dp_debug_max_pclk_khz_write(struct file *file,
 		return 0;
 
 	if (max_pclk > debug->parser->max_pclk_khz)
-		pr_err("requested: %d, max_pclk_khz:%d\n", max_pclk,
+		DP_ERR("requested: %d, max_pclk_khz:%d\n", max_pclk,
 				debug->parser->max_pclk_khz);
 	else
 		debug->dp_debug.max_pclk_khz = max_pclk;
 
-	pr_debug("max_pclk_khz: %d\n", max_pclk);
+	DP_DEBUG("max_pclk_khz: %d\n", max_pclk);
 
 	return len;
 }
@@ -759,19 +757,19 @@ static ssize_t dp_debug_mst_sideband_mode_write(struct file *file,
 	buf[len] = '\0';
 
 	if (sscanf(buf, "%d %u", &mst_sideband_mode, &mst_port_cnt) != 2) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
 	if (mst_port_cnt > DP_MST_SIM_MAX_PORTS) {
-		pr_err("port cnt:%d exceeding max:%d\n", mst_port_cnt,
+		DP_ERR("port cnt:%d exceeding max:%d\n", mst_port_cnt,
 				DP_MST_SIM_MAX_PORTS);
 		return -EINVAL;
 	}
 
 	debug->parser->has_mst_sideband = mst_sideband_mode ? true : false;
 	debug->dp_debug.mst_port_cnt = mst_port_cnt;
-	pr_debug("mst_sideband_mode: %d port_cnt:%d\n",
+	DP_DEBUG("mst_sideband_mode: %d port_cnt:%d\n",
 			mst_sideband_mode, mst_port_cnt);
 	return count;
 }
@@ -800,7 +798,7 @@ static ssize_t dp_debug_widebus_mode_write(struct file *file,
 		return -EINVAL;
 
 	debug->parser->has_widebus = widebus_mode ? true : false;
-	pr_debug("widebus_enable: %d\n", widebus_mode);
+	DP_DEBUG("widebus_enable: %d\n", widebus_mode);
 
 	return len;
 }
@@ -830,7 +828,7 @@ static ssize_t dp_debug_tpg_write(struct file *file,
 		goto bail;
 
 	tpg_state &= 0x1;
-	pr_debug("tpg_state: %d\n", tpg_state);
+	DP_DEBUG("tpg_state: %d\n", tpg_state);
 
 	if (tpg_state == debug->dp_debug.tpg_state)
 		goto bail;
@@ -950,7 +948,7 @@ static ssize_t dp_debug_read_hdcp(struct file *file,
 static int dp_debug_check_buffer_overflow(int rc, int *max_size, int *len)
 {
 	if (rc >= *max_size) {
-		pr_err("buffer overflow\n");
+		DP_ERR("buffer overflow\n");
 		return -EINVAL;
 	}
 	*len += rc;
@@ -970,7 +968,7 @@ static ssize_t dp_debug_read_edid_modes(struct file *file,
 	struct drm_display_mode *mode;
 
 	if (!debug) {
-		pr_err("invalid data\n");
+		DP_ERR("invalid data\n");
 		rc = -ENODEV;
 		goto error;
 	}
@@ -978,7 +976,7 @@ static ssize_t dp_debug_read_edid_modes(struct file *file,
 	connector = *debug->connector;
 
 	if (!connector) {
-		pr_err("connector is NULL\n");
+		DP_ERR("connector is NULL\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -1030,7 +1028,7 @@ static ssize_t dp_debug_read_edid_modes_mst(struct file *file,
 	bool in_list = false;
 
 	if (!debug) {
-		pr_err("invalid data\n");
+		DP_ERR("invalid data\n");
 		rc = -ENODEV;
 		goto error;
 	}
@@ -1046,13 +1044,13 @@ static ssize_t dp_debug_read_edid_modes_mst(struct file *file,
 	mutex_unlock(&debug->dp_debug.dp_mst_connector_list.lock);
 
 	if (!in_list) {
-		pr_err("connector %u not in mst list\n", debug->mst_con_id);
+		DP_ERR("connector %u not in mst list\n", debug->mst_con_id);
 		rc = -EINVAL;
 		goto error;
 	}
 
 	if (!connector) {
-		pr_err("connector is NULL\n");
+		DP_ERR("connector is NULL\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -1101,7 +1099,7 @@ static ssize_t dp_debug_read_mst_con_id(struct file *file,
 	int rc = 0;
 
 	if (!debug) {
-		pr_err("invalid data\n");
+		DP_ERR("invalid data\n");
 		rc = -ENODEV;
 		goto error;
 	}
@@ -1143,7 +1141,7 @@ static ssize_t dp_debug_read_mst_conn_info(struct file *file,
 	struct drm_connector *connector;
 
 	if (!debug) {
-		pr_err("invalid data\n");
+		DP_ERR("invalid data\n");
 		rc = -ENODEV;
 		goto error;
 	}
@@ -1167,7 +1165,7 @@ static ssize_t dp_debug_read_mst_conn_info(struct file *file,
 		connector = mst_connector->conn;
 
 		if (!connector) {
-			pr_err("connector for id %d is NULL\n",
+			DP_ERR("connector for id %d is NULL\n",
 					mst_connector->con_id);
 			continue;
 		}
@@ -1488,14 +1486,14 @@ static ssize_t dp_debug_read_hdr(struct file *file,
 	struct drm_connector *connector;
 
 	if (!debug) {
-		pr_err("invalid data\n");
+		DP_ERR("invalid data\n");
 		return -ENODEV;
 	}
 
 	connector = *debug->connector;
 
 	if (!connector) {
-		pr_err("connector is NULL\n");
+		DP_ERR("connector is NULL\n");
 		return -EINVAL;
 	}
 
@@ -1533,7 +1531,7 @@ static ssize_t dp_debug_read_hdr_mst(struct file *file,
 	bool in_list = false;
 
 	if (!debug) {
-		pr_err("invalid data\n");
+		DP_ERR("invalid data\n");
 		return -ENODEV;
 	}
 
@@ -1548,12 +1546,12 @@ static ssize_t dp_debug_read_hdr_mst(struct file *file,
 	mutex_unlock(&debug->dp_debug.dp_mst_connector_list.lock);
 
 	if (!in_list) {
-		pr_err("connector %u not in mst list\n", debug->mst_con_id);
+		DP_ERR("connector %u not in mst list\n", debug->mst_con_id);
 		return -EINVAL;
 	}
 
 	if (!connector) {
-		pr_err("connector is NULL\n");
+		DP_ERR("connector is NULL\n");
 		return -EINVAL;
 	}
 
@@ -1598,7 +1596,7 @@ static void dp_debug_set_sim_mode(struct dp_debug_private *debug, bool sim)
 			debug->edid, debug->dpcd);
 	} else {
 		if (debug->hotplug) {
-			pr_warn("sim mode off before hotplug disconnect\n");
+			DP_WARN("sim mode off before hotplug disconnect\n");
 			debug->hpd->simulate_connect(debug->hpd, false);
 			debug->hotplug = false;
 		}
@@ -1626,7 +1624,7 @@ static void dp_debug_set_sim_mode(struct dp_debug_private *debug, bool sim)
 	 * only while running in debug mode which is manually
 	 * triggered by a tester or a script.
 	 */
-	pr_info("%s\n", sim ? "[ON]" : "[OFF]");
+	DP_INFO("%s\n", sim ? "[ON]" : "[OFF]");
 }
 
 static ssize_t dp_debug_write_sim(struct file *file,
@@ -1897,7 +1895,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			rc = -EINVAL;
 		else
 			rc = PTR_ERR(dir);
-		pr_err("[%s] debugfs create dir failed, rc = %d\n",
+		DP_ERR("[%s] debugfs create dir failed, rc = %d\n",
 		       DEBUG_NAME, rc);
 		goto error;
 	}
@@ -1908,7 +1906,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 				debug, &dp_debug_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs create file failed, rc=%d\n",
+		DP_ERR("[%s] debugfs create file failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -1917,7 +1915,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 					debug, &edid_modes_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs create edid_modes failed, rc=%d\n",
+		DP_ERR("[%s] debugfs create edid_modes failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -1926,7 +1924,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 					debug, &edid_modes_mst_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs create edid_modes_mst failed, rc=%d\n",
+		DP_ERR("[%s] debugfs create edid_modes_mst failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -1935,7 +1933,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 					debug, &mst_con_id_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs create mst_con_id failed, rc=%d\n",
+		DP_ERR("[%s] debugfs create mst_con_id failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -1944,7 +1942,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 					debug, &mst_conn_info_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs create mst_conn_info failed, rc=%d\n",
+		DP_ERR("[%s] debugfs create mst_conn_info failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -1971,7 +1969,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 					debug, &hpd_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs hpd failed, rc=%d\n",
+		DP_ERR("[%s] debugfs hpd failed, rc=%d\n",
 			DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -1980,7 +1978,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 					debug, &connected_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs connected failed, rc=%d\n",
+		DP_ERR("[%s] debugfs connected failed, rc=%d\n",
 			DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -1989,7 +1987,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			debug, &bw_code_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs max_bw_code failed, rc=%d\n",
+		DP_ERR("[%s] debugfs max_bw_code failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 	}
 
@@ -1997,7 +1995,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			debug, &exe_mode_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs register failed, rc=%d\n",
+		DP_ERR("[%s] debugfs register failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 	}
 
@@ -2005,7 +2003,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 					debug, &edid_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs edid failed, rc=%d\n",
+		DP_ERR("[%s] debugfs edid failed, rc=%d\n",
 			DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2014,7 +2012,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 					debug, &dpcd_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs dpcd failed, rc=%d\n",
+		DP_ERR("[%s] debugfs dpcd failed, rc=%d\n",
 			DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2023,7 +2021,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			debug, &tpg_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs tpg failed, rc=%d\n",
+		DP_ERR("[%s] debugfs tpg failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2033,7 +2031,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs hdr failed, rc=%d\n",
+		DP_ERR("[%s] debugfs hdr failed, rc=%d\n",
 			DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2043,7 +2041,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs hdr_mst failed, rc=%d\n",
+		DP_ERR("[%s] debugfs hdr_mst failed, rc=%d\n",
 			DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2053,7 +2051,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs sim failed, rc=%d\n",
+		DP_ERR("[%s] debugfs sim failed, rc=%d\n",
 			DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2063,7 +2061,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs attention failed, rc=%d\n",
+		DP_ERR("[%s] debugfs attention failed, rc=%d\n",
 			DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2073,7 +2071,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs dump failed, rc=%d\n",
+		DP_ERR("[%s] debugfs dump failed, rc=%d\n",
 			DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2082,7 +2080,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			debug, &mst_mode_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs max_bw_code failed, rc=%d\n",
+		DP_ERR("[%s] debugfs max_bw_code failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2091,7 +2089,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			debug, &mst_sideband_mode_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs max_bw_code failed, rc=%d\n",
+		DP_ERR("[%s] debugfs max_bw_code failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2100,7 +2098,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			debug, &max_pclk_khz_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs max_pclk_khz failed, rc=%d\n",
+		DP_ERR("[%s] debugfs max_pclk_khz failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2109,7 +2107,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			&debug->dp_debug.force_encryption);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs force_encryption failed, rc=%d\n",
+		DP_ERR("[%s] debugfs force_encryption failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2118,7 +2116,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 					debug, &hdcp_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs hdcp failed, rc=%d\n",
+		DP_ERR("[%s] debugfs hdcp failed, rc=%d\n",
 			DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2128,7 +2126,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs hdcp_wait_sink_sync failed, rc=%d\n",
+		DP_ERR("[%s] debugfs hdcp_wait_sink_sync failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 		goto error_remove_dir;
 	}
@@ -2137,7 +2135,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			&debug->parser->dsc_feature_enable);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs dsc_feature failed, rc=%d\n",
+		DP_ERR("[%s] debugfs dsc_feature failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 	}
 
@@ -2145,7 +2143,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			&debug->parser->fec_feature_enable);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs fec_feature_enable failed, rc=%d\n",
+		DP_ERR("[%s] debugfs fec_feature_enable failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 	}
 
@@ -2153,7 +2151,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			debug, &widebus_mode_fops);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs widebus failed, rc=%d\n",
+		DP_ERR("[%s] debugfs widebus failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 	}
 
@@ -2161,7 +2159,7 @@ static int dp_debug_init(struct dp_debug *dp_debug)
 			&debug->parser->max_lclk_khz);
 	if (IS_ERR_OR_NULL(file)) {
 		rc = PTR_ERR(file);
-		pr_err("[%s] debugfs max_lclk_khz failed, rc=%d\n",
+		DP_ERR("[%s] debugfs max_lclk_khz failed, rc=%d\n",
 		       DEBUG_NAME, rc);
 	}
 
@@ -2209,7 +2207,7 @@ struct dp_debug *dp_debug_get(struct dp_debug_in *in)
 
 	if (!in->dev || !in->panel || !in->hpd || !in->link ||
 	    !in->catalog || !in->ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}

msm/dp/dp_debug.h

@@ -13,6 +13,14 @@
 #include "dp_aux.h"
 #include "dp_display.h"
 
+#define DP_WARN(fmt, ...)	DRM_WARN("[msm-dp-warn] "fmt, ##__VA_ARGS__)
+#define DP_ERR(fmt, ...)	DRM_DEV_ERROR(NULL, "[msm-dp-error]" fmt, \
+								##__VA_ARGS__)
+#define DP_INFO(fmt, ...)	DRM_DEV_INFO(NULL, "[msm-dp-info] "fmt, \
+								##__VA_ARGS__)
+#define DP_DEBUG(fmt, ...)	DRM_DEV_DEBUG_DP(NULL, "[msm-dp-debug] "fmt, \
+								##__VA_ARGS__)
+
 /**
  * struct dp_debug
  * @debug_en: specifies whether debug mode enabled

msm/dp/dp_drm.c

@@ -3,8 +3,6 @@
  * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp]: %s: " fmt, __func__
-
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_atomic.h>
 #include <drm/drm_crtc.h>
@@ -15,7 +13,7 @@
 #include "dp_drm.h"
 #include "dp_debug.h"
 
-#define DP_MST_DEBUG(fmt, ...) pr_debug(fmt, ##__VA_ARGS__)
+#define DP_MST_DEBUG(fmt, ...) DP_DEBUG(fmt, ##__VA_ARGS__)
 
 #define to_dp_bridge(x)     container_of((x), struct dp_bridge, base)
 
@@ -65,11 +63,11 @@ static int dp_bridge_attach(struct drm_bridge *dp_bridge)
 	struct dp_bridge *bridge = to_dp_bridge(dp_bridge);
 
 	if (!dp_bridge) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return -EINVAL;
 	}
 
-	pr_debug("[%d] attached\n", bridge->id);
+	DP_DEBUG("[%d] attached\n", bridge->id);
 
 	return 0;
 }
@@ -81,7 +79,7 @@ static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge)
 	struct dp_display *dp;
 
 	if (!drm_bridge) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return;
 	}
 
@@ -89,26 +87,26 @@ static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge)
 	dp = bridge->display;
 
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		return;
 	}
 
 	if (!bridge->dp_panel) {
-		pr_err("Invalid dp_panel\n");
+		DP_ERR("Invalid dp_panel\n");
 		return;
 	}
 
 	/* By this point mode should have been validated through mode_fixup */
 	rc = dp->set_mode(dp, bridge->dp_panel, &bridge->dp_mode);
 	if (rc) {
-		pr_err("[%d] failed to perform a mode set, rc=%d\n",
+		DP_ERR("[%d] failed to perform a mode set, rc=%d\n",
 		       bridge->id, rc);
 		return;
 	}
 
 	rc = dp->prepare(dp, bridge->dp_panel);
 	if (rc) {
-		pr_err("[%d] DP display prepare failed, rc=%d\n",
+		DP_ERR("[%d] DP display prepare failed, rc=%d\n",
 		       bridge->id, rc);
 		return;
 	}
@@ -118,7 +116,7 @@ static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge)
 
 	rc = dp->enable(dp, bridge->dp_panel);
 	if (rc) {
-		pr_err("[%d] DP display enable failed, rc=%d\n",
+		DP_ERR("[%d] DP display enable failed, rc=%d\n",
 		       bridge->id, rc);
 		dp->unprepare(dp, bridge->dp_panel);
 	}
@@ -131,18 +129,18 @@ static void dp_bridge_enable(struct drm_bridge *drm_bridge)
 	struct dp_display *dp;
 
 	if (!drm_bridge) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return;
 	}
 
 	bridge = to_dp_bridge(drm_bridge);
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		return;
 	}
 
 	if (!bridge->dp_panel) {
-		pr_err("Invalid dp_panel\n");
+		DP_ERR("Invalid dp_panel\n");
 		return;
 	}
 
@@ -150,7 +148,7 @@ static void dp_bridge_enable(struct drm_bridge *drm_bridge)
 
 	rc = dp->post_enable(dp, bridge->dp_panel);
 	if (rc)
-		pr_err("[%d] DP display post enable failed, rc=%d\n",
+		DP_ERR("[%d] DP display post enable failed, rc=%d\n",
 		       bridge->id, rc);
 }
 
@@ -161,25 +159,25 @@ static void dp_bridge_disable(struct drm_bridge *drm_bridge)
 	struct dp_display *dp;
 
 	if (!drm_bridge) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return;
 	}
 
 	bridge = to_dp_bridge(drm_bridge);
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		return;
 	}
 
 	if (!bridge->dp_panel) {
-		pr_err("Invalid dp_panel\n");
+		DP_ERR("Invalid dp_panel\n");
 		return;
 	}
 
 	dp = bridge->display;
 
 	if (!dp) {
-		pr_err("dp is null\n");
+		DP_ERR("dp is null\n");
 		return;
 	}
 
@@ -188,7 +186,7 @@ static void dp_bridge_disable(struct drm_bridge *drm_bridge)
 
 	rc = dp->pre_disable(dp, bridge->dp_panel);
 	if (rc) {
-		pr_err("[%d] DP display pre disable failed, rc=%d\n",
+		DP_ERR("[%d] DP display pre disable failed, rc=%d\n",
 		       bridge->id, rc);
 	}
 }
@@ -200,18 +198,18 @@ static void dp_bridge_post_disable(struct drm_bridge *drm_bridge)
 	struct dp_display *dp;
 
 	if (!drm_bridge) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return;
 	}
 
 	bridge = to_dp_bridge(drm_bridge);
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		return;
 	}
 
 	if (!bridge->dp_panel) {
-		pr_err("Invalid dp_panel\n");
+		DP_ERR("Invalid dp_panel\n");
 		return;
 	}
 
@@ -219,14 +217,14 @@ static void dp_bridge_post_disable(struct drm_bridge *drm_bridge)
 
 	rc = dp->disable(dp, bridge->dp_panel);
 	if (rc) {
-		pr_err("[%d] DP display disable failed, rc=%d\n",
+		DP_ERR("[%d] DP display disable failed, rc=%d\n",
 		       bridge->id, rc);
 		return;
 	}
 
 	rc = dp->unprepare(dp, bridge->dp_panel);
 	if (rc) {
-		pr_err("[%d] DP display unprepare failed, rc=%d\n",
+		DP_ERR("[%d] DP display unprepare failed, rc=%d\n",
 		       bridge->id, rc);
 		return;
 	}
@@ -240,18 +238,18 @@ static void dp_bridge_mode_set(struct drm_bridge *drm_bridge,
 	struct dp_display *dp;
 
 	if (!drm_bridge || !mode || !adjusted_mode) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return;
 	}
 
 	bridge = to_dp_bridge(drm_bridge);
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		return;
 	}
 
 	if (!bridge->dp_panel) {
-		pr_err("Invalid dp_panel\n");
+		DP_ERR("Invalid dp_panel\n");
 		return;
 	}
 
@@ -271,20 +269,20 @@ static bool dp_bridge_mode_fixup(struct drm_bridge *drm_bridge,
 	struct dp_display *dp;
 
 	if (!drm_bridge || !mode || !adjusted_mode) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		ret = false;
 		goto end;
 	}
 
 	bridge = to_dp_bridge(drm_bridge);
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		ret = false;
 		goto end;
 	}
 
 	if (!bridge->dp_panel) {
-		pr_err("Invalid dp_panel\n");
+		DP_ERR("Invalid dp_panel\n");
 		ret = false;
 		goto end;
 	}
@@ -314,13 +312,13 @@ int dp_connector_config_hdr(struct drm_connector *connector, void *display,
 	struct sde_connector *sde_conn;
 
 	if (!display || !c_state || !connector) {
-		pr_err("invalid params\n");
+		DP_ERR("invalid params\n");
 		return -EINVAL;
 	}
 
 	sde_conn = to_sde_connector(connector);
 	if (!sde_conn->drv_panel) {
-		pr_err("invalid dp panel\n");
+		DP_ERR("invalid dp panel\n");
 		return -EINVAL;
 	}
 
@@ -371,7 +369,7 @@ int dp_connector_get_mode_info(struct drm_connector *connector,
 
 	if (!drm_mode || !mode_info || !avail_res ||
 			!avail_res->max_mixer_width || !connector || !display) {
-		pr_err("invalid params\n");
+		DP_ERR("invalid params\n");
 		return -EINVAL;
 	}
 
@@ -410,7 +408,7 @@ int dp_connector_get_info(struct drm_connector *connector,
 	struct dp_display *display = data;
 
 	if (!info || !display || !display->drm_dev) {
-		pr_err("invalid params\n");
+		DP_ERR("invalid params\n");
 		return -EINVAL;
 	}
 
@@ -440,7 +438,7 @@ enum drm_connector_status dp_connector_detect(struct drm_connector *conn,
 	memset(&info, 0x0, sizeof(info));
 	rc = dp_connector_get_info(conn, &info, display);
 	if (rc) {
-		pr_err("failed to get display info, rc=%d\n", rc);
+		DP_ERR("failed to get display info, rc=%d\n", rc);
 		return connector_status_disconnected;
 	}
 
@@ -461,7 +459,7 @@ void dp_connector_post_open(struct drm_connector *connector, void *display)
 	struct dp_display *dp;
 
 	if (!display) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -485,7 +483,7 @@ int dp_connector_get_modes(struct drm_connector *connector,
 
 	sde_conn = to_sde_connector(connector);
 	if (!sde_conn->drv_panel) {
-		pr_err("invalid dp panel\n");
+		DP_ERR("invalid dp panel\n");
 		return 0;
 	}
 
@@ -499,14 +497,14 @@ int dp_connector_get_modes(struct drm_connector *connector,
 	if (dp->is_sst_connected) {
 		rc = dp->get_modes(dp, sde_conn->drv_panel, dp_mode);
 		if (!rc)
-			pr_err("failed to get DP sink modes, rc=%d\n", rc);
+			DP_ERR("failed to get DP sink modes, rc=%d\n", rc);
 
 		if (dp_mode->timing.pixel_clk_khz) { /* valid DP mode */
 			memset(&drm_mode, 0x0, sizeof(drm_mode));
 			convert_to_drm_mode(dp_mode, &drm_mode);
 			m = drm_mode_duplicate(connector->dev, &drm_mode);
 			if (!m) {
-				pr_err("failed to add mode %ux%u\n",
+				DP_ERR("failed to add mode %ux%u\n",
 				       drm_mode.hdisplay,
 				       drm_mode.vdisplay);
 				kfree(dp_mode);
@@ -517,7 +515,7 @@ int dp_connector_get_modes(struct drm_connector *connector,
 			drm_mode_probed_add(connector, m);
 		}
 	} else {
-		pr_err("No sink connected\n");
+		DP_ERR("No sink connected\n");
 	}
 	kfree(dp_mode);
 
@@ -547,13 +545,13 @@ int dp_drm_bridge_init(void *data, struct drm_encoder *encoder)
 
 	rc = drm_bridge_attach(encoder, &bridge->base, NULL);
 	if (rc) {
-		pr_err("failed to attach bridge, rc=%d\n", rc);
+		DP_ERR("failed to attach bridge, rc=%d\n", rc);
 		goto error_free_bridge;
 	}
 
 	rc = display->request_irq(display);
 	if (rc) {
-		pr_err("request_irq failed, rc=%d\n", rc);
+		DP_ERR("request_irq failed, rc=%d\n", rc);
 		goto error_free_bridge;
 	}
 
@@ -587,13 +585,13 @@ enum drm_mode_status dp_connector_mode_valid(struct drm_connector *connector,
 	struct sde_connector *sde_conn;
 
 	if (!mode || !display || !connector) {
-		pr_err("invalid params\n");
+		DP_ERR("invalid params\n");
 		return MODE_ERROR;
 	}
 
 	sde_conn = to_sde_connector(connector);
 	if (!sde_conn->drv_panel) {
-		pr_err("invalid dp panel\n");
+		DP_ERR("invalid dp panel\n");
 		return MODE_ERROR;
 	}
 
@@ -611,13 +609,13 @@ int dp_connector_update_pps(struct drm_connector *connector,
 	struct sde_connector *sde_conn;
 
 	if (!display || !connector) {
-		pr_err("invalid params\n");
+		DP_ERR("invalid params\n");
 		return -EINVAL;
 	}
 
 	sde_conn = to_sde_connector(connector);
 	if (!sde_conn->drv_panel) {
-		pr_err("invalid dp panel\n");
+		DP_ERR("invalid dp panel\n");
 		return MODE_ERROR;
 	}
 

msm/dp/dp_gpio_hpd.c

@@ -3,8 +3,6 @@
  * Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
@@ -15,6 +13,7 @@
 #include <linux/sde_io_util.h>
 #include <linux/of_gpio.h>
 #include "dp_gpio_hpd.h"
+#include "dp_debug.h"
 
 struct dp_gpio_hpd_private {
 	struct device *dev;
@@ -31,7 +30,7 @@ static int dp_gpio_hpd_connect(struct dp_gpio_hpd_private *gpio_hpd, bool hpd)
 	int rc = 0;
 
 	if (!gpio_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -43,7 +42,7 @@ static int dp_gpio_hpd_connect(struct dp_gpio_hpd_private *gpio_hpd, bool hpd)
 	if (!gpio_hpd->cb ||
 		!gpio_hpd->cb->configure ||
 		!gpio_hpd->cb->disconnect) {
-		pr_err("invalid cb\n");
+		DP_ERR("invalid cb\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -62,7 +61,7 @@ static int dp_gpio_hpd_attention(struct dp_gpio_hpd_private *gpio_hpd)
 	int rc = 0;
 
 	if (!gpio_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -144,7 +143,7 @@ static void dp_gpio_hpd_work(struct work_struct *work)
 	}
 
 	if (ret < 0)
-		pr_err("Cannot claim IRQ dp-gpio-intp\n");
+		DP_ERR("Cannot claim IRQ dp-gpio-intp\n");
 }
 
 static int dp_gpio_hpd_simulate_connect(struct dp_hpd *dp_hpd, bool hpd)
@@ -153,7 +152,7 @@ static int dp_gpio_hpd_simulate_connect(struct dp_hpd *dp_hpd, bool hpd)
 	struct dp_gpio_hpd_private *gpio_hpd;
 
 	if (!dp_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -171,7 +170,7 @@ static int dp_gpio_hpd_simulate_attention(struct dp_hpd *dp_hpd, int vdo)
 	struct dp_gpio_hpd_private *gpio_hpd;
 
 	if (!dp_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -202,7 +201,7 @@ int dp_gpio_hpd_register(struct dp_hpd *dp_hpd)
 		edge | IRQF_ONESHOT,
 		"dp-gpio-intp", gpio_hpd);
 	if (rc) {
-		pr_err("Failed to request INTP threaded IRQ: %d\n", rc);
+		DP_ERR("Failed to request INTP threaded IRQ: %d\n", rc);
 		return rc;
 	}
 
@@ -221,7 +220,7 @@ struct dp_hpd *dp_gpio_hpd_get(struct device *dev,
 	struct dp_pinctrl pinctrl = {0};
 
 	if (!dev || !cb) {
-		pr_err("invalid device\n");
+		DP_ERR("invalid device\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -240,7 +239,7 @@ struct dp_hpd *dp_gpio_hpd_get(struct device *dev,
 			rc = pinctrl_select_state(pinctrl.pin,
 					pinctrl.state_hpd_active);
 			if (rc) {
-				pr_err("failed to set hpd active state\n");
+				DP_ERR("failed to set hpd active state\n");
 				goto gpio_error;
 			}
 		}
@@ -249,7 +248,7 @@ struct dp_hpd *dp_gpio_hpd_get(struct device *dev,
 	gpio_hpd->gpio_cfg.gpio = of_get_named_gpio(dev->of_node,
 		hpd_gpio_name, 0);
 	if (!gpio_is_valid(gpio_hpd->gpio_cfg.gpio)) {
-		pr_err("%s gpio not specified\n", hpd_gpio_name);
+		DP_ERR("%s gpio not specified\n", hpd_gpio_name);
 		rc = -EINVAL;
 		goto gpio_error;
 	}
@@ -261,7 +260,7 @@ struct dp_hpd *dp_gpio_hpd_get(struct device *dev,
 	rc = gpio_request(gpio_hpd->gpio_cfg.gpio,
 		gpio_hpd->gpio_cfg.gpio_name);
 	if (rc) {
-		pr_err("%s: failed to request gpio\n", hpd_gpio_name);
+		DP_ERR("%s: failed to request gpio\n", hpd_gpio_name);
 		goto gpio_error;
 	}
 	gpio_direction_input(gpio_hpd->gpio_cfg.gpio);

msm/dp/dp_hdcp2p2.c

@@ -3,8 +3,6 @@
  * Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[dp-hdcp2p2] %s: " fmt, __func__
-
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/slab.h>
@@ -16,6 +14,7 @@
 #include <drm/drm_dp_helper.h>
 
 #include "sde_hdcp_2x.h"
+#include "dp_debug.h"
 
 #define DP_INTR_STATUS2				(0x00000024)
 #define DP_INTR_STATUS3				(0x00000028)
@@ -68,17 +67,17 @@ struct dp_hdcp2p2_interrupts {
 static inline int dp_hdcp2p2_valid_handle(struct dp_hdcp2p2_ctrl *ctrl)
 {
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
 	if (!ctrl->lib_ctx) {
-		pr_err("HDCP library needs to be acquired\n");
+		DP_ERR("HDCP library needs to be acquired\n");
 		return -EINVAL;
 	}
 
 	if (!ctrl->lib) {
-		pr_err("invalid lib ops data\n");
+		DP_ERR("invalid lib ops data\n");
 		return -EINVAL;
 	}
 	return 0;
@@ -174,13 +173,13 @@ static int dp_hdcp2p2_wakeup(struct hdcp_transport_wakeup_data *data)
 	u32 const default_timeout_us = 500;
 
 	if (!data) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
 	ctrl = data->context;
 	if (!ctrl) {
-		pr_err("invalid ctrl\n");
+		DP_ERR("invalid ctrl\n");
 		return -EINVAL;
 	}
 
@@ -223,7 +222,7 @@ static inline void dp_hdcp2p2_wakeup_lib(struct dp_hdcp2p2_ctrl *ctrl,
 		data && (data->cmd != HDCP_2X_CMD_INVALID)) {
 		rc = ctrl->lib->wakeup(data);
 		if (rc)
-			pr_err("error sending %s to lib\n",
+			DP_ERR("error sending %s to lib\n",
 				sde_hdcp_2x_cmd_to_str(data->cmd));
 	}
 }
@@ -231,7 +230,7 @@ static inline void dp_hdcp2p2_wakeup_lib(struct dp_hdcp2p2_ctrl *ctrl,
 static void dp_hdcp2p2_reset(struct dp_hdcp2p2_ctrl *ctrl)
 {
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -274,7 +273,7 @@ static int dp_hdcp2p2_on(void *input)
 	cdata.context = ctrl->lib_ctx;
 	rc = ctrl->lib->wakeup(&cdata);
 	if (rc)
-		pr_err("Unable to start the HDCP 2.2 library (%d)\n", rc);
+		DP_ERR("Unable to start the HDCP 2.2 library (%d)\n", rc);
 
 	return rc;
 }
@@ -329,7 +328,7 @@ static int dp_hdcp2p2_reauthenticate(void *input)
 	struct dp_hdcp2p2_ctrl *ctrl = (struct dp_hdcp2p2_ctrl *)input;
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -346,12 +345,12 @@ static void dp_hdcp2p2_min_level_change(void *client_ctx,
 		HDCP_2X_CMD_MIN_ENC_LEVEL};
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (!dp_hdcp2p2_is_valid_state(ctrl)) {
-		pr_err("invalid state\n");
+		DP_ERR("invalid state\n");
 		return;
 	}
 
@@ -368,18 +367,18 @@ static int dp_hdcp2p2_aux_read_message(struct dp_hdcp2p2_ctrl *ctrl)
 
 	if (atomic_read(&ctrl->auth_state) == HDCP_STATE_INACTIVE ||
 		atomic_read(&ctrl->auth_state) == HDCP_STATE_AUTH_FAIL) {
-		pr_err("invalid hdcp state\n");
+		DP_ERR("invalid hdcp state\n");
 		rc = -EINVAL;
 		goto exit;
 	}
 
 	if (!buf) {
-		pr_err("invalid request buffer\n");
+		DP_ERR("invalid request buffer\n");
 		rc = -EINVAL;
 		goto exit;
 	}
 
-	pr_debug("offset(0x%x), size(%d)\n", offset, size);
+	DP_DEBUG("offset(0x%x), size(%d)\n", offset, size);
 
 	do {
 		read_size = min(size, max_size);
@@ -387,7 +386,7 @@ static int dp_hdcp2p2_aux_read_message(struct dp_hdcp2p2_ctrl *ctrl)
 		bytes_read = drm_dp_dpcd_read(ctrl->init_data.drm_aux,
 				offset, buf, read_size);
 		if (bytes_read != read_size) {
-			pr_err("fail: offset(0x%x), size(0x%x), rc(0x%x)\n",
+			DP_ERR("fail: offset(0x%x), size(0x%x), rc(0x%x)\n",
 					offset, read_size, bytes_read);
 			rc = -EINVAL;
 			break;
@@ -408,7 +407,7 @@ static int dp_hdcp2p2_aux_write_message(struct dp_hdcp2p2_ctrl *ctrl,
 	int const max_size = 16;
 	int rc = 0, write_size = 0, bytes_written = 0;
 
-	pr_debug("offset(0x%x), size(%d)\n", offset, size);
+	DP_DEBUG("offset(0x%x), size(%d)\n", offset, size);
 
 	do {
 		write_size = min(size, max_size);
@@ -416,7 +415,7 @@ static int dp_hdcp2p2_aux_write_message(struct dp_hdcp2p2_ctrl *ctrl,
 		bytes_written = drm_dp_dpcd_write(ctrl->init_data.drm_aux,
 				offset, buf, write_size);
 		if (bytes_written != write_size) {
-			pr_err("fail: offset(0x%x), size(0x%x), rc(0x%x)\n",
+			DP_ERR("fail: offset(0x%x), size(0x%x), rc(0x%x)\n",
 					offset, write_size, bytes_written);
 			rc = -EINVAL;
 			break;
@@ -470,7 +469,7 @@ static void dp_hdcp2p2_send_msg(struct dp_hdcp2p2_ctrl *ctrl)
 	struct sde_hdcp_2x_wakeup_data cdata = {HDCP_2X_CMD_INVALID};
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto exit;
 	}
@@ -478,7 +477,7 @@ static void dp_hdcp2p2_send_msg(struct dp_hdcp2p2_ctrl *ctrl)
 	cdata.context = ctrl->lib_ctx;
 
 	if (atomic_read(&ctrl->auth_state) == HDCP_STATE_INACTIVE) {
-		pr_err("hdcp is off\n");
+		DP_ERR("hdcp is off\n");
 		goto exit;
 	}
 
@@ -488,7 +487,7 @@ static void dp_hdcp2p2_send_msg(struct dp_hdcp2p2_ctrl *ctrl)
 			ctrl->response.length, ctrl->msg_part->offset,
 			ctrl->timeout);
 	if (rc) {
-		pr_err("Error sending msg to sink %d\n", rc);
+		DP_ERR("Error sending msg to sink %d\n", rc);
 		mutex_unlock(&ctrl->msg_lock);
 		goto exit;
 	}
@@ -515,7 +514,7 @@ static int dp_hdcp2p2_get_msg_from_sink(struct dp_hdcp2p2_ctrl *ctrl)
 
 	rc = dp_hdcp2p2_aux_read_message(ctrl);
 	if (rc) {
-		pr_err("error reading message %d\n", rc);
+		DP_ERR("error reading message %d\n", rc);
 		goto exit;
 	}
 
@@ -541,7 +540,7 @@ static void dp_hdcp2p2_recv_msg(struct dp_hdcp2p2_ctrl *ctrl)
 	cdata.context = ctrl->lib_ctx;
 
 	if (atomic_read(&ctrl->auth_state) == HDCP_STATE_INACTIVE) {
-		pr_err("hdcp is off\n");
+		DP_ERR("hdcp is off\n");
 		return;
 	}
 
@@ -554,13 +553,13 @@ static void dp_hdcp2p2_link_check(struct dp_hdcp2p2_ctrl *ctrl)
 	struct sde_hdcp_2x_wakeup_data cdata = {HDCP_2X_CMD_INVALID};
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (atomic_read(&ctrl->auth_state) == HDCP_STATE_AUTH_FAIL ||
 		atomic_read(&ctrl->auth_state) == HDCP_STATE_INACTIVE) {
-		pr_err("invalid hdcp state\n");
+		DP_ERR("invalid hdcp state\n");
 		return;
 	}
 
@@ -568,10 +567,10 @@ static void dp_hdcp2p2_link_check(struct dp_hdcp2p2_ctrl *ctrl)
 
 	if (ctrl->sink_rx_status & ctrl->abort_mask) {
 		if (ctrl->sink_rx_status & BIT(3))
-			pr_err("reauth_req set by sink\n");
+			DP_ERR("reauth_req set by sink\n");
 
 		if (ctrl->sink_rx_status & BIT(4))
-			pr_err("link failure reported by sink\n");
+			DP_ERR("link failure reported by sink\n");
 
 		ctrl->sink_rx_status = 0;
 		ctrl->rx_status = 0;
@@ -626,25 +625,25 @@ static int dp_hdcp2p2_read_rx_status(struct dp_hdcp2p2_ctrl *ctrl,
 	bytes_read = drm_dp_dpcd_read(ctrl->init_data.drm_aux,
 			cp_irq_dpcd_offset, &buf, bytes_to_read);
 	if (bytes_read != bytes_to_read) {
-		pr_err("cp irq read failed\n");
+		DP_ERR("cp irq read failed\n");
 		rc = bytes_read;
 		goto error;
 	}
 
 	cp_irq = buf & BIT(2);
-	pr_debug("cp_irq=0x%x\n", cp_irq);
+	DP_DEBUG("cp_irq=0x%x\n", cp_irq);
 	buf = 0;
 
 	if (cp_irq) {
 		bytes_read = drm_dp_dpcd_read(ctrl->init_data.drm_aux,
 				rxstatus_dpcd_offset, &buf, bytes_to_read);
 		if (bytes_read != bytes_to_read) {
-			pr_err("rxstatus read failed\n");
+			DP_ERR("rxstatus read failed\n");
 			rc = bytes_read;
 			goto error;
 		}
 		*rx_status = buf;
-		pr_debug("rx_status=0x%x\n", *rx_status);
+		DP_DEBUG("rx_status=0x%x\n", *rx_status);
 	}
 
 error:
@@ -662,21 +661,21 @@ static int dp_hdcp2p2_cp_irq(void *input)
 
 	if (atomic_read(&ctrl->auth_state) == HDCP_STATE_AUTH_FAIL ||
 		atomic_read(&ctrl->auth_state) == HDCP_STATE_INACTIVE) {
-		pr_err("invalid hdcp state\n");
+		DP_ERR("invalid hdcp state\n");
 		return -EINVAL;
 	}
 
 	ctrl->sink_rx_status = 0;
 	rc = dp_hdcp2p2_read_rx_status(ctrl, &ctrl->sink_rx_status);
 	if (rc) {
-		pr_err("failed to read rx status\n");
+		DP_ERR("failed to read rx status\n");
 		return rc;
 	}
 
-	pr_debug("sink_rx_status=0x%x\n", ctrl->sink_rx_status);
+	DP_DEBUG("sink_rx_status=0x%x\n", ctrl->sink_rx_status);
 
 	if (!ctrl->sink_rx_status) {
-		pr_debug("not a hdcp 2.2 irq\n");
+		DP_DEBUG("not a hdcp 2.2 irq\n");
 		return -EINVAL;
 	}
 
@@ -696,7 +695,7 @@ static int dp_hdcp2p2_isr(void *input)
 	u32 hdcp_int_val = 0;
 
 	if (!ctrl || !ctrl->init_data.dp_ahb) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -711,7 +710,7 @@ static int dp_hdcp2p2_isr(void *input)
 
 		while (int_set && int_set->interrupt) {
 			if (hdcp_int_val & (int_set->interrupt >> 2)) {
-				pr_debug("%s\n", int_set->name);
+				DP_DEBUG("%s\n", int_set->name);
 
 				if (int_set->func)
 					int_set->func(ctrl);
@@ -734,17 +733,17 @@ static bool dp_hdcp2p2_supported(void *input)
 	ssize_t bytes_read = 0;
 	u8 buf[DP_HDCP_RXCAPS_LENGTH];
 
-	pr_debug("Checking sink capability\n");
+	DP_DEBUG("Checking sink capability\n");
 
 	bytes_read = drm_dp_dpcd_read(ctrl->init_data.drm_aux,
 			rxcaps_dpcd_offset, &buf, DP_HDCP_RXCAPS_LENGTH);
 	if (bytes_read != DP_HDCP_RXCAPS_LENGTH) {
-		pr_err("RxCaps read failed\n");
+		DP_ERR("RxCaps read failed\n");
 		goto error;
 	}
 
-	pr_debug("HDCP_CAPABLE=%lu\n", (buf[2] & BIT(1)) >> 1);
-	pr_debug("VERSION=%d\n", buf[0]);
+	DP_DEBUG("HDCP_CAPABLE=%lu\n", (buf[2] & BIT(1)) >> 1);
+	DP_DEBUG("VERSION=%d\n", buf[0]);
 
 	if ((buf[2] & BIT(1)) && (buf[0] == 0x2))
 		return true;
@@ -756,17 +755,17 @@ static int dp_hdcp2p2_change_streams(struct dp_hdcp2p2_ctrl *ctrl,
 		struct sde_hdcp_2x_wakeup_data *cdata)
 {
 	if (!ctrl || cdata->num_streams == 0 || !cdata->streams) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
 	if (!ctrl->lib_ctx) {
-		pr_err("HDCP library needs to be acquired\n");
+		DP_ERR("HDCP library needs to be acquired\n");
 		return -EINVAL;
 	}
 
 	if (!ctrl->lib) {
-		pr_err("invalid lib ops data\n");
+		DP_ERR("invalid lib ops data\n");
 		return -EINVAL;
 	}
 
@@ -803,7 +802,7 @@ void sde_dp_hdcp2p2_deinit(void *input)
 	struct sde_hdcp_2x_wakeup_data cdata = {HDCP_2X_CMD_INVALID};
 
 	if (!ctrl) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -921,7 +920,7 @@ void *sde_dp_hdcp2p2_init(struct sde_hdcp_init_data *init_data)
 
 	if (!init_data || !init_data->cb_data ||
 			!init_data->notify_status || !init_data->drm_aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return ERR_PTR(-EINVAL);
 	}
 
@@ -953,7 +952,7 @@ void *sde_dp_hdcp2p2_init(struct sde_hdcp_init_data *init_data)
 
 	rc = sde_hdcp_2x_register(&register_data);
 	if (rc) {
-		pr_err("Unable to register with HDCP 2.2 library\n");
+		DP_ERR("Unable to register with HDCP 2.2 library\n");
 		goto error;
 	}
 
@@ -964,7 +963,7 @@ void *sde_dp_hdcp2p2_init(struct sde_hdcp_init_data *init_data)
 	ctrl->thread = kthread_run(dp_hdcp2p2_main, ctrl, "dp_hdcp2p2");
 
 	if (IS_ERR(ctrl->thread)) {
-		pr_err("unable to start DP hdcp2p2 thread\n");
+		DP_ERR("unable to start DP hdcp2p2 thread\n");
 		rc = PTR_ERR(ctrl->thread);
 		ctrl->thread = NULL;
 		goto error;

msm/dp/dp_hpd.c

@@ -3,8 +3,6 @@
  * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/delay.h>
@@ -14,12 +12,13 @@
 #include "dp_usbpd.h"
 #include "dp_gpio_hpd.h"
 #include "dp_lphw_hpd.h"
+#include "dp_debug.h"
 
 static void dp_hpd_host_init(struct dp_hpd *dp_hpd,
 		struct dp_catalog_hpd *catalog)
 {
 	if (!catalog) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 	catalog->config_hpd(catalog, true);
@@ -29,7 +28,7 @@ static void dp_hpd_host_deinit(struct dp_hpd *dp_hpd,
 		struct dp_catalog_hpd *catalog)
 {
 	if (!catalog) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 	catalog->config_hpd(catalog, false);
@@ -47,21 +46,21 @@ struct dp_hpd *dp_hpd_get(struct device *dev, struct dp_parser *parser,
 	if (parser->no_aux_switch && parser->lphw_hpd) {
 		dp_hpd = dp_lphw_hpd_get(dev, parser, catalog, cb);
 		if (IS_ERR(dp_hpd)) {
-			pr_err("failed to get lphw hpd\n");
+			DP_ERR("failed to get lphw hpd\n");
 			return dp_hpd;
 		}
 		dp_hpd->type = DP_HPD_LPHW;
 	} else if (parser->no_aux_switch) {
 		dp_hpd = dp_gpio_hpd_get(dev, cb);
 		if (IS_ERR(dp_hpd)) {
-			pr_err("failed to get gpio hpd\n");
+			DP_ERR("failed to get gpio hpd\n");
 			return dp_hpd;
 		}
 		dp_hpd->type = DP_HPD_GPIO;
 	} else {
 		dp_hpd = dp_usbpd_get(dev, cb);
 		if (IS_ERR(dp_hpd)) {
-			pr_err("failed to get usbpd\n");
+			DP_ERR("failed to get usbpd\n");
 			return dp_hpd;
 		}
 		dp_hpd->type = DP_HPD_USBPD;
@@ -93,7 +92,7 @@ void dp_hpd_put(struct dp_hpd *dp_hpd)
 		dp_lphw_hpd_put(dp_hpd);
 		break;
 	default:
-		pr_err("unknown hpd type %d\n", dp_hpd->type);
+		DP_ERR("unknown hpd type %d\n", dp_hpd->type);
 		break;
 	}
 }

msm/dp/dp_link.c

@@ -3,10 +3,9 @@
  * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include "dp_link.h"
 #include "dp_panel.h"
+#include "dp_debug.h"
 
 enum dynamic_range {
 	DP_DYNAMIC_RANGE_RGB_VESA = 0x00,
@@ -90,7 +89,7 @@ static int dp_link_get_period(struct dp_link_private *link, int const addr)
 	/* TEST_AUDIO_PERIOD_CH_XX */
 	if (drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp,
 		param_len) < param_len) {
-		pr_err("failed to read test_audio_period (0x%x)\n", addr);
+		DP_ERR("failed to read test_audio_period (0x%x)\n", addr);
 		ret = -EINVAL;
 		goto exit;
 	}
@@ -100,7 +99,7 @@ static int dp_link_get_period(struct dp_link_private *link, int const addr)
 	/* Period - Bits 3:0 */
 	data = data & 0xF;
 	if ((int)data > max_audio_period) {
-		pr_err("invalid test_audio_period_ch_1 = 0x%x\n", data);
+		DP_ERR("invalid test_audio_period_ch_1 = 0x%x\n", data);
 		ret = -EINVAL;
 		goto exit;
 	}
@@ -120,14 +119,14 @@ static int dp_link_parse_audio_channel_period(struct dp_link_private *link)
 		goto exit;
 
 	req->test_audio_period_ch_1 = ret;
-	pr_debug("test_audio_period_ch_1 = 0x%x\n", ret);
+	DP_DEBUG("test_audio_period_ch_1 = 0x%x\n", ret);
 
 	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH2);
 	if (ret == -EINVAL)
 		goto exit;
 
 	req->test_audio_period_ch_2 = ret;
-	pr_debug("test_audio_period_ch_2 = 0x%x\n", ret);
+	DP_DEBUG("test_audio_period_ch_2 = 0x%x\n", ret);
 
 	/* TEST_AUDIO_PERIOD_CH_3 (Byte 0x275) */
 	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH3);
@@ -135,42 +134,42 @@ static int dp_link_parse_audio_channel_period(struct dp_link_private *link)
 		goto exit;
 
 	req->test_audio_period_ch_3 = ret;
-	pr_debug("test_audio_period_ch_3 = 0x%x\n", ret);
+	DP_DEBUG("test_audio_period_ch_3 = 0x%x\n", ret);
 
 	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH4);
 	if (ret == -EINVAL)
 		goto exit;
 
 	req->test_audio_period_ch_4 = ret;
-	pr_debug("test_audio_period_ch_4 = 0x%x\n", ret);
+	DP_DEBUG("test_audio_period_ch_4 = 0x%x\n", ret);
 
 	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH5);
 	if (ret == -EINVAL)
 		goto exit;
 
 	req->test_audio_period_ch_5 = ret;
-	pr_debug("test_audio_period_ch_5 = 0x%x\n", ret);
+	DP_DEBUG("test_audio_period_ch_5 = 0x%x\n", ret);
 
 	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH6);
 	if (ret == -EINVAL)
 		goto exit;
 
 	req->test_audio_period_ch_6 = ret;
-	pr_debug("test_audio_period_ch_6 = 0x%x\n", ret);
+	DP_DEBUG("test_audio_period_ch_6 = 0x%x\n", ret);
 
 	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH7);
 	if (ret == -EINVAL)
 		goto exit;
 
 	req->test_audio_period_ch_7 = ret;
-	pr_debug("test_audio_period_ch_7 = 0x%x\n", ret);
+	DP_DEBUG("test_audio_period_ch_7 = 0x%x\n", ret);
 
 	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH8);
 	if (ret == -EINVAL)
 		goto exit;
 
 	req->test_audio_period_ch_8 = ret;
-	pr_debug("test_audio_period_ch_8 = 0x%x\n", ret);
+	DP_DEBUG("test_audio_period_ch_8 = 0x%x\n", ret);
 exit:
 	return ret;
 }
@@ -187,7 +186,7 @@ static int dp_link_parse_audio_pattern_type(struct dp_link_private *link)
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
 		DP_TEST_AUDIO_PATTERN_TYPE, &bp, param_len);
 	if (rlen < param_len) {
-		pr_err("failed to read link audio mode data\n");
+		DP_ERR("failed to read link audio mode data\n");
 		ret = -EINVAL;
 		goto exit;
 	}
@@ -195,13 +194,13 @@ static int dp_link_parse_audio_pattern_type(struct dp_link_private *link)
 
 	/* Audio Pattern Type - Bits 7:0 */
 	if ((int)data > max_audio_pattern_type) {
-		pr_err("invalid audio pattern type = 0x%x\n", data);
+		DP_ERR("invalid audio pattern type = 0x%x\n", data);
 		ret = -EINVAL;
 		goto exit;
 	}
 
 	link->dp_link.test_audio.test_audio_pattern_type = data;
-	pr_debug("audio pattern type = %s\n",
+	DP_DEBUG("audio pattern type = %s\n",
 			dp_link_get_audio_test_pattern(data));
 exit:
 	return ret;
@@ -222,7 +221,7 @@ static int dp_link_parse_audio_mode(struct dp_link_private *link)
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_AUDIO_MODE,
 			&bp, param_len);
 	if (rlen < param_len) {
-		pr_err("failed to read link audio mode data\n");
+		DP_ERR("failed to read link audio mode data\n");
 		ret = -EINVAL;
 		goto exit;
 	}
@@ -231,7 +230,7 @@ static int dp_link_parse_audio_mode(struct dp_link_private *link)
 	/* Sampling Rate - Bits 3:0 */
 	sampling_rate = data & 0xF;
 	if (sampling_rate > max_audio_sampling_rate) {
-		pr_err("sampling rate (0x%x) greater than max (0x%x)\n",
+		DP_ERR("sampling rate (0x%x) greater than max (0x%x)\n",
 				sampling_rate, max_audio_sampling_rate);
 		ret = -EINVAL;
 		goto exit;
@@ -240,7 +239,7 @@ static int dp_link_parse_audio_mode(struct dp_link_private *link)
 	/* Channel Count - Bits 7:4 */
 	channel_count = ((data & 0xF0) >> 4) + 1;
 	if (channel_count > max_audio_channel_count) {
-		pr_err("channel_count (0x%x) greater than max (0x%x)\n",
+		DP_ERR("channel_count (0x%x) greater than max (0x%x)\n",
 				channel_count, max_audio_channel_count);
 		ret = -EINVAL;
 		goto exit;
@@ -248,7 +247,7 @@ static int dp_link_parse_audio_mode(struct dp_link_private *link)
 
 	link->dp_link.test_audio.test_audio_sampling_rate = sampling_rate;
 	link->dp_link.test_audio.test_audio_channel_count = channel_count;
-	pr_debug("sampling_rate = %s, channel_count = 0x%x\n",
+	DP_DEBUG("sampling_rate = %s, channel_count = 0x%x\n",
 		dp_link_get_audio_sample_rate(sampling_rate), channel_count);
 exit:
 	return ret;
@@ -389,7 +388,7 @@ static int dp_link_parse_timing_params1(struct dp_link_private *link,
 	/* Read the requested video link pattern (Byte 0x221). */
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, bp, len);
 	if (rlen < len) {
-		pr_err("failed to read 0x%x\n", addr);
+		DP_ERR("failed to read 0x%x\n", addr);
 		return -EINVAL;
 	}
 
@@ -410,7 +409,7 @@ static int dp_link_parse_timing_params2(struct dp_link_private *link,
 	/* Read the requested video link pattern (Byte 0x221). */
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, bp, len);
 	if (rlen < len) {
-		pr_err("failed to read 0x%x\n", addr);
+		DP_ERR("failed to read 0x%x\n", addr);
 		return -EINVAL;
 	}
 
@@ -429,7 +428,7 @@ static int dp_link_parse_timing_params3(struct dp_link_private *link,
 
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp, len);
 	if (rlen < 1) {
-		pr_err("failed to read 0x%x\n", addr);
+		DP_ERR("failed to read 0x%x\n", addr);
 		return -EINVAL;
 	}
 	*val = bp;
@@ -456,20 +455,20 @@ static int dp_link_parse_video_pattern_params(struct dp_link_private *link)
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_PATTERN,
 			&bp, param_len);
 	if (rlen < param_len) {
-		pr_err("failed to read link video pattern\n");
+		DP_ERR("failed to read link video pattern\n");
 		ret = -EINVAL;
 		goto exit;
 	}
 	data = bp;
 
 	if (!dp_link_is_video_pattern_valid(data)) {
-		pr_err("invalid link video pattern = 0x%x\n", data);
+		DP_ERR("invalid link video pattern = 0x%x\n", data);
 		ret = -EINVAL;
 		goto exit;
 	}
 
 	link->dp_link.test_video.test_video_pattern = data;
-	pr_debug("link video pattern = 0x%x (%s)\n",
+	DP_DEBUG("link video pattern = 0x%x (%s)\n",
 		link->dp_link.test_video.test_video_pattern,
 		dp_link_video_pattern_to_string(
 			link->dp_link.test_video.test_video_pattern));
@@ -478,7 +477,7 @@ static int dp_link_parse_video_pattern_params(struct dp_link_private *link)
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_MISC0,
 			&bp, param_len);
 	if (rlen < param_len) {
-		pr_err("failed to read link bit depth\n");
+		DP_ERR("failed to read link bit depth\n");
 		ret = -EINVAL;
 		goto exit;
 	}
@@ -487,12 +486,12 @@ static int dp_link_parse_video_pattern_params(struct dp_link_private *link)
 	/* Dynamic Range */
 	dyn_range = (data & DP_TEST_DYNAMIC_RANGE_CEA) >> 3;
 	if (!dp_link_is_dynamic_range_valid(dyn_range)) {
-		pr_err("invalid link dynamic range = 0x%x\n", dyn_range);
+		DP_ERR("invalid link dynamic range = 0x%x\n", dyn_range);
 		ret = -EINVAL;
 		goto exit;
 	}
 	link->dp_link.test_video.test_dyn_range = dyn_range;
-	pr_debug("link dynamic range = 0x%x (%s)\n",
+	DP_DEBUG("link dynamic range = 0x%x (%s)\n",
 		link->dp_link.test_video.test_dyn_range,
 		dp_link_dynamic_range_to_string(
 			link->dp_link.test_video.test_dyn_range));
@@ -500,13 +499,13 @@ static int dp_link_parse_video_pattern_params(struct dp_link_private *link)
 	/* Color bit depth */
 	data &= DP_TEST_BIT_DEPTH_MASK;
 	if (!dp_link_is_bit_depth_valid(data)) {
-		pr_err("invalid link bit depth = 0x%x\n", data);
+		DP_ERR("invalid link bit depth = 0x%x\n", data);
 		ret = -EINVAL;
 		goto exit;
 	}
 
 	link->dp_link.test_video.test_bit_depth = data;
-	pr_debug("link bit depth = 0x%x (%s)\n",
+	DP_DEBUG("link bit depth = 0x%x (%s)\n",
 		link->dp_link.test_video.test_bit_depth,
 		dp_link_bit_depth_to_string(
 		link->dp_link.test_video.test_bit_depth));
@@ -515,93 +514,93 @@ static int dp_link_parse_video_pattern_params(struct dp_link_private *link)
 	ret = dp_link_parse_timing_params1(link, DP_TEST_H_TOTAL_HI, 2,
 			&link->dp_link.test_video.test_h_total);
 	if (ret) {
-		pr_err("failed to parse test_h_total (DP_TEST_H_TOTAL_HI)\n");
+		DP_ERR("failed to parse test_h_total (DP_TEST_H_TOTAL_HI)\n");
 		goto exit;
 	}
-	pr_debug("TEST_H_TOTAL = %d\n", link->dp_link.test_video.test_h_total);
+	DP_DEBUG("TEST_H_TOTAL = %d\n", link->dp_link.test_video.test_h_total);
 
 	ret = dp_link_parse_timing_params1(link, DP_TEST_V_TOTAL_HI, 2,
 			&link->dp_link.test_video.test_v_total);
 	if (ret) {
-		pr_err("failed to parse test_v_total (DP_TEST_V_TOTAL_HI)\n");
+		DP_ERR("failed to parse test_v_total (DP_TEST_V_TOTAL_HI)\n");
 		goto exit;
 	}
-	pr_debug("TEST_V_TOTAL = %d\n", link->dp_link.test_video.test_v_total);
+	DP_DEBUG("TEST_V_TOTAL = %d\n", link->dp_link.test_video.test_v_total);
 
 	ret = dp_link_parse_timing_params1(link, DP_TEST_H_START_HI, 2,
 			&link->dp_link.test_video.test_h_start);
 	if (ret) {
-		pr_err("failed to parse test_h_start (DP_TEST_H_START_HI)\n");
+		DP_ERR("failed to parse test_h_start (DP_TEST_H_START_HI)\n");
 		goto exit;
 	}
-	pr_debug("TEST_H_START = %d\n", link->dp_link.test_video.test_h_start);
+	DP_DEBUG("TEST_H_START = %d\n", link->dp_link.test_video.test_h_start);
 
 	ret = dp_link_parse_timing_params1(link, DP_TEST_V_START_HI, 2,
 			&link->dp_link.test_video.test_v_start);
 	if (ret) {
-		pr_err("failed to parse test_v_start (DP_TEST_V_START_HI)\n");
+		DP_ERR("failed to parse test_v_start (DP_TEST_V_START_HI)\n");
 		goto exit;
 	}
-	pr_debug("TEST_V_START = %d\n", link->dp_link.test_video.test_v_start);
+	DP_DEBUG("TEST_V_START = %d\n", link->dp_link.test_video.test_v_start);
 
 	ret = dp_link_parse_timing_params2(link, DP_TEST_HSYNC_HI, 2,
 			&link->dp_link.test_video.test_hsync_pol,
 			&link->dp_link.test_video.test_hsync_width);
 	if (ret) {
-		pr_err("failed to parse (DP_TEST_HSYNC_HI)\n");
+		DP_ERR("failed to parse (DP_TEST_HSYNC_HI)\n");
 		goto exit;
 	}
-	pr_debug("TEST_HSYNC_POL = %d\n",
+	DP_DEBUG("TEST_HSYNC_POL = %d\n",
 		link->dp_link.test_video.test_hsync_pol);
-	pr_debug("TEST_HSYNC_WIDTH = %d\n",
+	DP_DEBUG("TEST_HSYNC_WIDTH = %d\n",
 		link->dp_link.test_video.test_hsync_width);
 
 	ret = dp_link_parse_timing_params2(link, DP_TEST_VSYNC_HI, 2,
 			&link->dp_link.test_video.test_vsync_pol,
 			&link->dp_link.test_video.test_vsync_width);
 	if (ret) {
-		pr_err("failed to parse (DP_TEST_VSYNC_HI)\n");
+		DP_ERR("failed to parse (DP_TEST_VSYNC_HI)\n");
 		goto exit;
 	}
-	pr_debug("TEST_VSYNC_POL = %d\n",
+	DP_DEBUG("TEST_VSYNC_POL = %d\n",
 		link->dp_link.test_video.test_vsync_pol);
-	pr_debug("TEST_VSYNC_WIDTH = %d\n",
+	DP_DEBUG("TEST_VSYNC_WIDTH = %d\n",
 		link->dp_link.test_video.test_vsync_width);
 
 	ret = dp_link_parse_timing_params1(link, DP_TEST_H_WIDTH_HI, 2,
 			&link->dp_link.test_video.test_h_width);
 	if (ret) {
-		pr_err("failed to parse test_h_width (DP_TEST_H_WIDTH_HI)\n");
+		DP_ERR("failed to parse test_h_width (DP_TEST_H_WIDTH_HI)\n");
 		goto exit;
 	}
-	pr_debug("TEST_H_WIDTH = %d\n", link->dp_link.test_video.test_h_width);
+	DP_DEBUG("TEST_H_WIDTH = %d\n", link->dp_link.test_video.test_h_width);
 
 	ret = dp_link_parse_timing_params1(link, DP_TEST_V_HEIGHT_HI, 2,
 			&link->dp_link.test_video.test_v_height);
 	if (ret) {
-		pr_err("failed to parse test_v_height (DP_TEST_V_HEIGHT_HI)\n");
+		DP_ERR("failed to parse test_v_height (DP_TEST_V_HEIGHT_HI)\n");
 		goto exit;
 	}
-	pr_debug("TEST_V_HEIGHT = %d\n",
+	DP_DEBUG("TEST_V_HEIGHT = %d\n",
 		link->dp_link.test_video.test_v_height);
 
 	ret = dp_link_parse_timing_params3(link, DP_TEST_MISC1,
 		&link->dp_link.test_video.test_rr_d);
 	link->dp_link.test_video.test_rr_d &= DP_TEST_REFRESH_DENOMINATOR;
 	if (ret) {
-		pr_err("failed to parse test_rr_d (DP_TEST_MISC1)\n");
+		DP_ERR("failed to parse test_rr_d (DP_TEST_MISC1)\n");
 		goto exit;
 	}
-	pr_debug("TEST_REFRESH_DENOMINATOR = %d\n",
+	DP_DEBUG("TEST_REFRESH_DENOMINATOR = %d\n",
 		link->dp_link.test_video.test_rr_d);
 
 	ret = dp_link_parse_timing_params3(link, DP_TEST_REFRESH_RATE_NUMERATOR,
 		&link->dp_link.test_video.test_rr_n);
 	if (ret) {
-		pr_err("failed to parse test_rr_n (DP_TEST_REFRESH_RATE_NUMERATOR)\n");
+		DP_ERR("failed to parse test_rr_n (DP_TEST_REFRESH_RATE_NUMERATOR)\n");
 		goto exit;
 	}
-	pr_debug("TEST_REFRESH_NUMERATOR = %d\n",
+	DP_DEBUG("TEST_REFRESH_NUMERATOR = %d\n",
 		link->dp_link.test_video.test_rr_n);
 exit:
 	return ret;
@@ -626,25 +625,25 @@ static int dp_link_parse_link_training_params(struct dp_link_private *link)
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_LINK_RATE,
 			&bp, param_len);
 	if (rlen < param_len) {
-		pr_err("failed to read link rate\n");
+		DP_ERR("failed to read link rate\n");
 		ret = -EINVAL;
 		goto exit;
 	}
 	data = bp;
 
 	if (!is_link_rate_valid(data)) {
-		pr_err("invalid link rate = 0x%x\n", data);
+		DP_ERR("invalid link rate = 0x%x\n", data);
 		ret = -EINVAL;
 		goto exit;
 	}
 
 	link->request.test_link_rate = data;
-	pr_debug("link rate = 0x%x\n", link->request.test_link_rate);
+	DP_DEBUG("link rate = 0x%x\n", link->request.test_link_rate);
 
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_LANE_COUNT,
 			&bp, param_len);
 	if (rlen < param_len) {
-		pr_err("failed to read lane count\n");
+		DP_ERR("failed to read lane count\n");
 		ret = -EINVAL;
 		goto exit;
 	}
@@ -652,13 +651,13 @@ static int dp_link_parse_link_training_params(struct dp_link_private *link)
 	data &= 0x1F;
 
 	if (!is_lane_count_valid(data)) {
-		pr_err("invalid lane count = 0x%x\n", data);
+		DP_ERR("invalid lane count = 0x%x\n", data);
 		ret = -EINVAL;
 		goto exit;
 	}
 
 	link->request.test_lane_count = data;
-	pr_debug("lane count = 0x%x\n", link->request.test_lane_count);
+	DP_DEBUG("lane count = 0x%x\n", link->request.test_lane_count);
 exit:
 	return ret;
 }
@@ -697,7 +696,7 @@ static int dp_link_parse_phy_test_params(struct dp_link_private *link)
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_PHY_PATTERN,
 			&bp, param_len);
 	if (rlen < param_len) {
-		pr_err("failed to read phy link pattern\n");
+		DP_ERR("failed to read phy link pattern\n");
 		ret = -EINVAL;
 		goto end;
 	}
@@ -706,7 +705,7 @@ static int dp_link_parse_phy_test_params(struct dp_link_private *link)
 
 	link->dp_link.phy_params.phy_test_pattern_sel = data;
 
-	pr_debug("phy_test_pattern_sel = %s\n",
+	DP_DEBUG("phy_test_pattern_sel = %s\n",
 			dp_link_get_phy_test_pattern(data));
 
 	if (!dp_link_is_phy_test_pattern_supported(data))
@@ -772,7 +771,7 @@ static int dp_link_parse_request(struct dp_link_private *link)
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
 		DP_DEVICE_SERVICE_IRQ_VECTOR, &bp, param_len);
 	if (rlen < param_len) {
-		pr_err("aux read failed\n");
+		DP_ERR("aux read failed\n");
 		ret = -EINVAL;
 		goto end;
 	}
@@ -789,7 +788,7 @@ static int dp_link_parse_request(struct dp_link_private *link)
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_REQUEST,
 			&bp, param_len);
 	if (rlen < param_len) {
-		pr_err("aux read failed\n");
+		DP_ERR("aux read failed\n");
 		ret = -EINVAL;
 		goto end;
 	}
@@ -797,7 +796,7 @@ static int dp_link_parse_request(struct dp_link_private *link)
 	data = bp;
 
 	if (!dp_link_is_test_supported(data)) {
-		pr_debug("link 0x%x not supported\n", data);
+		DP_DEBUG("link 0x%x not supported\n", data);
 		goto end;
 	}
 
@@ -856,7 +855,7 @@ static int dp_link_parse_sink_count(struct dp_link *dp_link)
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_SINK_COUNT,
 			&link->dp_link.sink_count.count, param_len);
 	if (rlen < param_len) {
-		pr_err("failed to read sink count\n");
+		DP_ERR("failed to read sink count\n");
 		return -EINVAL;
 	}
 
@@ -866,7 +865,7 @@ static int dp_link_parse_sink_count(struct dp_link *dp_link)
 	link->dp_link.sink_count.count =
 		DP_GET_SINK_COUNT(link->dp_link.sink_count.count);
 
-	pr_debug("sink_count = 0x%x, cp_ready = 0x%x\n",
+	DP_DEBUG("sink_count = 0x%x, cp_ready = 0x%x\n",
 		link->dp_link.sink_count.count,
 		link->dp_link.sink_count.cp_ready);
 	return 0;
@@ -882,7 +881,7 @@ static void dp_link_parse_sink_status_field(struct dp_link_private *link)
 	len = drm_dp_dpcd_read_link_status(link->aux->drm_aux,
 		link->link_status);
 	if (len < DP_LINK_STATUS_SIZE)
-		pr_err("DP link status read failed\n");
+		DP_ERR("DP link status read failed\n");
 	dp_link_parse_request(link);
 }
 
@@ -907,7 +906,7 @@ static int dp_link_process_link_training_request(struct dp_link_private *link)
 	if (!dp_link_is_link_training_requested(link))
 		return -EINVAL;
 
-	pr_debug("%s link rate = 0x%x, lane count = 0x%x\n",
+	DP_DEBUG("%s link rate = 0x%x, lane count = 0x%x\n",
 			dp_link_get_test_name(DP_TEST_LINK_TRAINING),
 			link->request.test_link_rate,
 			link->request.test_lane_count);
@@ -924,7 +923,7 @@ static void dp_link_send_test_response(struct dp_link *dp_link)
 	u32 const response_len = 0x1;
 
 	if (!dp_link) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -941,7 +940,7 @@ static int dp_link_psm_config(struct dp_link *dp_link,
 	int ret = 0;
 
 	if (!dp_link) {
-		pr_err("invalid params\n");
+		DP_ERR("invalid params\n");
 		return -EINVAL;
 	}
 
@@ -953,7 +952,7 @@ static int dp_link_psm_config(struct dp_link *dp_link,
 		ret = drm_dp_link_power_up(link->aux->drm_aux, link_info);
 
 	if (ret)
-		pr_err("Failed to %s low power mode\n",
+		DP_ERR("Failed to %s low power mode\n",
 			(enable ? "enter" : "exit"));
 
 	return ret;
@@ -965,7 +964,7 @@ static void dp_link_send_edid_checksum(struct dp_link *dp_link, u8 checksum)
 	u32 const response_len = 0x1;
 
 	if (!dp_link) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -984,19 +983,19 @@ static int dp_link_parse_vx_px(struct dp_link_private *link)
 	u32 v0, p0, v1, p1, v2, p2, v3, p3;
 	int rlen;
 
-	pr_debug("\n");
+	DP_DEBUG("\n");
 
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_ADJUST_REQUEST_LANE0_1,
 			&bp, param_len);
 	if (rlen < param_len) {
-		pr_err("failed reading lanes 0/1\n");
+		DP_ERR("failed reading lanes 0/1\n");
 		ret = -EINVAL;
 		goto end;
 	}
 
 	data = bp;
 
-	pr_debug("lanes 0/1 (Byte 0x206): 0x%x\n", data);
+	DP_DEBUG("lanes 0/1 (Byte 0x206): 0x%x\n", data);
 
 	v0 = data & 0x3;
 	data = data >> 2;
@@ -1011,14 +1010,14 @@ static int dp_link_parse_vx_px(struct dp_link_private *link)
 	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_ADJUST_REQUEST_LANE2_3,
 			&bp, param_len);
 	if (rlen < param_len) {
-		pr_err("failed reading lanes 2/3\n");
+		DP_ERR("failed reading lanes 2/3\n");
 		ret = -EINVAL;
 		goto end;
 	}
 
 	data = bp;
 
-	pr_debug("lanes 2/3 (Byte 0x207): 0x%x\n", data);
+	DP_DEBUG("lanes 2/3 (Byte 0x207): 0x%x\n", data);
 
 	v2 = data & 0x3;
 	data = data >> 2;
@@ -1030,21 +1029,21 @@ static int dp_link_parse_vx_px(struct dp_link_private *link)
 	p3 = data & 0x3;
 	data = data >> 2;
 
-	pr_debug("vx: 0=%d, 1=%d, 2=%d, 3=%d\n", v0, v1, v2, v3);
-	pr_debug("px: 0=%d, 1=%d, 2=%d, 3=%d\n", p0, p1, p2, p3);
+	DP_DEBUG("vx: 0=%d, 1=%d, 2=%d, 3=%d\n", v0, v1, v2, v3);
+	DP_DEBUG("px: 0=%d, 1=%d, 2=%d, 3=%d\n", p0, p1, p2, p3);
 
 	/**
 	 * Update the voltage and pre-emphasis levels as per DPCD request
 	 * vector.
 	 */
-	pr_debug("Current: v_level = 0x%x, p_level = 0x%x\n",
+	DP_DEBUG("Current: v_level = 0x%x, p_level = 0x%x\n",
 			link->dp_link.phy_params.v_level,
 			link->dp_link.phy_params.p_level);
-	pr_debug("Requested: v_level = 0x%x, p_level = 0x%x\n", v0, p0);
+	DP_DEBUG("Requested: v_level = 0x%x, p_level = 0x%x\n", v0, p0);
 	link->dp_link.phy_params.v_level = v0;
 	link->dp_link.phy_params.p_level = p0;
 
-	pr_debug("Success\n");
+	DP_DEBUG("Success\n");
 end:
 	return ret;
 }
@@ -1063,7 +1062,7 @@ static int dp_link_process_phy_test_pattern_request(
 	u32 test_link_rate = 0, test_lane_count = 0;
 
 	if (!(link->request.test_requested & DP_TEST_LINK_PHY_TEST_PATTERN)) {
-		pr_debug("no phy test\n");
+		DP_DEBUG("no phy test\n");
 		return -EINVAL;
 	}
 
@@ -1072,18 +1071,18 @@ static int dp_link_process_phy_test_pattern_request(
 
 	if (!is_link_rate_valid(test_link_rate) ||
 		!is_lane_count_valid(test_lane_count)) {
-		pr_err("Invalid params: link rate = 0x%x, lane count = 0x%x\n",
+		DP_ERR("Invalid params: link rate = 0x%x, lane count = 0x%x\n",
 				test_link_rate, test_lane_count);
 		return -EINVAL;
 	}
 
-	pr_debug("start\n");
+	DP_DEBUG("start\n");
 
-	pr_info("Current: bw_code = 0x%x, lane count = 0x%x\n",
+	DP_INFO("Current: bw_code = 0x%x, lane count = 0x%x\n",
 			link->dp_link.link_params.bw_code,
 			link->dp_link.link_params.lane_count);
 
-	pr_info("Requested: bw_code = 0x%x, lane count = 0x%x\n",
+	DP_INFO("Requested: bw_code = 0x%x, lane count = 0x%x\n",
 			test_link_rate, test_lane_count);
 
 	link->dp_link.link_params.lane_count = link->request.test_lane_count;
@@ -1091,7 +1090,7 @@ static int dp_link_process_phy_test_pattern_request(
 
 	dp_link_parse_vx_px(link);
 
-	pr_debug("end\n");
+	DP_DEBUG("end\n");
 
 	return 0;
 }
@@ -1122,7 +1121,7 @@ static int dp_link_process_link_status_update(struct dp_link_private *link)
 			link->dp_link.link_params.lane_count)))
 		return -EINVAL;
 
-	pr_debug("channel_eq_done = %d, clock_recovery_done = %d\n",
+	DP_DEBUG("channel_eq_done = %d, clock_recovery_done = %d\n",
 			drm_dp_clock_recovery_ok(link->link_status,
 			link->dp_link.link_params.lane_count),
 			drm_dp_clock_recovery_ok(link->link_status,
@@ -1192,7 +1191,7 @@ static int dp_link_process_video_pattern_request(struct dp_link_private *link)
 	if (!dp_link_is_video_pattern_requested(link))
 		goto end;
 
-	pr_debug("%s: bit depth=%d(%d bpp) pattern=%s\n",
+	DP_DEBUG("%s: bit depth=%d(%d bpp) pattern=%s\n",
 		dp_link_get_test_name(DP_TEST_LINK_VIDEO_PATTERN),
 		link->dp_link.test_video.test_bit_depth,
 		dp_link_bit_depth_to_bpp(
@@ -1219,20 +1218,20 @@ static int dp_link_process_audio_pattern_request(struct dp_link_private *link)
 	if (!dp_link_is_audio_pattern_requested(link))
 		return -EINVAL;
 
-	pr_debug("sampling_rate=%s, channel_count=%d, pattern_type=%s\n",
+	DP_DEBUG("sampling_rate=%s, channel_count=%d, pattern_type=%s\n",
 		dp_link_get_audio_sample_rate(
 			link->dp_link.test_audio.test_audio_sampling_rate),
 		link->dp_link.test_audio.test_audio_channel_count,
 		dp_link_get_audio_test_pattern(
 			link->dp_link.test_audio.test_audio_pattern_type));
 
-	pr_debug("audio_period: ch1=0x%x, ch2=0x%x, ch3=0x%x, ch4=0x%x\n",
+	DP_DEBUG("audio_period: ch1=0x%x, ch2=0x%x, ch3=0x%x, ch4=0x%x\n",
 		link->dp_link.test_audio.test_audio_period_ch_1,
 		link->dp_link.test_audio.test_audio_period_ch_2,
 		link->dp_link.test_audio.test_audio_period_ch_3,
 		link->dp_link.test_audio.test_audio_period_ch_4);
 
-	pr_debug("audio_period: ch5=0x%x, ch6=0x%x, ch7=0x%x, ch8=0x%x\n",
+	DP_DEBUG("audio_period: ch5=0x%x, ch6=0x%x, ch7=0x%x, ch8=0x%x\n",
 		link->dp_link.test_audio.test_audio_period_ch_5,
 		link->dp_link.test_audio.test_audio_period_ch_6,
 		link->dp_link.test_audio.test_audio_period_ch_7,
@@ -1266,7 +1265,7 @@ static int dp_link_process_request(struct dp_link *dp_link)
 	struct dp_link_private *link;
 
 	if (!dp_link) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -1317,7 +1316,7 @@ static int dp_link_process_request(struct dp_link *dp_link)
 		goto exit;
 	}
 
-	pr_debug("no test requested\n");
+	DP_DEBUG("no test requested\n");
 	return ret;
 exit:
 	/*
@@ -1326,7 +1325,7 @@ exit:
 	 * and want source to redo some part of initialization which can
 	 * be helpful in debugging.
 	 */
-	pr_info("test requested: %s\n",
+	DP_INFO("test requested: %s\n",
 		dp_link_get_test_name(dp_link->sink_request));
 	return 0;
 }
@@ -1338,7 +1337,7 @@ static int dp_link_get_colorimetry_config(struct dp_link *dp_link)
 	struct dp_link_private *link;
 
 	if (!dp_link) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -1372,7 +1371,7 @@ static int dp_link_adjust_levels(struct dp_link *dp_link, u8 *link_status)
 	u8 buf[8] = {0}, offset = 0;
 
 	if (!dp_link) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -1430,7 +1429,7 @@ static int dp_link_adjust_levels(struct dp_link *dp_link, u8 *link_status)
 		&& (dp_link->phy_params.v_level == DP_LINK_VOLTAGE_LEVEL_1))
 		dp_link->phy_params.p_level = DP_LINK_PRE_EMPHASIS_LEVEL_2;
 
-	pr_debug("Set (VxPx): %x%x\n",
+	DP_DEBUG("Set (VxPx): %x%x\n",
 		dp_link->phy_params.v_level, dp_link->phy_params.p_level);
 
 	return 0;
@@ -1441,7 +1440,7 @@ static int dp_link_send_psm_request(struct dp_link *dp_link, bool req)
 	struct dp_link_private *link;
 
 	if (!dp_link) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -1487,7 +1486,7 @@ struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux)
 	struct dp_link *dp_link;
 
 	if (!dev || !aux) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}

msm/dp/dp_lphw_hpd.c

@@ -3,8 +3,6 @@
  * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
@@ -15,6 +13,7 @@
 #include <linux/sde_io_util.h>
 #include <linux/of_gpio.h>
 #include "dp_lphw_hpd.h"
+#include "dp_debug.h"
 
 struct dp_lphw_hpd_private {
 	struct device *dev;
@@ -38,7 +37,7 @@ static void dp_lphw_hpd_attention(struct work_struct *work)
 				struct dp_lphw_hpd_private, attention);
 
 	if (!lphw_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -54,7 +53,7 @@ static void dp_lphw_hpd_connect(struct work_struct *work)
 				struct dp_lphw_hpd_private, connect);
 
 	if (!lphw_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -72,7 +71,7 @@ static void dp_lphw_hpd_disconnect(struct work_struct *work)
 				struct dp_lphw_hpd_private, disconnect);
 
 	if (!lphw_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -100,7 +99,7 @@ static irqreturn_t dp_tlmm_isr(int unused, void *data)
 
 	hpd = gpio_get_value_cansleep(lphw_hpd->gpio_cfg.gpio);
 
-	pr_debug("lphw_hpd state = %d, new hpd state = %d\n",
+	DP_DEBUG("lphw_hpd state = %d, new hpd state = %d\n",
 			lphw_hpd->hpd, hpd);
 	if (!lphw_hpd->hpd && hpd) {
 		lphw_hpd->hpd = true;
@@ -116,7 +115,7 @@ static void dp_lphw_hpd_host_init(struct dp_hpd *dp_hpd,
 	struct dp_lphw_hpd_private *lphw_hpd;
 
 	if (!dp_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -138,7 +137,7 @@ static void dp_lphw_hpd_host_deinit(struct dp_hpd *dp_hpd,
 	struct dp_lphw_hpd_private *lphw_hpd;
 
 	if (!dp_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -157,7 +156,7 @@ static void dp_lphw_hpd_isr(struct dp_hpd *dp_hpd)
 	int rc = 0;
 
 	if (!dp_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -167,7 +166,7 @@ static void dp_lphw_hpd_isr(struct dp_hpd *dp_hpd)
 
 	if (isr & DP_HPD_UNPLUG_INT_STATUS) { /* disconnect interrupt */
 
-		pr_debug("disconnect interrupt, hpd isr state: 0x%x\n", isr);
+		DP_DEBUG("disconnect interrupt, hpd isr state: 0x%x\n", isr);
 
 		if (lphw_hpd->base.hpd_high) {
 			lphw_hpd->hpd = false;
@@ -178,18 +177,18 @@ static void dp_lphw_hpd_isr(struct dp_hpd *dp_hpd)
 			rc = queue_work(lphw_hpd->connect_wq,
 					&lphw_hpd->disconnect);
 			if (!rc)
-				pr_debug("disconnect not queued\n");
+				DP_DEBUG("disconnect not queued\n");
 		} else {
-			pr_err("already disconnected\n");
+			DP_ERR("already disconnected\n");
 		}
 
 	} else if (isr & DP_IRQ_HPD_INT_STATUS) { /* attention interrupt */
 
-		pr_debug("hpd_irq interrupt, hpd isr state: 0x%x\n", isr);
+		DP_DEBUG("hpd_irq interrupt, hpd isr state: 0x%x\n", isr);
 
 		rc = queue_work(lphw_hpd->connect_wq, &lphw_hpd->attention);
 		if (!rc)
-			pr_debug("attention not queued\n");
+			DP_DEBUG("attention not queued\n");
 	}
 }
 
@@ -198,7 +197,7 @@ static int dp_lphw_hpd_simulate_connect(struct dp_hpd *dp_hpd, bool hpd)
 	struct dp_lphw_hpd_private *lphw_hpd;
 
 	if (!dp_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -210,7 +209,7 @@ static int dp_lphw_hpd_simulate_connect(struct dp_hpd *dp_hpd, bool hpd)
 
 	if (!lphw_hpd->cb || !lphw_hpd->cb->configure ||
 			!lphw_hpd->cb->disconnect) {
-		pr_err("invalid callback\n");
+		DP_ERR("invalid callback\n");
 		return -EINVAL;
 	}
 
@@ -227,7 +226,7 @@ static int dp_lphw_hpd_simulate_attention(struct dp_hpd *dp_hpd, int vdo)
 	struct dp_lphw_hpd_private *lphw_hpd;
 
 	if (!dp_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -258,7 +257,7 @@ int dp_lphw_hpd_register(struct dp_hpd *dp_hpd)
 		IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 		"dp-gpio-intp", lphw_hpd);
 	if (rc) {
-		pr_err("Failed to request INTP threaded IRQ: %d\n", rc);
+		DP_ERR("Failed to request INTP threaded IRQ: %d\n", rc);
 		return rc;
 	}
 	enable_irq_wake(lphw_hpd->irq);
@@ -282,7 +281,7 @@ static void dp_lphw_hpd_deinit(struct dp_lphw_hpd_private *lphw_hpd)
 			if (msm_dss_enable_vreg(
 				&parser->mp[DP_PHY_PM].vreg_config[i], 1,
 				false))
-				pr_err("hpd-pwr vreg not disabled\n");
+				DP_ERR("hpd-pwr vreg not disabled\n");
 
 			break;
 		}
@@ -303,7 +302,7 @@ static void dp_lphw_hpd_init(struct dp_lphw_hpd_private *lphw_hpd)
 			if (msm_dss_enable_vreg(
 				&parser->mp[DP_PHY_PM].vreg_config[i], 1,
 				true))
-				pr_err("hpd-pwr vreg not enabled\n");
+				DP_ERR("hpd-pwr vreg not enabled\n");
 
 			break;
 		}
@@ -319,7 +318,7 @@ static void dp_lphw_hpd_init(struct dp_lphw_hpd_private *lphw_hpd)
 			rc = pinctrl_select_state(pinctrl.pin,
 					pinctrl.state_hpd_active);
 			if (rc)
-				pr_err("failed to set hpd_active state\n");
+				DP_ERR("failed to set hpd_active state\n");
 		}
 	}
 }
@@ -328,7 +327,7 @@ static int dp_lphw_hpd_create_workqueue(struct dp_lphw_hpd_private *lphw_hpd)
 {
 	lphw_hpd->connect_wq = create_singlethread_workqueue("dp_lphw_work");
 	if (IS_ERR_OR_NULL(lphw_hpd->connect_wq)) {
-		pr_err("Error creating connect_wq\n");
+		DP_ERR("Error creating connect_wq\n");
 		return -EPERM;
 	}
 
@@ -347,7 +346,7 @@ struct dp_hpd *dp_lphw_hpd_get(struct device *dev, struct dp_parser *parser,
 	struct dp_lphw_hpd_private *lphw_hpd;
 
 	if (!dev || !parser || !cb) {
-		pr_err("invalid device\n");
+		DP_ERR("invalid device\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -361,7 +360,7 @@ struct dp_hpd *dp_lphw_hpd_get(struct device *dev, struct dp_parser *parser,
 	lphw_hpd->gpio_cfg.gpio = of_get_named_gpio(dev->of_node,
 		hpd_gpio_name, 0);
 	if (!gpio_is_valid(lphw_hpd->gpio_cfg.gpio)) {
-		pr_err("%s gpio not specified\n", hpd_gpio_name);
+		DP_ERR("%s gpio not specified\n", hpd_gpio_name);
 		rc = -EINVAL;
 		goto gpio_error;
 	}
@@ -373,7 +372,7 @@ struct dp_hpd *dp_lphw_hpd_get(struct device *dev, struct dp_parser *parser,
 	rc = gpio_request(lphw_hpd->gpio_cfg.gpio,
 		lphw_hpd->gpio_cfg.gpio_name);
 	if (rc) {
-		pr_err("%s: failed to request gpio\n", hpd_gpio_name);
+		DP_ERR("%s: failed to request gpio\n", hpd_gpio_name);
 		goto gpio_error;
 	}
 	gpio_direction_input(lphw_hpd->gpio_cfg.gpio);
@@ -384,7 +383,7 @@ struct dp_hpd *dp_lphw_hpd_get(struct device *dev, struct dp_parser *parser,
 
 	rc = dp_lphw_hpd_create_workqueue(lphw_hpd);
 	if (rc) {
-		pr_err("Failed to create a dp_hpd workqueue\n");
+		DP_ERR("Failed to create a dp_hpd workqueue\n");
 		goto gpio_error;
 	}
 

msm/dp/dp_mst_drm.c

@@ -25,8 +25,6 @@
  * OF THIS SOFTWARE.
  */
 
-#define pr_fmt(fmt)	"[drm-dp-mst]: %s: " fmt, __func__
-
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/errno.h>
@@ -41,9 +39,10 @@
 #include "msm_kms.h"
 #include "sde_connector.h"
 #include "dp_drm.h"
+#include "dp_debug.h"
 
-#define DP_MST_DEBUG(fmt, ...) pr_debug(fmt, ##__VA_ARGS__)
-#define DP_MST_INFO_LOG(fmt, ...) pr_debug(fmt, ##__VA_ARGS__)
+#define DP_MST_DEBUG(fmt, ...) DP_DEBUG(fmt, ##__VA_ARGS__)
+#define DP_MST_INFO_LOG(fmt, ...) DP_DEBUG(fmt, ##__VA_ARGS__)
 
 #define MAX_DP_MST_DRM_ENCODERS		2
 #define MAX_DP_MST_DRM_BRIDGES		2
@@ -330,7 +329,7 @@ static int dp_mst_sim_update_payload_part1(struct drm_dp_mst_topology_mgr *mgr)
 
 	for (i = 0; i < mgr->max_payloads; i++) {
 		if (mgr->payloads[i].payload_state == DP_PAYLOAD_DELETE_LOCAL) {
-			pr_debug("removing payload %d\n", i);
+			DP_DEBUG("removing payload %d\n", i);
 			for (j = i; j < mgr->max_payloads - 1; j++) {
 				memcpy(&mgr->payloads[j],
 					&mgr->payloads[j + 1],
@@ -368,7 +367,7 @@ static int dp_mst_sim_update_payload_part2(struct drm_dp_mst_topology_mgr *mgr)
 		port = container_of(mgr->proposed_vcpis[i],
 				struct drm_dp_mst_port, vcpi);
 
-		pr_debug("payload %d %d\n", i, mgr->payloads[i].payload_state);
+		DP_DEBUG("payload %d %d\n", i, mgr->payloads[i].payload_state);
 		if (mgr->payloads[i].payload_state == DP_PAYLOAD_LOCAL)
 			mgr->payloads[i].payload_state = DP_PAYLOAD_REMOTE;
 		else if (mgr->payloads[i].payload_state ==
@@ -511,7 +510,7 @@ static void _dp_mst_get_vcpi_info(
 	}
 	mutex_unlock(&mgr->payload_lock);
 
-	pr_info("vcpi_info. vcpi:%d, start_slot:%d, num_slots:%d\n",
+	DP_INFO("vcpi_info. vcpi:%d, start_slot:%d, num_slots:%d\n",
 			vcpi, *start_slot, *num_slots);
 }
 
@@ -528,7 +527,7 @@ static int dp_mst_calc_pbn_mode(struct dp_display_mode *dp_mode)
 	pbn = drm_dp_calc_pbn_mode(dp_mode->timing.pixel_clk_khz, bpp);
 	pbn_fp = drm_fixp_from_fraction(pbn, 1);
 
-	pr_debug("before overhead pbn:%d, bpp:%d\n", pbn, bpp);
+	DP_DEBUG("before overhead pbn:%d, bpp:%d\n", pbn, bpp);
 
 	if (dsc_en)
 		pbn_fp = drm_fixp_mul(pbn_fp, dp_mode->dsc_overhead_fp);
@@ -538,7 +537,7 @@ static int dp_mst_calc_pbn_mode(struct dp_display_mode *dp_mode)
 
 	pbn = drm_fixp2int(pbn_fp);
 
-	pr_debug("after overhead pbn:%d, bpp:%d\n", pbn, bpp);
+	DP_DEBUG("after overhead pbn:%d, bpp:%d\n", pbn, bpp);
 	return pbn;
 }
 
@@ -585,7 +584,7 @@ static int dp_mst_bridge_attach(struct drm_bridge *dp_bridge)
 	DP_MST_DEBUG("enter\n");
 
 	if (!dp_bridge) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return -EINVAL;
 	}
 
@@ -608,20 +607,20 @@ static bool dp_mst_bridge_mode_fixup(struct drm_bridge *drm_bridge,
 	DP_MST_DEBUG("enter\n");
 
 	if (!drm_bridge || !mode || !adjusted_mode) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		ret = false;
 		goto end;
 	}
 
 	bridge = to_dp_mst_bridge(drm_bridge);
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		ret = false;
 		goto end;
 	}
 
 	if (!bridge->dp_panel) {
-		pr_err("Invalid dp_panel\n");
+		DP_ERR("Invalid dp_panel\n");
 		ret = false;
 		goto end;
 	}
@@ -651,7 +650,7 @@ static int _dp_mst_compute_config(struct drm_atomic_state *state,
 	slots = mst->mst_fw_cbs->atomic_find_vcpi_slots(state,
 			&mst->mst_mgr, c_conn->mst_port, pbn);
 	if (slots < 0) {
-		pr_err("mst: failed to find vcpi slots. pbn:%d, slots:%d\n",
+		DP_ERR("mst: failed to find vcpi slots. pbn:%d, slots:%d\n",
 				pbn, slots);
 		return slots;
 	}
@@ -690,7 +689,7 @@ static void _dp_mst_update_timeslots(struct dp_mst_private *mst,
 				dp_bridge->id, start_slot, num_slots, pbn,
 				dp_bridge->vcpi);
 
-		pr_info("bridge:%d vcpi:%d start_slot:%d num_slots:%d, pbn:%d\n",
+		DP_INFO("bridge:%d vcpi:%d start_slot:%d num_slots:%d, pbn:%d\n",
 			dp_bridge->id, dp_bridge->vcpi,
 			start_slot, num_slots, pbn);
 	}
@@ -741,13 +740,13 @@ static void _dp_mst_bridge_pre_enable_part1(struct dp_mst_bridge *dp_bridge)
 
 	slots = mst->mst_fw_cbs->find_vcpi_slots(&mst->mst_mgr, pbn);
 
-	pr_info("bridge:%d, pbn:%d, slots:%d\n", dp_bridge->id,
+	DP_INFO("bridge:%d, pbn:%d, slots:%d\n", dp_bridge->id,
 			dp_bridge->pbn, dp_bridge->num_slots);
 
 	ret = mst->mst_fw_cbs->allocate_vcpi(&mst->mst_mgr,
 				       port, pbn, slots);
 	if (!ret) {
-		pr_err("mst: failed to allocate vcpi. bridge:%d\n",
+		DP_ERR("mst: failed to allocate vcpi. bridge:%d\n",
 				dp_bridge->id);
 		return;
 	}
@@ -844,7 +843,7 @@ static void dp_mst_bridge_pre_enable(struct drm_bridge *drm_bridge)
 	struct dp_mst_private *mst;
 
 	if (!drm_bridge) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return;
 	}
 
@@ -855,7 +854,7 @@ static void dp_mst_bridge_pre_enable(struct drm_bridge *drm_bridge)
 	bridge->old_dp_panel = NULL;
 
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		return;
 	}
 
@@ -866,14 +865,14 @@ static void dp_mst_bridge_pre_enable(struct drm_bridge *drm_bridge)
 	/* By this point mode should have been validated through mode_fixup */
 	rc = dp->set_mode(dp, bridge->dp_panel, &bridge->dp_mode);
 	if (rc) {
-		pr_err("[%d] failed to perform a mode set, rc=%d\n",
+		DP_ERR("[%d] failed to perform a mode set, rc=%d\n",
 		       bridge->id, rc);
 		goto end;
 	}
 
 	rc = dp->prepare(dp, bridge->dp_panel);
 	if (rc) {
-		pr_err("[%d] DP display prepare failed, rc=%d\n",
+		DP_ERR("[%d] DP display prepare failed, rc=%d\n",
 		       bridge->id, rc);
 		goto end;
 	}
@@ -882,7 +881,7 @@ static void dp_mst_bridge_pre_enable(struct drm_bridge *drm_bridge)
 
 	rc = dp->enable(dp, bridge->dp_panel);
 	if (rc) {
-		pr_err("[%d] DP display enable failed, rc=%d\n",
+		DP_ERR("[%d] DP display enable failed, rc=%d\n",
 		       bridge->id, rc);
 		dp->unprepare(dp, bridge->dp_panel);
 		goto end;
@@ -909,13 +908,13 @@ static void dp_mst_bridge_enable(struct drm_bridge *drm_bridge)
 	struct dp_display *dp;
 
 	if (!drm_bridge) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return;
 	}
 
 	bridge = to_dp_mst_bridge(drm_bridge);
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		return;
 	}
 
@@ -923,7 +922,7 @@ static void dp_mst_bridge_enable(struct drm_bridge *drm_bridge)
 
 	rc = dp->post_enable(dp, bridge->dp_panel);
 	if (rc) {
-		pr_err("mst bridge [%d] post enable failed, rc=%d\n",
+		DP_ERR("mst bridge [%d] post enable failed, rc=%d\n",
 		       bridge->id, rc);
 		return;
 	}
@@ -940,13 +939,13 @@ static void dp_mst_bridge_disable(struct drm_bridge *drm_bridge)
 	struct dp_mst_private *mst;
 
 	if (!drm_bridge) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return;
 	}
 
 	bridge = to_dp_mst_bridge(drm_bridge);
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		return;
 	}
 
@@ -962,7 +961,7 @@ static void dp_mst_bridge_disable(struct drm_bridge *drm_bridge)
 
 	rc = dp->pre_disable(dp, bridge->dp_panel);
 	if (rc)
-		pr_err("[%d] DP display pre disable failed, rc=%d\n",
+		DP_ERR("[%d] DP display pre disable failed, rc=%d\n",
 		       bridge->id, rc);
 
 	_dp_mst_bridge_pre_disable_part2(bridge);
@@ -980,13 +979,13 @@ static void dp_mst_bridge_post_disable(struct drm_bridge *drm_bridge)
 	struct dp_mst_private *mst;
 
 	if (!drm_bridge) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return;
 	}
 
 	bridge = to_dp_mst_bridge(drm_bridge);
 	if (!bridge->connector) {
-		pr_err("Invalid connector\n");
+		DP_ERR("Invalid connector\n");
 		return;
 	}
 
@@ -995,12 +994,12 @@ static void dp_mst_bridge_post_disable(struct drm_bridge *drm_bridge)
 
 	rc = dp->disable(dp, bridge->dp_panel);
 	if (rc)
-		pr_info("[%d] DP display disable failed, rc=%d\n",
+		DP_INFO("[%d] DP display disable failed, rc=%d\n",
 		       bridge->id, rc);
 
 	rc = dp->unprepare(dp, bridge->dp_panel);
 	if (rc)
-		pr_info("[%d] DP display unprepare failed, rc=%d\n",
+		DP_INFO("[%d] DP display unprepare failed, rc=%d\n",
 		       bridge->id, rc);
 
 	/* maintain the connector to encoder link during suspend/resume */
@@ -1029,14 +1028,14 @@ static void dp_mst_bridge_mode_set(struct drm_bridge *drm_bridge,
 	DP_MST_DEBUG("enter\n");
 
 	if (!drm_bridge || !mode || !adjusted_mode) {
-		pr_err("Invalid params\n");
+		DP_ERR("Invalid params\n");
 		return;
 	}
 
 	bridge = to_dp_mst_bridge(drm_bridge);
 	if (!bridge->connector) {
 		if (!bridge->old_connector) {
-			pr_err("Invalid connector\n");
+			DP_ERR("Invalid connector\n");
 			return;
 		}
 		bridge->connector = bridge->old_connector;
@@ -1045,7 +1044,7 @@ static void dp_mst_bridge_mode_set(struct drm_bridge *drm_bridge,
 
 	if (!bridge->dp_panel) {
 		if (!bridge->old_dp_panel) {
-			pr_err("Invalid dp_panel\n");
+			DP_ERR("Invalid dp_panel\n");
 			return;
 		}
 		bridge->dp_panel = bridge->old_dp_panel;
@@ -1090,14 +1089,14 @@ int dp_mst_drm_bridge_init(void *data, struct drm_encoder *encoder)
 
 	if (!mst || !mst->mst_initialized) {
 		if (dp_mst_enc_cache.cnt >= MAX_DP_MST_DRM_BRIDGES) {
-			pr_info("exceeding max bridge cnt %d\n",
+			DP_INFO("exceeding max bridge cnt %d\n",
 					dp_mst_enc_cache.cnt);
 			return 0;
 		}
 
 		dp_mst_enc_cache.mst_enc[dp_mst_enc_cache.cnt] = encoder;
 		dp_mst_enc_cache.cnt++;
-		pr_info("mst not initialized. cache encoder information\n");
+		DP_INFO("mst not initialized. cache encoder information\n");
 		return 0;
 	}
 
@@ -1112,7 +1111,7 @@ int dp_mst_drm_bridge_init(void *data, struct drm_encoder *encoder)
 	}
 
 	if (i == MAX_DP_MST_DRM_BRIDGES) {
-		pr_err("mst supports only %d bridges\n", i);
+		DP_ERR("mst supports only %d bridges\n", i);
 		rc = -EACCES;
 		goto end;
 	}
@@ -1126,7 +1125,7 @@ int dp_mst_drm_bridge_init(void *data, struct drm_encoder *encoder)
 
 	rc = drm_bridge_attach(encoder, &bridge->base, NULL);
 	if (rc) {
-		pr_err("failed to attach bridge, rc=%d\n", rc);
+		DP_ERR("failed to attach bridge, rc=%d\n", rc);
 		goto end;
 	}
 
@@ -1146,7 +1145,7 @@ int dp_mst_drm_bridge_init(void *data, struct drm_encoder *encoder)
 			dp_mst_drm_fixed_connector_init(display,
 				bridge->encoder);
 		if (bridge->fixed_connector == NULL) {
-			pr_err("failed to create fixed connector\n");
+			DP_ERR("failed to create fixed connector\n");
 			rc = -ENOMEM;
 			goto end;
 		}
@@ -1237,7 +1236,7 @@ enum drm_mode_status dp_mst_connector_mode_valid(
 	const u32 tot_slots = 63;
 
 	if (!connector || !mode || !display) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return 0;
 	}
 
@@ -1259,7 +1258,7 @@ enum drm_mode_status dp_mst_connector_mode_valid(
 	if (active_enc_cnt < DP_STREAM_MAX)
 		available_slots = tot_slots - slots_in_use;
 	else {
-		pr_debug("all mst streams are active\n");
+		DP_DEBUG("all mst streams are active\n");
 		return MODE_BAD;
 	}
 
@@ -1271,7 +1270,7 @@ enum drm_mode_status dp_mst_connector_mode_valid(
 			&mst->mst_mgr, required_pbn);
 
 	if (required_pbn > available_pbn || required_slots > available_slots) {
-		pr_debug("mode:%s not supported\n", mode->name);
+		DP_DEBUG("mode:%s not supported\n", mode->name);
 		return MODE_BAD;
 	}
 
@@ -1440,7 +1439,7 @@ static int dp_mst_connector_atomic_check(struct drm_connector *connector,
 		rc = mst->mst_fw_cbs->atomic_release_vcpi_slots(state,
 				&mst->mst_mgr, slots);
 		if (rc) {
-			pr_err("failed releasing %d vcpi slots rc:%d\n",
+			DP_ERR("failed releasing %d vcpi slots rc:%d\n",
 					slots, rc);
 			goto end;
 		}
@@ -1552,14 +1551,14 @@ dp_mst_add_connector(struct drm_dp_mst_topology_mgr *mgr,
 				DRM_MODE_CONNECTOR_DisplayPort);
 
 	if (!connector) {
-		pr_err("mst sde_connector_init failed\n");
+		DP_ERR("mst sde_connector_init failed\n");
 		drm_modeset_unlock_all(dev);
 		return connector;
 	}
 
 	rc = dp_display->mst_connector_install(dp_display, connector);
 	if (rc) {
-		pr_err("mst connector install failed\n");
+		DP_ERR("mst connector install failed\n");
 		sde_connector_destroy(connector);
 		drm_modeset_unlock_all(dev);
 		return NULL;
@@ -1875,13 +1874,13 @@ dp_mst_drm_fixed_connector_init(struct dp_display *dp_display,
 				DRM_MODE_CONNECTOR_DisplayPort);
 
 	if (!connector) {
-		pr_err("mst sde_connector_init failed\n");
+		DP_ERR("mst sde_connector_init failed\n");
 		return NULL;
 	}
 
 	rc = dp_display->mst_connector_install(dp_display, connector);
 	if (rc) {
-		pr_err("mst connector install failed\n");
+		DP_ERR("mst connector install failed\n");
 		sde_connector_destroy(connector);
 		return NULL;
 	}
@@ -1999,14 +1998,14 @@ static void dp_mst_display_hpd_irq(void *dp_display,
 	}
 
 	if (!mst->mst_session_state) {
-		pr_err("mst_hpd_irq received before mst session start\n");
+		DP_ERR("mst_hpd_irq received before mst session start\n");
 		return;
 	}
 
 	rc = drm_dp_dpcd_read(mst->caps.drm_aux, DP_SINK_COUNT_ESI,
 		esi, 14);
 	if (rc != 14) {
-		pr_err("dpcd sink status read failed, rlen=%d\n", rc);
+		DP_ERR("dpcd sink status read failed, rlen=%d\n", rc);
 		return;
 	}
 
@@ -2020,7 +2019,7 @@ static void dp_mst_display_hpd_irq(void *dp_display,
 		rc = drm_dp_dpcd_write(mst->caps.drm_aux, esi_res, &esi[1], 3);
 
 		if (rc != 3)
-			pr_err("dpcd esi_res failed. rlen=%d\n", rc);
+			DP_ERR("dpcd esi_res failed. rlen=%d\n", rc);
 	}
 
 	DP_MST_DEBUG("mst display hpd_irq handled:%d rc:%d\n", handled, rc);
@@ -2032,7 +2031,7 @@ static void dp_mst_set_state(void *dp_display, enum dp_drv_state mst_state)
 	struct dp_mst_private *mst = dp->dp_mst_prv_info;
 
 	if (!mst) {
-		pr_debug("mst not initialized\n");
+		DP_DEBUG("mst not initialized\n");
 		return;
 	}
 
@@ -2078,7 +2077,7 @@ int dp_mst_init(struct dp_display *dp_display)
 	memset(&dp_mst, 0, sizeof(dp_mst));
 
 	if (!dp_display) {
-		pr_err("invalid params\n");
+		DP_ERR("invalid params\n");
 		return 0;
 	}
 
@@ -2111,7 +2110,7 @@ int dp_mst_init(struct dp_display *dp_display)
 					dp_mst.caps.max_streams_supported,
 					conn_base_id);
 	if (ret) {
-		pr_err("dp drm mst topology manager init failed\n");
+		DP_ERR("dp drm mst topology manager init failed\n");
 		goto error;
 	}
 
@@ -2144,7 +2143,7 @@ void dp_mst_deinit(struct dp_display *dp_display)
 	struct dp_mst_private *mst;
 
 	if (!dp_display) {
-		pr_err("invalid params\n");
+		DP_ERR("invalid params\n");
 		return;
 	}
 

msm/dp/dp_panel.c

@@ -3,11 +3,10 @@
  * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include "dp_panel.h"
 #include <linux/unistd.h>
 #include <drm/drm_fixed.h>
+#include "dp_debug.h"
 
 #define DP_KHZ_TO_HZ 1000
 #define DP_PANEL_DEFAULT_BPP 24
@@ -308,7 +307,7 @@ static void dp_panel_update_tu_timings(struct dp_tu_calc_input *in,
 	tot_num_dummy_bytes = (nlanes - eoc_bytes) * dsc_num_slices;
 
 	if (dsc_num_bytes == 0)
-		pr_info("incorrect no of bytes per slice=%d\n", dsc_num_bytes);
+		DP_INFO("incorrect no of bytes per slice=%d\n", dsc_num_bytes);
 
 	dwidth_dsc_bytes = (tot_num_hor_bytes +
 				tot_num_eoc_symbols +
@@ -706,7 +705,7 @@ static void _dp_panel_calc_tu(struct dp_tu_calc_input *in,
 
 	if (tu.dsc_en && compare_result_1 && compare_result_2) {
 		HBLANK_MARGIN += 4;
-		pr_info("Info: increase HBLANK_MARGIN to %d\n", HBLANK_MARGIN);
+		DP_INFO("Info: increase HBLANK_MARGIN to %d\n", HBLANK_MARGIN);
 	}
 
 tu_size_calc:
@@ -740,7 +739,7 @@ tu_size_calc:
 		tu.n_tus += 1;
 
 	tu.even_distribution_legacy = tu.n_tus % tu.nlanes == 0 ? 1 : 0;
-	pr_info("Info: n_sym = %d, num_of_tus = %d\n",
+	DP_INFO("Info: n_sym = %d, num_of_tus = %d\n",
 		tu.valid_boundary_link, tu.n_tus);
 
 	_dp_calc_extra_bytes(&tu);
@@ -870,17 +869,17 @@ tu_size_calc:
 	tu_table->lower_boundary_count      = tu.lower_boundary_count;
 	tu_table->tu_size_minus1            = tu.tu_size_minus1;
 
-	pr_info("TU: valid_boundary_link: %d\n", tu_table->valid_boundary_link);
-	pr_info("TU: delay_start_link: %d\n", tu_table->delay_start_link);
-	pr_info("TU: boundary_moderation_en: %d\n",
+	DP_INFO("TU: valid_boundary_link: %d\n", tu_table->valid_boundary_link);
+	DP_INFO("TU: delay_start_link: %d\n", tu_table->delay_start_link);
+	DP_INFO("TU: boundary_moderation_en: %d\n",
 			tu_table->boundary_moderation_en);
-	pr_info("TU: valid_lower_boundary_link: %d\n",
+	DP_INFO("TU: valid_lower_boundary_link: %d\n",
 			tu_table->valid_lower_boundary_link);
-	pr_info("TU: upper_boundary_count: %d\n",
+	DP_INFO("TU: upper_boundary_count: %d\n",
 			tu_table->upper_boundary_count);
-	pr_info("TU: lower_boundary_count: %d\n",
+	DP_INFO("TU: lower_boundary_count: %d\n",
 			tu_table->lower_boundary_count);
-	pr_info("TU: tu_size_minus1: %d\n", tu_table->tu_size_minus1);
+	DP_INFO("TU: tu_size_minus1: %d\n", tu_table->tu_size_minus1);
 }
 
 static void dp_panel_calc_tu_parameters(struct dp_panel *dp_panel,
@@ -938,7 +937,7 @@ static void dp_panel_config_tr_unit(struct dp_panel *dp_panel)
 	struct dp_vc_tu_mapping_table tu_calc_table;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -961,7 +960,7 @@ static void dp_panel_config_tr_unit(struct dp_panel *dp_panel)
 	if (tu_calc_table.boundary_moderation_en)
 		valid_boundary2 |= BIT(0);
 
-	pr_debug("dp_tu=0x%x, valid_boundary=0x%x, valid_boundary2=0x%x\n",
+	DP_DEBUG("dp_tu=0x%x, valid_boundary=0x%x, valid_boundary2=0x%x\n",
 			dp_tu, valid_boundary, valid_boundary2);
 
 	catalog->dp_tu = dp_tu;
@@ -1253,7 +1252,7 @@ static void _dp_panel_dsc_get_num_extra_pclk(struct msm_display_dsc_info *dsc,
 	else
 		dsc->extra_width = 0;
 
-	pr_debug("extra pclks required: %d\n", dsc->extra_width);
+	DP_DEBUG("extra pclks required: %d\n", dsc->extra_width);
 }
 
 static void _dp_panel_dsc_bw_overhead_calc(struct dp_panel *dp_panel,
@@ -1279,7 +1278,7 @@ static void _dp_panel_dsc_bw_overhead_calc(struct dp_panel *dp_panel,
 	dwidth_dsc_bytes = tot_num_hor_bytes + tot_num_eoc_symbols +
 				tot_num_dummy_bytes;
 
-	pr_debug("dwidth_dsc_bytes:%d, tot_num_hor_bytes:%d\n",
+	DP_DEBUG("dwidth_dsc_bytes:%d, tot_num_hor_bytes:%d\n",
 			dwidth_dsc_bytes, tot_num_hor_bytes);
 
 	dp_mode->dsc_overhead_fp = drm_fixp_from_fraction(dwidth_dsc_bytes,
@@ -1635,7 +1634,7 @@ static int dp_panel_dsc_prepare_basic_params(
 
 	ppr_max_index = dp_panel->dsc_dpcd[11] &= 0xf;
 	if (!ppr_max_index || ppr_max_index >= 15) {
-		pr_debug("Throughput mode 0 not supported");
+		DP_DEBUG("Throughput mode 0 not supported");
 		return -EINVAL;
 	}
 
@@ -1711,7 +1710,7 @@ static int dp_panel_read_dpcd(struct dp_panel *dp_panel, bool multi_func)
 	u32 dfp_count = 0, offset = DP_DPCD_REV;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -1728,27 +1727,27 @@ static int dp_panel_read_dpcd(struct dp_panel *dp_panel, bool multi_func)
 	panel->vscext_chaining_supported = false;
 
 	if (panel->custom_dpcd) {
-		pr_debug("skip dpcd read in debug mode\n");
+		DP_DEBUG("skip dpcd read in debug mode\n");
 		goto skip_dpcd_read;
 	}
 
 	rlen = drm_dp_dpcd_read(drm_aux, DP_TRAINING_AUX_RD_INTERVAL, &temp, 1);
 	if (rlen != 1) {
-		pr_err("error reading DP_TRAINING_AUX_RD_INTERVAL\n");
+		DP_ERR("error reading DP_TRAINING_AUX_RD_INTERVAL\n");
 		rc = -EINVAL;
 		goto end;
 	}
 
 	/* check for EXTENDED_RECEIVER_CAPABILITY_FIELD_PRESENT */
 	if (temp & BIT(7)) {
-		pr_debug("using EXTENDED_RECEIVER_CAPABILITY_FIELD\n");
+		DP_DEBUG("using EXTENDED_RECEIVER_CAPABILITY_FIELD\n");
 		offset = DPRX_EXTENDED_DPCD_FIELD;
 	}
 
 	rlen = drm_dp_dpcd_read(drm_aux, offset,
 		dp_panel->dpcd, (DP_RECEIVER_CAP_SIZE + 1));
 	if (rlen < (DP_RECEIVER_CAP_SIZE + 1)) {
-		pr_err("dpcd read failed, rlen=%d\n", rlen);
+		DP_ERR("dpcd read failed, rlen=%d\n", rlen);
 		if (rlen == -ETIMEDOUT)
 			rc = rlen;
 		else
@@ -1763,7 +1762,7 @@ static int dp_panel_read_dpcd(struct dp_panel *dp_panel, bool multi_func)
 	rlen = drm_dp_dpcd_read(panel->aux->drm_aux,
 		DPRX_FEATURE_ENUMERATION_LIST, &rx_feature, 1);
 	if (rlen != 1) {
-		pr_debug("failed to read DPRX_FEATURE_ENUMERATION_LIST\n");
+		DP_DEBUG("failed to read DPRX_FEATURE_ENUMERATION_LIST\n");
 		goto skip_dpcd_read;
 	}
 	panel->vsc_supported = !!(rx_feature &
@@ -1772,7 +1771,7 @@ static int dp_panel_read_dpcd(struct dp_panel *dp_panel, bool multi_func)
 	panel->vscext_chaining_supported = !!(rx_feature &
 			VSC_EXT_VESA_SDP_CHAINING_SUPPORTED);
 
-	pr_debug("vsc=%d, vscext=%d, vscext_chaining=%d\n",
+	DP_DEBUG("vsc=%d, vscext=%d, vscext_chaining=%d\n",
 		panel->vsc_supported, panel->vscext_supported,
 		panel->vscext_chaining_supported);
 
@@ -1791,7 +1790,7 @@ skip_dpcd_read:
 		link_info->num_lanes = min_t(unsigned int,
 			link_info->num_lanes, 2);
 
-	pr_debug("version:%d.%d, rate:%d, lanes:%d\n", panel->major,
+	DP_DEBUG("version:%d.%d, rate:%d, lanes:%d\n", panel->major,
 		panel->minor, link_info->rate, link_info->num_lanes);
 
 	if (drm_dp_enhanced_frame_cap(dpcd))
@@ -1806,14 +1805,14 @@ skip_dpcd_read:
 			DP_DOWNSTREAM_PORT_0, dp_panel->ds_ports,
 			DP_MAX_DOWNSTREAM_PORTS);
 		if (rlen < DP_MAX_DOWNSTREAM_PORTS) {
-			pr_err("ds port status failed, rlen=%d\n", rlen);
+			DP_ERR("ds port status failed, rlen=%d\n", rlen);
 			rc = -EINVAL;
 			goto end;
 		}
 	}
 
 	if (dfp_count > DP_MAX_DS_PORT_COUNT)
-		pr_debug("DS port count %d greater that max (%d) supported\n",
+		DP_DEBUG("DS port count %d greater that max (%d) supported\n",
 			dfp_count, DP_MAX_DS_PORT_COUNT);
 
 end:
@@ -1827,13 +1826,13 @@ static int dp_panel_set_default_link_params(struct dp_panel *dp_panel)
 	const int default_num_lanes = 1;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 	link_info = &dp_panel->link_info;
 	link_info->rate = default_bw_code;
 	link_info->num_lanes = default_num_lanes;
-	pr_debug("link_rate=%d num_lanes=%d\n",
+	DP_DEBUG("link_rate=%d num_lanes=%d\n",
 		link_info->rate, link_info->num_lanes);
 
 	return 0;
@@ -1844,7 +1843,7 @@ static int dp_panel_set_edid(struct dp_panel *dp_panel, u8 *edid)
 	struct dp_panel_private *panel;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -1858,7 +1857,7 @@ static int dp_panel_set_edid(struct dp_panel *dp_panel, u8 *edid)
 		dp_panel->edid_ctrl->edid = NULL;
 	}
 
-	pr_debug("%d\n", panel->custom_edid);
+	DP_DEBUG("%d\n", panel->custom_edid);
 	return 0;
 }
 
@@ -1868,7 +1867,7 @@ static int dp_panel_set_dpcd(struct dp_panel *dp_panel, u8 *dpcd)
 	u8 *dp_dpcd;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -1883,7 +1882,7 @@ static int dp_panel_set_dpcd(struct dp_panel *dp_panel, u8 *dpcd)
 		panel->custom_dpcd = false;
 	}
 
-	pr_debug("%d\n", panel->custom_dpcd);
+	DP_DEBUG("%d\n", panel->custom_dpcd);
 
 	return 0;
 }
@@ -1896,21 +1895,21 @@ static int dp_panel_read_edid(struct dp_panel *dp_panel,
 	struct edid *edid;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
 	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
 
 	if (panel->custom_edid) {
-		pr_debug("skip edid read in debug mode\n");
+		DP_DEBUG("skip edid read in debug mode\n");
 		goto end;
 	}
 
 	sde_get_edid(connector, &panel->aux->drm_aux->ddc,
 		(void **)&dp_panel->edid_ctrl);
 	if (!dp_panel->edid_ctrl->edid) {
-		pr_err("EDID read failed\n");
+		DP_ERR("EDID read failed\n");
 		ret = -EINVAL;
 		goto end;
 	}
@@ -1926,7 +1925,7 @@ static void dp_panel_decode_dsc_dpcd(struct dp_panel *dp_panel)
 	s64 fec_overhead_fp = drm_fixp_from_fraction(1, 1);
 
 	if (!dp_panel->dsc_feature_enable || !dp_panel->fec_feature_enable) {
-		pr_debug("source dsc is not supported\n");
+		DP_DEBUG("source dsc is not supported\n");
 		return;
 	}
 
@@ -1961,7 +1960,7 @@ static void dp_panel_read_sink_dsc_caps(struct dp_panel *dp_panel)
 	int dpcd_rev;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -1977,7 +1976,7 @@ static void dp_panel_read_sink_dsc_caps(struct dp_panel *dp_panel)
 		rlen = drm_dp_dpcd_read(panel->aux->drm_aux, DP_DSC_SUPPORT,
 			dp_panel->dsc_dpcd, (DP_RECEIVER_DSC_CAP_SIZE + 1));
 		if (rlen < (DP_RECEIVER_DSC_CAP_SIZE + 1)) {
-			pr_debug("dsc dpcd read failed, rlen=%d\n", rlen);
+			DP_DEBUG("dsc dpcd read failed, rlen=%d\n", rlen);
 			return;
 		}
 
@@ -1988,7 +1987,7 @@ static void dp_panel_read_sink_dsc_caps(struct dp_panel *dp_panel)
 		rlen = drm_dp_dpcd_read(panel->aux->drm_aux, fec_cap,
 			&dp_panel->fec_dpcd, 1);
 		if (rlen < 1) {
-			pr_err("fec dpcd read failed, rlen=%d\n", rlen);
+			DP_ERR("fec dpcd read failed, rlen=%d\n", rlen);
 			return;
 		}
 
@@ -2004,7 +2003,7 @@ static int dp_panel_read_sink_caps(struct dp_panel *dp_panel,
 	struct dp_panel_private *panel;
 
 	if (!dp_panel || !connector) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -2018,10 +2017,10 @@ static int dp_panel_read_sink_caps(struct dp_panel *dp_panel,
 		((drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate)) >
 		dp_panel->max_bw_code)) {
 		if ((rc == -ETIMEDOUT) || (rc == -ENODEV)) {
-			pr_err("DPCD read failed, return early\n");
+			DP_ERR("DPCD read failed, return early\n");
 			goto end;
 		}
-		pr_err("panel dpcd read failed/incorrect, set default params\n");
+		DP_ERR("panel dpcd read failed/incorrect, set default params\n");
 		dp_panel_set_default_link_params(dp_panel);
 	}
 
@@ -2034,7 +2033,7 @@ static int dp_panel_read_sink_caps(struct dp_panel *dp_panel,
 		if (rlen == count_len) {
 			count = DP_GET_SINK_COUNT(count);
 			if (!count) {
-				pr_err("no downstream ports connected\n");
+				DP_ERR("no downstream ports connected\n");
 				panel->link->sink_count.count = 0;
 				rc = -ENOTCONN;
 				goto end;
@@ -2044,7 +2043,7 @@ static int dp_panel_read_sink_caps(struct dp_panel *dp_panel,
 
 	rc = dp_panel_read_edid(dp_panel, connector);
 	if (rc) {
-		pr_err("panel edid read failed, set failsafe mode\n");
+		DP_ERR("panel edid read failed, set failsafe mode\n");
 		return rc;
 	}
 
@@ -2085,7 +2084,7 @@ static u32 dp_panel_get_mode_bpp(struct dp_panel *dp_panel,
 	u32 bpp = mode_edid_bpp;
 
 	if (!dp_panel || !mode_edid_bpp || !mode_pclk_khz) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return 0;
 	}
 
@@ -2108,7 +2107,7 @@ static void dp_panel_set_test_mode(struct dp_panel_private *panel,
 	struct dp_link_test_video *test_info = NULL;
 
 	if (!panel) {
-		pr_err("invalid params\n");
+		DP_ERR("invalid params\n");
 		return;
 	}
 
@@ -2152,7 +2151,7 @@ static int dp_panel_get_modes(struct dp_panel *dp_panel,
 	struct dp_panel_private *panel;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
@@ -2176,7 +2175,7 @@ static void dp_panel_handle_sink_request(struct dp_panel *dp_panel)
 	struct dp_panel_private *panel;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -2198,12 +2197,12 @@ static void dp_panel_tpg_config(struct dp_panel *dp_panel, bool enable)
 	struct dp_panel_info *pinfo;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
 	if (dp_panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream id:%d\n", dp_panel->stream_id);
+		DP_ERR("invalid stream id:%d\n", dp_panel->stream_id);
 		return;
 	}
 
@@ -2212,7 +2211,7 @@ static void dp_panel_tpg_config(struct dp_panel *dp_panel, bool enable)
 	pinfo = &panel->dp_panel.pinfo;
 
 	if (!panel->panel_on) {
-		pr_debug("DP panel not enabled, handle TPG on next panel on\n");
+		DP_DEBUG("DP panel not enabled, handle TPG on next panel on\n");
 		return;
 	}
 
@@ -2256,7 +2255,7 @@ static int dp_panel_config_timing(struct dp_panel *dp_panel)
 	struct dp_panel_info *pinfo;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -2265,11 +2264,11 @@ static int dp_panel_config_timing(struct dp_panel *dp_panel)
 	catalog = panel->catalog;
 	pinfo = &panel->dp_panel.pinfo;
 
-	pr_debug("width=%d hporch= %d %d %d\n",
+	DP_DEBUG("width=%d hporch= %d %d %d\n",
 		pinfo->h_active, pinfo->h_back_porch,
 		pinfo->h_front_porch, pinfo->h_sync_width);
 
-	pr_debug("height=%d vporch= %d %d %d\n",
+	DP_DEBUG("height=%d vporch= %d %d %d\n",
 		pinfo->v_active, pinfo->v_back_porch,
 		pinfo->v_front_porch, pinfo->v_sync_width);
 
@@ -2415,7 +2414,7 @@ static int dp_panel_edid_register(struct dp_panel_private *panel)
 
 	panel->dp_panel.edid_ctrl = sde_edid_init();
 	if (!panel->dp_panel.edid_ctrl) {
-		pr_err("sde edid init for DP failed\n");
+		DP_ERR("sde edid init for DP failed\n");
 		rc = -ENOMEM;
 	}
 
@@ -2432,7 +2431,7 @@ static int dp_panel_set_stream_info(struct dp_panel *dp_panel,
 			u32 ch_tot_slots, u32 pbn, int vcpi)
 {
 	if (!dp_panel || stream_id > DP_STREAM_MAX) {
-		pr_err("invalid input. stream_id: %d\n", stream_id);
+		DP_ERR("invalid input. stream_id: %d\n", stream_id);
 		return -EINVAL;
 	}
 
@@ -2452,7 +2451,7 @@ static int dp_panel_init_panel_info(struct dp_panel *dp_panel)
 	struct dp_panel_info *pinfo;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -2486,12 +2485,12 @@ static int dp_panel_deinit_panel_info(struct dp_panel *dp_panel, u32 flags)
 	struct sde_connector_state *c_state;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
 	if (flags & DP_PANEL_SRC_INITIATED_POWER_DOWN) {
-		pr_debug("retain states in src initiated power down request\n");
+		DP_DEBUG("retain states in src initiated power down request\n");
 		return 0;
 	}
 
@@ -2530,7 +2529,7 @@ static u32 dp_panel_get_min_req_link_rate(struct dp_panel *dp_panel)
 	struct dp_panel_info *pinfo;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		goto end;
 	}
 
@@ -2542,7 +2541,7 @@ static u32 dp_panel_get_min_req_link_rate(struct dp_panel *dp_panel)
 				(lane_cnt * encoding_factx10);
 	min_link_rate_khz *= pinfo->bpp;
 
-	pr_debug("min lclk req=%d khz for pclk=%d khz, lanes=%d, bpp=%d\n",
+	DP_DEBUG("min lclk req=%d khz for pclk=%d khz, lanes=%d, bpp=%d\n",
 		min_link_rate_khz, pinfo->pixel_clk_khz, lane_cnt,
 		pinfo->bpp);
 end:
@@ -2554,7 +2553,7 @@ static bool dp_panel_hdr_supported(struct dp_panel *dp_panel)
 	struct dp_panel_private *panel;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return false;
 	}
 
@@ -2631,19 +2630,19 @@ static u32 dp_panel_calc_dhdr_pkt_limit(struct dp_panel *dp_panel,
 
 	calc_pkt_limit = target_period / deploy_period;
 
-	pr_debug("input: %d, %d, %d, %d, %d, 0x%llx, %d, %d\n",
+	DP_DEBUG("input: %d, %d, %d, %d, %d, 0x%llx, %d, %d\n",
 		input->mdp_clk, input->lclk, input->pclk, input->h_active,
 		input->nlanes, input->mst_target_sc, input->mst_en ? 1 : 0,
 		input->fec_en ? 1 : 0);
-	pr_debug("factors: %d, %d, %d, %d, %d\n", f1, f2, f3, f4, f5);
-	pr_debug("d_p: %d, t_p: %d, maxPkts: %d%s\n", deploy_period,
+	DP_DEBUG("factors: %d, %d, %d, %d, %d\n", f1, f2, f3, f4, f5);
+	DP_DEBUG("d_p: %d, t_p: %d, maxPkts: %d%s\n", deploy_period,
 		target_period, calc_pkt_limit, calc_pkt_limit > max_pkt_limit ?
 		" CAPPED" : "");
 
 	if (calc_pkt_limit > max_pkt_limit)
 		calc_pkt_limit = max_pkt_limit;
 
-	pr_debug("packet limit per line = %d\n", calc_pkt_limit);
+	DP_DEBUG("packet limit per line = %d\n", calc_pkt_limit);
 	return calc_pkt_limit;
 }
 
@@ -2657,7 +2656,7 @@ static int dp_panel_setup_hdr(struct dp_panel *dp_panel,
 	struct dp_dhdr_maxpkt_calc_input input;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
@@ -2739,18 +2738,18 @@ static int dp_panel_spd_config(struct dp_panel *dp_panel)
 	struct dp_panel_private *panel;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto end;
 	}
 
 	if (dp_panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream id:%d\n", dp_panel->stream_id);
+		DP_ERR("invalid stream id:%d\n", dp_panel->stream_id);
 		return -EINVAL;
 	}
 
 	if (!dp_panel->spd_enabled) {
-		pr_debug("SPD Infoframe not enabled\n");
+		DP_DEBUG("SPD Infoframe not enabled\n");
 		goto end;
 	}
 
@@ -2847,8 +2846,8 @@ static void dp_panel_resolution_info(struct dp_panel_private *panel)
 	 * print resolution info as this is a result
 	 * of user initiated action of cable connection
 	 */
-	pr_info("DP RESOLUTION: active(back|front|width|low)\n");
-	pr_info("%d(%d|%d|%d|%d)x%d(%d|%d|%d|%d)@%dfps %dbpp %dKhz %dLR %dLn\n",
+	DP_INFO("DP RESOLUTION: active(back|front|width|low)\n");
+	DP_INFO("%d(%d|%d|%d|%d)x%d(%d|%d|%d|%d)@%dfps %dbpp %dKhz %dLR %dLn\n",
 		pinfo->h_active, pinfo->h_back_porch, pinfo->h_front_porch,
 		pinfo->h_sync_width, pinfo->h_active_low,
 		pinfo->v_active, pinfo->v_back_porch, pinfo->v_front_porch,
@@ -2863,12 +2862,12 @@ static int dp_panel_hw_cfg(struct dp_panel *dp_panel, bool enable)
 	struct dp_panel_private *panel;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return -EINVAL;
 	}
 
 	if (dp_panel->stream_id >= DP_STREAM_MAX) {
-		pr_err("invalid stream_id: %d\n", dp_panel->stream_id);
+		DP_ERR("invalid stream_id: %d\n", dp_panel->stream_id);
 		return -EINVAL;
 	}
 
@@ -2896,7 +2895,7 @@ static int dp_panel_read_sink_sts(struct dp_panel *dp_panel, u8 *sts, u32 size)
 	struct dp_panel_private *panel;
 
 	if (!dp_panel || !sts || !size) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		return rc;
 	}
@@ -2906,7 +2905,7 @@ static int dp_panel_read_sink_sts(struct dp_panel *dp_panel, u8 *sts, u32 size)
 	rlen = drm_dp_dpcd_read(panel->aux->drm_aux, DP_SINK_COUNT_ESI,
 		sts, size);
 	if (rlen != size) {
-		pr_err("dpcd sink sts fail rlen:%d size:%d\n", rlen, size);
+		DP_ERR("dpcd sink sts fail rlen:%d size:%d\n", rlen, size);
 		rc = -EINVAL;
 		return rc;
 	}
@@ -2935,7 +2934,7 @@ static bool dp_panel_read_mst_cap(struct dp_panel *dp_panel)
 	bool mst_cap = false;
 
 	if (!dp_panel) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return 0;
 	}
 
@@ -2944,14 +2943,14 @@ static bool dp_panel_read_mst_cap(struct dp_panel *dp_panel)
 	rlen = drm_dp_dpcd_read(panel->aux->drm_aux, DP_MSTM_CAP,
 		&dpcd, 1);
 	if (rlen < 1) {
-		pr_err("dpcd mstm_cap read failed, rlen=%d\n", rlen);
+		DP_ERR("dpcd mstm_cap read failed, rlen=%d\n", rlen);
 		goto end;
 	}
 
 	mst_cap = (dpcd & DP_MST_CAP) ? true : false;
 
 end:
-	pr_debug("dp mst-cap: %d\n", mst_cap);
+	DP_DEBUG("dp mst-cap: %d\n", mst_cap);
 
 	return mst_cap;
 }
@@ -3007,7 +3006,7 @@ static void dp_panel_convert_to_dp_mode(struct dp_panel *dp_panel,
 
 		if (dp_panel_dsc_prepare_basic_params(comp_info,
 					dp_mode, dp_panel)) {
-			pr_debug("prepare DSC basic params failed\n");
+			DP_DEBUG("prepare DSC basic params failed\n");
 			return;
 		}
 
@@ -3042,7 +3041,7 @@ struct dp_panel *dp_panel_get(struct dp_panel_in *in)
 
 	if (!in->dev || !in->catalog || !in->aux ||
 			!in->link || !in->connector) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}

msm/dp/dp_parser.c

@@ -3,12 +3,11 @@
  * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/of_gpio.h>
 #include <linux/of_platform.h>
 
 #include "dp_parser.h"
+#include "dp_debug.h"
 
 static void dp_parser_unmap_io_resources(struct dp_parser *parser)
 {
@@ -29,7 +28,7 @@ static int dp_parser_reg(struct dp_parser *parser)
 
 	reg_count = of_property_count_strings(dev->of_node, "reg-names");
 	if (reg_count <= 0) {
-		pr_err("no reg defined\n");
+		DP_ERR("no reg defined\n");
 		return -EINVAL;
 	}
 
@@ -45,7 +44,7 @@ static int dp_parser_reg(struct dp_parser *parser)
 		rc = msm_dss_ioremap_byname(pdev, &io->data[i].io,
 			io->data[i].name);
 		if (rc) {
-			pr_err("unable to remap %s resources\n",
+			DP_ERR("unable to remap %s resources\n",
 				io->data[i].name);
 			goto err;
 		}
@@ -105,27 +104,27 @@ static int dp_parser_aux(struct dp_parser *parser)
 
 		data = of_get_property(of_node, property, &len);
 		if (!data) {
-			pr_err("Unable to read %s\n", property);
+			DP_ERR("Unable to read %s\n", property);
 			goto error;
 		}
 
 		config_count = len - 1;
 		if ((config_count < minimum_config_count) ||
 			(config_count > DP_AUX_CFG_MAX_VALUE_CNT)) {
-			pr_err("Invalid config count (%d) configs for %s\n",
+			DP_ERR("Invalid config count (%d) configs for %s\n",
 					config_count, property);
 			goto error;
 		}
 
 		parser->aux_cfg[i].offset = data[0];
 		parser->aux_cfg[i].cfg_cnt = config_count;
-		pr_debug("%s offset=0x%x, cfg_cnt=%d\n",
+		DP_DEBUG("%s offset=0x%x, cfg_cnt=%d\n",
 				property,
 				parser->aux_cfg[i].offset,
 				parser->aux_cfg[i].cfg_cnt);
 		for (j = 1; j < len; j++) {
 			parser->aux_cfg[i].lut[j - 1] = data[j];
-			pr_debug("%s lut[%d]=0x%x\n",
+			DP_DEBUG("%s lut[%d]=0x%x\n",
 					property,
 					i,
 					parser->aux_cfg[i].lut[j - 1]);
@@ -178,14 +177,14 @@ static int dp_parser_msm_hdcp_dev(struct dp_parser *parser)
 	node = of_find_compatible_node(NULL, NULL, "qcom,msm-hdcp");
 	if (!node) {
 		// This is a non-fatal error, module initialization can proceed
-		pr_warn("couldn't find msm-hdcp node\n");
+		DP_WARN("couldn't find msm-hdcp node\n");
 		return 0;
 	}
 
 	pdev = of_find_device_by_node(node);
 	if (!pdev) {
 		// This is a non-fatal error, module initialization can proceed
-		pr_warn("couldn't find msm-hdcp pdev\n");
+		DP_WARN("couldn't find msm-hdcp pdev\n");
 		return 0;
 	}
 
@@ -202,7 +201,7 @@ static int dp_parser_pinctrl(struct dp_parser *parser)
 	pinctrl->pin = devm_pinctrl_get(&parser->pdev->dev);
 
 	if (IS_ERR_OR_NULL(pinctrl->pin)) {
-		pr_debug("failed to get pinctrl, rc=%d\n", rc);
+		DP_DEBUG("failed to get pinctrl, rc=%d\n", rc);
 		goto error;
 	}
 
@@ -219,7 +218,7 @@ static int dp_parser_pinctrl(struct dp_parser *parser)
 		if (!pinctrl->state_hpd_tlmm || !pinctrl->state_hpd_ctrl) {
 			pinctrl->state_hpd_tlmm = NULL;
 			pinctrl->state_hpd_ctrl = NULL;
-			pr_debug("tlmm or ctrl pinctrl state does not exist\n");
+			DP_DEBUG("tlmm or ctrl pinctrl state does not exist\n");
 		}
 	}
 
@@ -227,7 +226,7 @@ static int dp_parser_pinctrl(struct dp_parser *parser)
 					"mdss_dp_active");
 	if (IS_ERR_OR_NULL(pinctrl->state_active)) {
 		rc = PTR_ERR(pinctrl->state_active);
-		pr_err("failed to get pinctrl active state, rc=%d\n", rc);
+		DP_ERR("failed to get pinctrl active state, rc=%d\n", rc);
 		goto error;
 	}
 
@@ -235,7 +234,7 @@ static int dp_parser_pinctrl(struct dp_parser *parser)
 					"mdss_dp_sleep");
 	if (IS_ERR_OR_NULL(pinctrl->state_suspend)) {
 		rc = PTR_ERR(pinctrl->state_suspend);
-		pr_err("failed to get pinctrl suspend state, rc=%d\n", rc);
+		DP_ERR("failed to get pinctrl suspend state, rc=%d\n", rc);
 		goto error;
 	}
 error:
@@ -275,7 +274,7 @@ static int dp_parser_gpio(struct dp_parser *parser)
 			dp_gpios[i], 0);
 
 		if (!gpio_is_valid(mp->gpio_config[i].gpio)) {
-			pr_debug("%s gpio not specified\n", dp_gpios[i]);
+			DP_DEBUG("%s gpio not specified\n", dp_gpios[i]);
 			/* In case any gpio was not specified, we think gpio
 			 * aux switch also was not specified.
 			 */
@@ -317,17 +316,17 @@ static int dp_parser_get_vreg(struct dp_parser *parser,
 	pm_supply_name = dp_parser_supply_node_name(module);
 	supply_root_node = of_get_child_by_name(of_node, pm_supply_name);
 	if (!supply_root_node) {
-		pr_err("no supply entry present: %s\n", pm_supply_name);
+		DP_WARN("no supply entry present: %s\n", pm_supply_name);
 		goto novreg;
 	}
 
 	mp->num_vreg = of_get_available_child_count(supply_root_node);
 
 	if (mp->num_vreg == 0) {
-		pr_debug("no vreg\n");
+		DP_DEBUG("no vreg\n");
 		goto novreg;
 	} else {
-		pr_debug("vreg found. count=%d\n", mp->num_vreg);
+		DP_DEBUG("vreg found. count=%d\n", mp->num_vreg);
 	}
 
 	mp->vreg_config = devm_kzalloc(&parser->pdev->dev,
@@ -343,7 +342,7 @@ static int dp_parser_get_vreg(struct dp_parser *parser,
 		rc = of_property_read_string(supply_node,
 			"qcom,supply-name", &st);
 		if (rc) {
-			pr_err("error reading name. rc=%d\n",
+			DP_ERR("error reading name. rc=%d\n",
 				 rc);
 			goto error;
 		}
@@ -353,7 +352,7 @@ static int dp_parser_get_vreg(struct dp_parser *parser,
 		rc = of_property_read_u32(supply_node,
 			"qcom,supply-min-voltage", &tmp);
 		if (rc) {
-			pr_err("error reading min volt. rc=%d\n",
+			DP_ERR("error reading min volt. rc=%d\n",
 				rc);
 			goto error;
 		}
@@ -363,7 +362,7 @@ static int dp_parser_get_vreg(struct dp_parser *parser,
 		rc = of_property_read_u32(supply_node,
 			"qcom,supply-max-voltage", &tmp);
 		if (rc) {
-			pr_err("error reading max volt. rc=%d\n",
+			DP_ERR("error reading max volt. rc=%d\n",
 				rc);
 			goto error;
 		}
@@ -373,7 +372,7 @@ static int dp_parser_get_vreg(struct dp_parser *parser,
 		rc = of_property_read_u32(supply_node,
 			"qcom,supply-enable-load", &tmp);
 		if (rc) {
-			pr_err("error reading enable load. rc=%d\n",
+			DP_ERR("error reading enable load. rc=%d\n",
 				rc);
 			goto error;
 		}
@@ -383,13 +382,13 @@ static int dp_parser_get_vreg(struct dp_parser *parser,
 		rc = of_property_read_u32(supply_node,
 			"qcom,supply-disable-load", &tmp);
 		if (rc) {
-			pr_err("error reading disable load. rc=%d\n",
+			DP_ERR("error reading disable load. rc=%d\n",
 				rc);
 			goto error;
 		}
 		mp->vreg_config[i].disable_load = tmp;
 
-		pr_debug("%s min=%d, max=%d, enable=%d, disable=%d\n",
+		DP_DEBUG("%s min=%d, max=%d, enable=%d, disable=%d\n",
 			mp->vreg_config[i].vreg_name,
 			mp->vreg_config[i].min_voltage,
 			mp->vreg_config[i].max_voltage,
@@ -436,7 +435,7 @@ static int dp_parser_regulator(struct dp_parser *parser)
 	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
 		rc = dp_parser_get_vreg(parser, i);
 		if (rc) {
-			pr_err("get_dt_vreg_data failed for %s. rc=%d\n",
+			DP_ERR("get_dt_vreg_data failed for %s. rc=%d\n",
 				dp_parser_pm_name(i), rc);
 			i--;
 			for (; i >= DP_CORE_PM; i--)
@@ -504,7 +503,7 @@ static int dp_parser_init_clk_data(struct dp_parser *parser)
 
 	num_clk = of_property_count_strings(dev->of_node, "clock-names");
 	if (num_clk <= 0) {
-		pr_err("no clocks are defined\n");
+		DP_ERR("no clocks are defined\n");
 		rc = -EINVAL;
 		goto exit;
 	}
@@ -528,7 +527,7 @@ static int dp_parser_init_clk_data(struct dp_parser *parser)
 
 	/* Initialize the CORE power module */
 	if (core_clk_count <= 0) {
-		pr_err("no core clocks are defined\n");
+		DP_ERR("no core clocks are defined\n");
 		rc = -EINVAL;
 		goto exit;
 	}
@@ -544,7 +543,7 @@ static int dp_parser_init_clk_data(struct dp_parser *parser)
 
 	/* Initialize the STREAM0 power module */
 	if (strm0_clk_count <= 0) {
-		pr_debug("no strm0 clocks are defined\n");
+		DP_DEBUG("no strm0 clocks are defined\n");
 	} else {
 		strm0_power->num_clk = strm0_clk_count;
 		strm0_power->clk_config = devm_kzalloc(dev,
@@ -559,7 +558,7 @@ static int dp_parser_init_clk_data(struct dp_parser *parser)
 
 	/* Initialize the STREAM1 power module */
 	if (strm1_clk_count <= 0) {
-		pr_debug("no strm1 clocks are defined\n");
+		DP_DEBUG("no strm1 clocks are defined\n");
 	} else {
 		strm1_power->num_clk = strm1_clk_count;
 		strm1_power->clk_config = devm_kzalloc(dev,
@@ -574,7 +573,7 @@ static int dp_parser_init_clk_data(struct dp_parser *parser)
 
 	/* Initialize the link power module */
 	if (link_clk_count <= 0) {
-		pr_err("no link clocks are defined\n");
+		DP_ERR("no link clocks are defined\n");
 		rc = -EINVAL;
 		goto link_clock_error;
 	}
@@ -627,7 +626,7 @@ static int dp_parser_clock(struct dp_parser *parser)
 
 	rc =  dp_parser_init_clk_data(parser);
 	if (rc) {
-		pr_err("failed to initialize power data\n");
+		DP_ERR("failed to initialize power data\n");
 		rc = -EINVAL;
 		goto exit;
 	}
@@ -680,7 +679,7 @@ static int dp_parser_clock(struct dp_parser *parser)
 		}
 	}
 
-	pr_debug("clock parsing successful\n");
+	DP_DEBUG("clock parsing successful\n");
 
 exit:
 	return rc;
@@ -709,7 +708,7 @@ static int dp_parser_mst(struct dp_parser *parser)
 			"qcom,mst-enable");
 	parser->has_mst_sideband = parser->has_mst;
 
-	pr_debug("mst parsing successful. mst:%d\n", parser->has_mst);
+	DP_DEBUG("mst parsing successful. mst:%d\n", parser->has_mst);
 
 	for (i = 0; i < MAX_DP_MST_STREAMS; i++) {
 		of_property_read_u32_index(dev->of_node,
@@ -739,7 +738,7 @@ static void dp_parser_dsc(struct dp_parser *parser)
 	if (rc || !parser->max_dp_dsc_input_width_pixs)
 		parser->dsc_feature_enable = false;
 
-	pr_debug("dsc parsing successful. dsc:%d, blks:%d, width:%d\n",
+	DP_DEBUG("dsc parsing successful. dsc:%d, blks:%d, width:%d\n",
 			parser->dsc_feature_enable,
 			parser->max_dp_dsc_blks,
 			parser->max_dp_dsc_input_width_pixs);
@@ -752,7 +751,7 @@ static void dp_parser_fec(struct dp_parser *parser)
 	parser->fec_feature_enable = of_property_read_bool(dev->of_node,
 			"qcom,fec-feature-enable");
 
-	pr_debug("fec parsing successful. fec:%d\n",
+	DP_DEBUG("fec parsing successful. fec:%d\n",
 			parser->fec_feature_enable);
 }
 
@@ -763,7 +762,7 @@ static void dp_parser_widebus(struct dp_parser *parser)
 	parser->has_widebus = of_property_read_bool(dev->of_node,
 			"qcom,widebus-enable");
 
-	pr_debug("widebus parsing successful. widebus:%d\n",
+	DP_DEBUG("widebus parsing successful. widebus:%d\n",
 			parser->has_widebus);
 }
 
@@ -772,7 +771,7 @@ static int dp_parser_parse(struct dp_parser *parser)
 	int rc = 0;
 
 	if (!parser) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto err;
 	}
@@ -831,7 +830,7 @@ static struct dp_io_data *dp_parser_get_io(struct dp_parser *dp_parser,
 	struct dp_io *io;
 
 	if (!dp_parser) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		goto err;
 	}
 
@@ -853,7 +852,7 @@ static void dp_parser_get_io_buf(struct dp_parser *dp_parser, char *name)
 	struct dp_io *io;
 
 	if (!dp_parser) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -876,7 +875,7 @@ static void dp_parser_clear_io_buf(struct dp_parser *dp_parser)
 	struct dp_io *io;
 
 	if (!dp_parser) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		return;
 	}
 
@@ -915,7 +914,7 @@ void dp_parser_put(struct dp_parser *parser)
 	struct dss_module_power *power = NULL;
 
 	if (!parser) {
-		pr_err("invalid parser module\n");
+		DP_ERR("invalid parser module\n");
 		return;
 	}
 

msm/dp/dp_power.c

@@ -3,13 +3,12 @@
  * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/clk.h>
 #include <linux/pm_runtime.h>
 #include <drm/drmP.h>
 #include "dp_power.h"
 #include "dp_catalog.h"
+#include "dp_debug.h"
 
 #define DP_CLIENT_NAME_SIZE	20
 
@@ -43,7 +42,7 @@ static int dp_power_regulator_init(struct dp_power_private *power)
 			parser->mp[i].vreg_config,
 			parser->mp[i].num_vreg, 1);
 		if (rc) {
-			pr_err("failed to init vregs for %s\n",
+			DP_ERR("failed to init vregs for %s\n",
 				dp_parser_pm_name(i));
 			for (j = i - 1; j >= DP_CORE_PM; j--) {
 				msm_dss_config_vreg(&pdev->dev,
@@ -72,7 +71,7 @@ static void dp_power_regulator_deinit(struct dp_power_private *power)
 			parser->mp[i].vreg_config,
 			parser->mp[i].num_vreg, 0);
 		if (rc)
-			pr_err("failed to deinit vregs for %s\n",
+			DP_ERR("failed to deinit vregs for %s\n",
 				dp_parser_pm_name(i));
 	}
 }
@@ -89,7 +88,7 @@ static int dp_power_regulator_ctrl(struct dp_power_private *power, bool enable)
 			parser->mp[i].vreg_config,
 			parser->mp[i].num_vreg, enable);
 		if (rc) {
-			pr_err("failed to '%s' vregs for %s\n",
+			DP_ERR("failed to '%s' vregs for %s\n",
 					enable ? "enable" : "disable",
 					dp_parser_pm_name(i));
 			if (enable) {
@@ -124,7 +123,7 @@ static int dp_power_pinctrl_set(struct dp_power_private *power, bool active)
 			rc = pinctrl_select_state(parser->pinctrl.pin,
 				pin_state);
 			if (rc) {
-				pr_err("cannot direct hpd line to %s\n",
+				DP_ERR("cannot direct hpd line to %s\n",
 					active ? "ctrl" : "tlmm");
 				return rc;
 			}
@@ -140,11 +139,11 @@ static int dp_power_pinctrl_set(struct dp_power_private *power, bool active)
 		rc = pinctrl_select_state(parser->pinctrl.pin,
 				pin_state);
 		if (rc)
-			pr_err("can not set %s pins\n",
+			DP_ERR("can not set %s pins\n",
 			       active ? "dp_active"
 			       : "dp_sleep");
 	} else {
-		pr_err("invalid '%s' pinstate\n",
+		DP_ERR("invalid '%s' pinstate\n",
 		       active ? "dp_active"
 		       : "dp_sleep");
 	}
@@ -170,7 +169,7 @@ static int dp_power_clk_init(struct dp_power_private *power, bool enable)
 
 			rc = msm_dss_get_clk(dev, pm->clk_config, pm->num_clk);
 			if (rc) {
-				pr_err("failed to get %s clk. err=%d\n",
+				DP_ERR("failed to get %s clk. err=%d\n",
 					dp_parser_pm_name(module), rc);
 				goto exit;
 			}
@@ -178,25 +177,25 @@ static int dp_power_clk_init(struct dp_power_private *power, bool enable)
 
 		power->pixel_clk_rcg = devm_clk_get(dev, "pixel_clk_rcg");
 		if (IS_ERR(power->pixel_clk_rcg)) {
-			pr_debug("Unable to get DP pixel clk RCG\n");
+			DP_DEBUG("Unable to get DP pixel clk RCG\n");
 			power->pixel_clk_rcg = NULL;
 		}
 
 		power->pixel_parent = devm_clk_get(dev, "pixel_parent");
 		if (IS_ERR(power->pixel_parent)) {
-			pr_debug("Unable to get DP pixel RCG parent\n");
+			DP_DEBUG("Unable to get DP pixel RCG parent\n");
 			power->pixel_parent = NULL;
 		}
 
 		power->pixel1_clk_rcg = devm_clk_get(dev, "pixel1_clk_rcg");
 		if (IS_ERR(power->pixel1_clk_rcg)) {
-			pr_debug("Unable to get DP pixel1 clk RCG\n");
+			DP_DEBUG("Unable to get DP pixel1 clk RCG\n");
 			power->pixel1_clk_rcg = NULL;
 		}
 
 		power->pixel1_parent = devm_clk_get(dev, "pixel1_parent");
 		if (IS_ERR(power->pixel1_parent)) {
-			pr_debug("Unable to get DP pixel1 RCG parent\n");
+			DP_DEBUG("Unable to get DP pixel1 RCG parent\n");
 			power->pixel1_parent = NULL;
 		}
 	} else {
@@ -233,7 +232,7 @@ static int dp_power_clk_set_rate(struct dp_power_private *power,
 	struct dss_module_power *mp;
 
 	if (!power) {
-		pr_err("invalid power data\n");
+		DP_ERR("invalid power data\n");
 		rc = -EINVAL;
 		goto exit;
 	}
@@ -243,19 +242,19 @@ static int dp_power_clk_set_rate(struct dp_power_private *power,
 	if (enable) {
 		rc = msm_dss_clk_set_rate(mp->clk_config, mp->num_clk);
 		if (rc) {
-			pr_err("failed to set clks rate.\n");
+			DP_ERR("failed to set clks rate.\n");
 			goto exit;
 		}
 
 		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 1);
 		if (rc) {
-			pr_err("failed to enable clks\n");
+			DP_ERR("failed to enable clks\n");
 			goto exit;
 		}
 	} else {
 		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 0);
 		if (rc) {
-			pr_err("failed to disable clks\n");
+			DP_ERR("failed to disable clks\n");
 				goto exit;
 		}
 	}
@@ -271,7 +270,7 @@ static int dp_power_clk_enable(struct dp_power *dp_power,
 	struct dp_power_private *power;
 
 	if (!dp_power) {
-		pr_err("invalid power data\n");
+		DP_ERR("invalid power data\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -281,33 +280,33 @@ static int dp_power_clk_enable(struct dp_power *dp_power,
 	mp = &power->parser->mp[pm_type];
 
 	if (pm_type >= DP_MAX_PM) {
-		pr_err("unsupported power module: %s\n",
+		DP_ERR("unsupported power module: %s\n",
 				dp_parser_pm_name(pm_type));
 		return -EINVAL;
 	}
 
 	if (enable) {
 		if (pm_type == DP_CORE_PM && power->core_clks_on) {
-			pr_debug("core clks already enabled\n");
+			DP_DEBUG("core clks already enabled\n");
 			return 0;
 		}
 
 		if ((pm_type == DP_STREAM0_PM) && (power->strm0_clks_on)) {
-			pr_debug("strm0 clks already enabled\n");
+			DP_DEBUG("strm0 clks already enabled\n");
 			return 0;
 		}
 
 		if ((pm_type == DP_STREAM1_PM) && (power->strm1_clks_on)) {
-			pr_debug("strm1 clks already enabled\n");
+			DP_DEBUG("strm1 clks already enabled\n");
 			return 0;
 		}
 
 		if ((pm_type == DP_CTRL_PM) && (!power->core_clks_on)) {
-			pr_debug("Need to enable core clks before link clks\n");
+			DP_DEBUG("Need to enable core clks before link clks\n");
 
 			rc = dp_power_clk_set_rate(power, pm_type, enable);
 			if (rc) {
-				pr_err("failed to enable clks: %s. err=%d\n",
+				DP_ERR("failed to enable clks: %s. err=%d\n",
 					dp_parser_pm_name(DP_CORE_PM), rc);
 				goto error;
 			} else {
@@ -316,14 +315,14 @@ static int dp_power_clk_enable(struct dp_power *dp_power,
 		}
 
 		if (pm_type == DP_LINK_PM && power->link_clks_on) {
-			pr_debug("links clks already enabled\n");
+			DP_DEBUG("links clks already enabled\n");
 			return 0;
 		}
 	}
 
 	rc = dp_power_clk_set_rate(power, pm_type, enable);
 	if (rc) {
-		pr_err("failed to '%s' clks for: %s. err=%d\n",
+		DP_ERR("failed to '%s' clks for: %s. err=%d\n",
 			enable ? "enable" : "disable",
 			dp_parser_pm_name(pm_type), rc);
 			goto error;
@@ -344,7 +343,7 @@ static int dp_power_clk_enable(struct dp_power *dp_power,
 	 * usecase, it is not going to flood the kernel logs. Also,
 	 * helpful in debugging the NOC issues.
 	 */
-	pr_info("core:%s link:%s strm0:%s strm1:%s\n",
+	DP_INFO("core:%s link:%s strm0:%s strm1:%s\n",
 		power->core_clks_on ? "on" : "off",
 		power->link_clks_on ? "on" : "off",
 		power->strm0_clks_on ? "on" : "off",
@@ -363,7 +362,7 @@ static int dp_power_request_gpios(struct dp_power_private *power)
 	};
 
 	if (!power) {
-		pr_err("invalid power data\n");
+		DP_ERR("invalid power data\n");
 		return -EINVAL;
 	}
 
@@ -376,7 +375,7 @@ static int dp_power_request_gpios(struct dp_power_private *power)
 		if (gpio_is_valid(gpio)) {
 			rc = devm_gpio_request(dev, gpio, gpio_names[i]);
 			if (rc) {
-				pr_err("request %s gpio failed, rc=%d\n",
+				DP_ERR("request %s gpio failed, rc=%d\n",
 					       gpio_names[i], rc);
 				goto error;
 			}
@@ -409,7 +408,7 @@ static void dp_power_set_gpio(struct dp_power_private *power, bool flip)
 			config->value = flip;
 
 		if (gpio_is_valid(config->gpio)) {
-			pr_debug("gpio %s, value %d\n", config->gpio_name,
+			DP_DEBUG("gpio %s, value %d\n", config->gpio_name,
 				config->value);
 
 			if (dp_power_find_gpio(config->gpio_name, "aux-en") ||
@@ -440,7 +439,7 @@ static int dp_power_config_gpios(struct dp_power_private *power, bool flip,
 	if (enable) {
 		rc = dp_power_request_gpios(power);
 		if (rc) {
-			pr_err("gpio request failed\n");
+			DP_ERR("gpio request failed\n");
 			return rc;
 		}
 
@@ -464,7 +463,7 @@ static int dp_power_client_init(struct dp_power *dp_power,
 	struct dp_power_private *power;
 
 	if (!drm_dev) {
-		pr_err("invalid drm_dev\n");
+		DP_ERR("invalid drm_dev\n");
 		return -EINVAL;
 	}
 
@@ -472,13 +471,13 @@ static int dp_power_client_init(struct dp_power *dp_power,
 
 	rc = dp_power_regulator_init(power);
 	if (rc) {
-		pr_err("failed to init regulators\n");
+		DP_ERR("failed to init regulators\n");
 		goto error_power;
 	}
 
 	rc = dp_power_clk_init(power, true);
 	if (rc) {
-		pr_err("failed to init clocks\n");
+		DP_ERR("failed to init clocks\n");
 		goto error_clk;
 	}
 	dp_power->phandle = phandle;
@@ -497,7 +496,7 @@ static void dp_power_client_deinit(struct dp_power *dp_power)
 	struct dp_power_private *power;
 
 	if (!dp_power) {
-		pr_err("invalid power data\n");
+		DP_ERR("invalid power data\n");
 		return;
 	}
 
@@ -513,7 +512,7 @@ static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power, u32 strm_id)
 	struct dp_power_private *power;
 
 	if (!dp_power || strm_id >= DP_STREAM_MAX) {
-		pr_err("invalid power data. stream %d\n", strm_id);
+		DP_ERR("invalid power data. stream %d\n", strm_id);
 		rc = -EINVAL;
 		goto exit;
 	}
@@ -543,7 +542,7 @@ static u64 dp_power_clk_get_rate(struct dp_power *dp_power, char *clk_name)
 	u64 rate = 0;
 
 	if (!clk_name) {
-		pr_err("invalid pointer for clk_name\n");
+		DP_ERR("invalid pointer for clk_name\n");
 		return 0;
 	}
 
@@ -577,7 +576,7 @@ static int dp_power_init(struct dp_power *dp_power, bool flip)
 	struct dp_power_private *power;
 
 	if (!dp_power) {
-		pr_err("invalid power data\n");
+		DP_ERR("invalid power data\n");
 		rc = -EINVAL;
 		goto exit;
 	}
@@ -586,31 +585,31 @@ static int dp_power_init(struct dp_power *dp_power, bool flip)
 
 	rc = dp_power_regulator_ctrl(power, true);
 	if (rc) {
-		pr_err("failed to enable regulators\n");
+		DP_ERR("failed to enable regulators\n");
 		goto exit;
 	}
 
 	rc = dp_power_pinctrl_set(power, true);
 	if (rc) {
-		pr_err("failed to set pinctrl state\n");
+		DP_ERR("failed to set pinctrl state\n");
 		goto err_pinctrl;
 	}
 
 	rc = dp_power_config_gpios(power, flip, true);
 	if (rc) {
-		pr_err("failed to enable gpios\n");
+		DP_ERR("failed to enable gpios\n");
 		goto err_gpio;
 	}
 
 	rc = pm_runtime_get_sync(dp_power->drm_dev->dev);
 	if (rc < 0) {
-		pr_err("Power resource enable failed\n");
+		DP_ERR("Power resource enable failed\n");
 		goto err_sde_power;
 	}
 
 	rc = dp_power_clk_enable(dp_power, DP_CORE_PM, true);
 	if (rc) {
-		pr_err("failed to enable DP core clocks\n");
+		DP_ERR("failed to enable DP core clocks\n");
 		goto err_clk;
 	}
 
@@ -634,7 +633,7 @@ static int dp_power_deinit(struct dp_power *dp_power)
 	struct dp_power_private *power;
 
 	if (!dp_power) {
-		pr_err("invalid power data\n");
+		DP_ERR("invalid power data\n");
 		rc = -EINVAL;
 		goto exit;
 	}
@@ -661,7 +660,7 @@ struct dp_power *dp_power_get(struct dp_parser *parser)
 	struct dp_power *dp_power;
 
 	if (!parser) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}

msm/dp/dp_usbpd.c

@@ -3,14 +3,13 @@
  * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
  */
 
-#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
-
 #include <linux/usb/usbpd.h>
 #include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/delay.h>
 
 #include "dp_usbpd.h"
+#include "dp_debug.h"
 
 /* DP specific VDM commands */
 #define DP_USBPD_VDM_STATUS	0x10
@@ -123,7 +122,7 @@ static void dp_usbpd_init_port(enum dp_usbpd_port *port, u32 in_port)
 	default:
 		*port = DP_USBPD_PORT_NONE;
 	}
-	pr_debug("port:%s\n", dp_usbpd_port_name(*port));
+	DP_DEBUG("port:%s\n", dp_usbpd_port_name(*port));
 }
 
 static void dp_usbpd_get_capabilities(struct dp_usbpd_private *pd)
@@ -153,13 +152,13 @@ static void dp_usbpd_get_status(struct dp_usbpd_private *pd)
 	status->base.hpd_high  = (buf & BIT(7)) ? true : false;
 	status->base.hpd_irq   = (buf & BIT(8)) ? true : false;
 
-	pr_debug("low_pow_st = %d, adaptor_dp_en = %d, multi_func = %d\n",
+	DP_DEBUG("low_pow_st = %d, adaptor_dp_en = %d, multi_func = %d\n",
 			status->low_pow_st, status->adaptor_dp_en,
 			status->base.multi_func);
-	pr_debug("usb_config_req = %d, exit_dp_mode = %d, hpd_high =%d\n",
+	DP_DEBUG("usb_config_req = %d, exit_dp_mode = %d, hpd_high =%d\n",
 			status->usb_config_req,
 			status->exit_dp_mode, status->base.hpd_high);
-	pr_debug("hpd_irq = %d\n", status->base.hpd_irq);
+	DP_DEBUG("hpd_irq = %d\n", status->base.hpd_irq);
 
 	dp_usbpd_init_port(&status->port, port);
 }
@@ -189,14 +188,14 @@ static u32 dp_usbpd_gen_config_pkt(struct dp_usbpd_private *pd)
 	if (pin == DP_USBPD_PIN_MAX)
 		pin = DP_USBPD_PIN_C;
 
-	pr_debug("pin assignment: %s\n", dp_usbpd_pin_name(pin));
+	DP_DEBUG("pin assignment: %s\n", dp_usbpd_pin_name(pin));
 
 	config |= BIT(pin) << 8;
 
 	config |= (dp_ver << 2);
 	config |= ufp_d_config;
 
-	pr_debug("config = 0x%x\n", config);
+	DP_DEBUG("config = 0x%x\n", config);
 	return config;
 }
 
@@ -232,7 +231,7 @@ static void dp_usbpd_send_event(struct dp_usbpd_private *pd,
 			SVDM_CMD_TYPE_INITIATOR, 0x1, &config, 0x1);
 		break;
 	default:
-		pr_err("unknown event:%d\n", event);
+		DP_ERR("unknown event:%d\n", event);
 	}
 }
 
@@ -242,11 +241,11 @@ static void dp_usbpd_connect_cb(struct usbpd_svid_handler *hdlr)
 
 	pd = container_of(hdlr, struct dp_usbpd_private, svid_handler);
 	if (!pd) {
-		pr_err("get_usbpd phandle failed\n");
+		DP_ERR("get_usbpd phandle failed\n");
 		return;
 	}
 
-	pr_debug("\n");
+	DP_DEBUG("\n");
 	dp_usbpd_send_event(pd, DP_USBPD_EVT_DISCOVER);
 }
 
@@ -256,13 +255,13 @@ static void dp_usbpd_disconnect_cb(struct usbpd_svid_handler *hdlr)
 
 	pd = container_of(hdlr, struct dp_usbpd_private, svid_handler);
 	if (!pd) {
-		pr_err("get_usbpd phandle failed\n");
+		DP_ERR("get_usbpd phandle failed\n");
 		return;
 	}
 
 	pd->alt_mode = DP_USBPD_ALT_MODE_NONE;
 	pd->dp_usbpd.base.alt_mode_cfg_done = false;
-	pr_debug("\n");
+	DP_DEBUG("\n");
 
 	if (pd->dp_cb && pd->dp_cb->disconnect)
 		pd->dp_cb->disconnect(pd->dev);
@@ -274,32 +273,32 @@ static int dp_usbpd_validate_callback(u8 cmd,
 	int ret = 0;
 
 	if (cmd_type == SVDM_CMD_TYPE_RESP_NAK) {
-		pr_err("error: NACK\n");
+		DP_ERR("error: NACK\n");
 		ret = -EINVAL;
 		goto end;
 	}
 
 	if (cmd_type == SVDM_CMD_TYPE_RESP_BUSY) {
-		pr_err("error: BUSY\n");
+		DP_ERR("error: BUSY\n");
 		ret = -EBUSY;
 		goto end;
 	}
 
 	if (cmd == USBPD_SVDM_ATTENTION) {
 		if (cmd_type != SVDM_CMD_TYPE_INITIATOR) {
-			pr_err("error: invalid cmd type for attention\n");
+			DP_ERR("error: invalid cmd type for attention\n");
 			ret = -EINVAL;
 			goto end;
 		}
 
 		if (!num_vdos) {
-			pr_err("error: no vdo provided\n");
+			DP_ERR("error: no vdo provided\n");
 			ret = -EINVAL;
 			goto end;
 		}
 	} else {
 		if (cmd_type != SVDM_CMD_TYPE_RESP_ACK) {
-			pr_err("error: invalid cmd type\n");
+			DP_ERR("error: invalid cmd type\n");
 			ret = -EINVAL;
 		}
 	}
@@ -328,7 +327,7 @@ static int dp_usbpd_get_ss_lanes(struct dp_usbpd_private *pd)
 			if (rc != -EBUSY)
 				break;
 
-			pr_warn("USB busy, retry\n");
+			DP_WARN("USB busy, retry\n");
 
 			/* wait for hw recommended delay for usb */
 			msleep(20);
@@ -348,11 +347,11 @@ static void dp_usbpd_response_cb(struct usbpd_svid_handler *hdlr, u8 cmd,
 
 	pd = container_of(hdlr, struct dp_usbpd_private, svid_handler);
 
-	pr_debug("callback -> cmd: %s, *vdos = 0x%x, num_vdos = %d\n",
+	DP_DEBUG("callback -> cmd: %s, *vdos = 0x%x, num_vdos = %d\n",
 				dp_usbpd_cmd_name(cmd), *vdos, num_vdos);
 
 	if (dp_usbpd_validate_callback(cmd, cmd_type, num_vdos)) {
-		pr_debug("invalid callback received\n");
+		DP_DEBUG("invalid callback received\n");
 		return;
 	}
 
@@ -409,7 +408,7 @@ static void dp_usbpd_response_cb(struct usbpd_svid_handler *hdlr, u8 cmd,
 
 		rc = dp_usbpd_get_ss_lanes(pd);
 		if (rc) {
-			pr_err("failed to get SuperSpeed lanes\n");
+			DP_ERR("failed to get SuperSpeed lanes\n");
 			break;
 		}
 
@@ -417,7 +416,7 @@ static void dp_usbpd_response_cb(struct usbpd_svid_handler *hdlr, u8 cmd,
 			pd->dp_cb->configure(pd->dev);
 		break;
 	default:
-		pr_err("unknown cmd: %d\n", cmd);
+		DP_ERR("unknown cmd: %d\n", cmd);
 		break;
 	}
 }
@@ -429,7 +428,7 @@ static int dp_usbpd_simulate_connect(struct dp_hpd *dp_hpd, bool hpd)
 	struct dp_usbpd_private *pd;
 
 	if (!dp_hpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -441,7 +440,7 @@ static int dp_usbpd_simulate_connect(struct dp_hpd *dp_hpd, bool hpd)
 	pd->forced_disconnect = !hpd;
 	pd->dp_usbpd.base.alt_mode_cfg_done = hpd;
 
-	pr_debug("hpd_high=%d, forced_disconnect=%d, orientation=%d\n",
+	DP_DEBUG("hpd_high=%d, forced_disconnect=%d, orientation=%d\n",
 			dp_usbpd->base.hpd_high, pd->forced_disconnect,
 			pd->dp_usbpd.base.orientation);
 	if (hpd)
@@ -461,7 +460,7 @@ static int dp_usbpd_simulate_attention(struct dp_hpd *dp_hpd, int vdo)
 
 	dp_usbpd = container_of(dp_hpd, struct dp_usbpd, base);
 	if (!dp_usbpd) {
-		pr_err("invalid input\n");
+		DP_ERR("invalid input\n");
 		rc = -EINVAL;
 		goto error;
 	}
@@ -492,7 +491,7 @@ int dp_usbpd_register(struct dp_hpd *dp_hpd)
 
 	rc = usbpd_register_svid(usbpd->pd, &usbpd->svid_handler);
 	if (rc)
-		pr_err("pd registration failed\n");
+		DP_ERR("pd registration failed\n");
 
 	return rc;
 }
@@ -506,7 +505,7 @@ static void dp_usbpd_wakeup_phy(struct dp_hpd *dp_hpd, bool wakeup)
 	usbpd = container_of(dp_usbpd, struct dp_usbpd_private, dp_usbpd);
 
 	if (!usbpd->pd) {
-		pr_err("usbpd pointer invalid");
+		DP_ERR("usbpd pointer invalid");
 		return;
 	}
 
@@ -529,14 +528,14 @@ struct dp_hpd *dp_usbpd_get(struct device *dev, struct dp_hpd_cb *cb)
 	};
 
 	if (!cb) {
-		pr_err("invalid cb data\n");
+		DP_ERR("invalid cb data\n");
 		rc = -EINVAL;
 		goto error;
 	}
 
 	pd = devm_usbpd_get_by_phandle(dev, pd_phandle);
 	if (IS_ERR(pd)) {
-		pr_err("usbpd phandle failed (%ld)\n", PTR_ERR(pd));
+		DP_ERR("usbpd phandle failed (%ld)\n", PTR_ERR(pd));
 		rc = PTR_ERR(pd);
 		goto error;
 	}