Merge "disp: msm: add physical address info when dumping display registers"

msm/dp/dp_display.c

@@ -2118,23 +2118,28 @@ static void dp_display_dbg_reister(struct dp_display_private *dp)
 
 	io = &parser->get_io(parser, "dp_ahb")->io;
 	if (io)
-		sde_dbg_reg_register_base("dp_ahb", io->base, io->len, SDE_DBG_DP);
+		sde_dbg_reg_register_base("dp_ahb", io->base, io->len,
+				msm_get_phys_addr(dp->pdev, "dp_ahb"), SDE_DBG_DP);
 
 	io = &parser->get_io(parser, "dp_aux")->io;
 	if (io)
-		sde_dbg_reg_register_base("dp_aux", io->base, io->len, SDE_DBG_DP);
+		sde_dbg_reg_register_base("dp_aux", io->base, io->len,
+				msm_get_phys_addr(dp->pdev, "dp_aux"), SDE_DBG_DP);
 
 	io = &parser->get_io(parser, "dp_link")->io;
 	if (io)
-		sde_dbg_reg_register_base("dp_link", io->base, io->len, SDE_DBG_DP);
+		sde_dbg_reg_register_base("dp_link", io->base, io->len,
+				msm_get_phys_addr(dp->pdev, "dp_link"), SDE_DBG_DP);
 
 	io = &parser->get_io(parser, "dp_p0")->io;
 	if (io)
-		sde_dbg_reg_register_base("dp_p0", io->base, io->len, SDE_DBG_DP);
+		sde_dbg_reg_register_base("dp_p0", io->base, io->len,
+				msm_get_phys_addr(dp->pdev, "dp_p0"), SDE_DBG_DP);
 
 	io = &parser->get_io(parser, "hdcp_physical")->io;
 	if (io)
-		sde_dbg_reg_register_base("hdcp_physical", io->base, io->len, SDE_DBG_DP);
+		sde_dbg_reg_register_base("hdcp_physical", io->base, io->len,
+				msm_get_phys_addr(dp->pdev, "hdcp_physical"), SDE_DBG_DP);
 }
 
 static int dp_display_post_init(struct dp_display *dp_display)

msm/dsi/dsi_ctrl.c

@@ -336,7 +336,8 @@ static int dsi_ctrl_debugfs_init(struct dsi_ctrl *dsi_ctrl,
 
 	snprintf(dbg_name, DSI_DEBUG_NAME_LEN, "dsi%d_ctrl", dsi_ctrl->cell_index);
 	sde_dbg_reg_register_base(dbg_name, dsi_ctrl->hw.base,
-				msm_iomap_size(dsi_ctrl->pdev, "dsi_ctrl"), SDE_DBG_DSI);
+			msm_iomap_size(dsi_ctrl->pdev, "dsi_ctrl"),
+			msm_get_phys_addr(dsi_ctrl->pdev, "dsi_ctrl"), SDE_DBG_DSI);
 error_remove_dir:
 	debugfs_remove(dir);
 error:
@@ -356,7 +357,9 @@ static int dsi_ctrl_debugfs_init(struct dsi_ctrl *dsi_ctrl,
 
 	snprintf(dbg_name, DSI_DEBUG_NAME_LEN, "dsi%d_ctrl", dsi_ctrl->cell_index);
 	sde_dbg_reg_register_base(dbg_name, dsi_ctrl->hw.base,
-				msm_iomap_size(dsi_ctrl->pdev, "dsi_ctrl"), SDE_DBG_DSI);
+			msm_iomap_size(dsi_ctrl->pdev, "dsi_ctrl"),
+			msm_get_phys_addr(dsi_ctrl->pdev, "dsi_ctrl"), SDE_DBG_DSI);
+
 	return 0;
 }
 static int dsi_ctrl_debugfs_deinit(struct dsi_ctrl *dsi_ctrl)

msm/dsi/dsi_phy.c

@@ -689,7 +689,9 @@ int dsi_phy_drv_init(struct msm_dsi_phy *dsi_phy)
 
 	snprintf(dbg_name, DSI_DEBUG_NAME_LEN, "dsi%d_phy", dsi_phy->index);
 	sde_dbg_reg_register_base(dbg_name, dsi_phy->hw.base,
-				msm_iomap_size(dsi_phy->pdev, "dsi_phy"), SDE_DBG_DSI);
+			msm_iomap_size(dsi_phy->pdev, "dsi_phy"),
+			msm_get_phys_addr(dsi_phy->pdev, "dsi_phy"), SDE_DBG_DSI);
+
 	return 0;
 }
 

msm/msm_drv.c

@@ -301,6 +301,24 @@ unsigned long msm_iomap_size(struct platform_device *pdev, const char *name)
 	return resource_size(res);
 }
 
+unsigned long msm_get_phys_addr(struct platform_device *pdev, const char *name)
+{
+	struct resource *res;
+
+	if (!name) {
+		dev_err(&pdev->dev, "invalid block name\n");
+		return 0;
+	}
+
+	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
+	if (!res) {
+		dev_err(&pdev->dev, "failed to get memory resource: %s\n", name);
+		return 0;
+	}
+
+	return res->start;
+}
+
 void msm_iounmap(struct platform_device *pdev, void __iomem *addr)
 {
 	devm_iounmap(&pdev->dev, addr);

msm/msm_drv.h

@@ -1370,6 +1370,7 @@ struct clk *msm_clk_bulk_get_clock(struct clk_bulk_data *bulk, int count,
 void __iomem *msm_ioremap(struct platform_device *pdev, const char *name,
 		const char *dbgname);
 unsigned long msm_iomap_size(struct platform_device *pdev, const char *name);
+unsigned long msm_get_phys_addr(struct platform_device *pdev, const char *name);
 void msm_iounmap(struct platform_device *dev, void __iomem *addr);
 void msm_writel(u32 data, void __iomem *addr);
 u32 msm_readl(const void __iomem *addr);

msm/sde/sde_kms.c

@@ -4305,7 +4305,9 @@ static int _sde_kms_hw_init_ioremap(struct sde_kms *sde_kms,
 	sde_kms->mmio_len = msm_iomap_size(platformdev, "mdp_phys");
 
 	rc = sde_dbg_reg_register_base(SDE_DBG_NAME, sde_kms->mmio,
-				sde_kms->mmio_len, SDE_DBG_SDE);
+				sde_kms->mmio_len,
+				msm_get_phys_addr(platformdev, "mdp_phys"),
+				SDE_DBG_SDE);
 	if (rc)
 		SDE_ERROR("dbg base register kms failed: %d\n", rc);
 
@@ -4318,7 +4320,9 @@ static int _sde_kms_hw_init_ioremap(struct sde_kms *sde_kms,
 	}
 	sde_kms->vbif_len[VBIF_RT] = msm_iomap_size(platformdev, "vbif_phys");
 	rc = sde_dbg_reg_register_base("vbif_rt", sde_kms->vbif[VBIF_RT],
-				sde_kms->vbif_len[VBIF_RT], SDE_DBG_VBIF_RT);
+				sde_kms->vbif_len[VBIF_RT],
+				msm_get_phys_addr(platformdev, "vbif_phys"),
+				SDE_DBG_VBIF_RT);
 	if (rc)
 		SDE_ERROR("dbg base register vbif_rt failed: %d\n", rc);
 
@@ -4337,7 +4341,9 @@ static int _sde_kms_hw_init_ioremap(struct sde_kms *sde_kms,
 	} else {
 		sde_kms->reg_dma_len = msm_iomap_size(platformdev, "regdma_phys");
 		rc =  sde_dbg_reg_register_base("reg_dma", sde_kms->reg_dma,
-				sde_kms->reg_dma_len, SDE_DBG_LUTDMA);
+				sde_kms->reg_dma_len,
+				msm_get_phys_addr(platformdev, "regdma_phys"),
+				SDE_DBG_LUTDMA);
 		if (rc)
 			SDE_ERROR("dbg base register reg_dma failed: %d\n", rc);
 	}
@@ -4349,7 +4355,9 @@ static int _sde_kms_hw_init_ioremap(struct sde_kms *sde_kms,
 	} else {
 		sde_kms->sid_len = msm_iomap_size(platformdev, "sid_phys");
 		rc =  sde_dbg_reg_register_base("sid", sde_kms->sid,
-				sde_kms->sid_len, SDE_DBG_SID);
+				sde_kms->sid_len,
+				msm_get_phys_addr(platformdev, "sid_phys"),
+				SDE_DBG_SID);
 		if (rc)
 			SDE_ERROR("dbg base register sid failed: %d\n", rc);
 	}

msm/sde_dbg.c

@@ -149,6 +149,7 @@ struct sde_dbg_reg_range {
  * @sub_range_list: head to the list with dump ranges
  * @name: register base name
  * @base: base pointer
+ * @phys_addr: block physical address
  * @off: cached offset of region for manual register dumping
  * @cnt: cached range of region for manual register dumping
  * @max_offset: length of region
@@ -164,6 +165,7 @@ struct sde_dbg_reg_base {
 	struct list_head sub_range_list;
 	char name[REG_BASE_NAME_LEN];
 	void __iomem *base;
+	unsigned long phys_addr;
 	size_t off;
 	size_t cnt;
 	size_t max_offset;
@@ -541,6 +543,20 @@ static int _sde_dump_reg_range_cmp(void *priv, struct list_head *a,
 	return ar->offset.start - br->offset.start;
 }
 
+static int _sde_dump_blk_phys_addr_cmp(void *priv, struct list_head *a,
+		struct list_head *b)
+{
+	struct sde_dbg_reg_base *ar, *br;
+
+	if (!a || !b)
+		return 0;
+
+	ar = container_of(a, struct sde_dbg_reg_base, reg_base_head);
+	br = container_of(b, struct sde_dbg_reg_base, reg_base_head);
+
+	return ar->phys_addr - br->phys_addr;
+}
+
 static const char *const exclude_modules[] = {
 	"vbif_rt",
 	"vbif_nrt",
@@ -617,6 +633,8 @@ static void _sde_dump_reg_mask(u64 dump_blk_mask, bool dump_secure)
 	if (!dump_blk_mask)
 		return;
 
+	list_sort(NULL, &dbg_base->reg_base_list, _sde_dump_blk_phys_addr_cmp);
+
 	list_for_each_entry(blk_base, &dbg_base->reg_base_list, reg_base_head) {
 
 		if ((!(blk_base->blk_id & dump_blk_mask)) || (!strlen(blk_base->name)))
@@ -969,6 +987,7 @@ static void _sde_dump_array(bool do_panic, const char *name, bool dump_secure, u
 	 */
 	skip_power = (dbg_base->dump_mode == SDE_DBG_DUMP_CLK_ENABLED_CTX);
 
+	if (sde_evtlog_is_enabled(dbg_base->evtlog, SDE_EVTLOG_ALWAYS))
 		sde_evtlog_dump_all(dbg_base->evtlog);
 
 	if (!skip_power) {
@@ -1405,8 +1424,8 @@ static int  _sde_dbg_recovery_dump_reg_blk(struct sde_dbg_reg_base *blk,
 	len += snprintf(buf + len, DUMP_LINE_SIZE,
 			"==========================================\n");
 	len += snprintf(buf + len, DUMP_LINE_SIZE,
-			"*********** DUMP of %s block *************\n",
-			blk->name);
+			"****** DUMP of %s block (0x%08x) ******\n",
+			blk->name, blk->phys_addr);
 	len += snprintf(buf + len, DUMP_LINE_SIZE,
 			"count:%ld max-off:0x%lx has_sub_blk:%d\n",
 			blk->cnt, blk->max_offset,
@@ -2299,7 +2318,8 @@ int sde_dbg_dsi_ctrl_register(void __iomem *base, const char *name)
 	return 0;
 }
 
-int sde_dbg_reg_register_base(const char *name, void __iomem *base, size_t max_offset, u64 blk_id)
+int sde_dbg_reg_register_base(const char *name, void __iomem *base, size_t max_offset,
+		unsigned long phys_addr, u64 blk_id)
 {
 	struct sde_dbg_base *dbg_base = &sde_dbg_base;
 	struct sde_dbg_reg_base *reg_base;
@@ -2315,6 +2335,7 @@ int sde_dbg_reg_register_base(const char *name, void __iomem *base, size_t max_o
 
 	strlcpy(reg_base->name, name, sizeof(reg_base->name));
 	reg_base->base = base;
+	reg_base->phys_addr = phys_addr;
 	reg_base->max_offset = max_offset;
 	reg_base->off = 0;
 	reg_base->cnt = DEFAULT_BASE_REG_CNT;

msm/sde_dbg.h

@@ -403,11 +403,12 @@ void sde_dbg_ctrl(const char *name, ...);
  * @name:	name of base region
  * @base:	base pointer of region
  * @max_offset:	length of region
+ * @phys_addr:	physical address of region
  * @blk_id:	hw block id
  * Returns:	0 or -ERROR
  */
 int sde_dbg_reg_register_base(const char *name, void __iomem *base,
-		size_t max_offset, u64 blk_id);
+		size_t max_offset, unsigned long phys_addr, u64 blk_id);
 
 /**
  * sde_dbg_reg_register_cb - register a hw register callback for later

msm/sde_rsc.c

@@ -20,6 +20,7 @@
 
 #include <soc/qcom/rpmh.h>
 #include <drm/drm_irq.h>
+#include "msm_drv.h"
 #include "sde_rsc_priv.h"
 #include "sde_dbg.h"
 #include "sde_trace.h"
@@ -1626,9 +1627,9 @@ static int sde_rsc_bind(struct device *dev,
 	}
 
 	sde_dbg_reg_register_base(SDE_RSC_DRV_DBG_NAME, rsc->drv_io.base,
-				rsc->drv_io.len, SDE_DBG_RSC);
+			rsc->drv_io.len, msm_get_phys_addr(pdev, "drv"), SDE_DBG_RSC);
 	sde_dbg_reg_register_base(SDE_RSC_WRAPPER_DBG_NAME, rsc->wrapper_io.base,
-				rsc->wrapper_io.len, SDE_DBG_RSC);
+			rsc->wrapper_io.len, msm_get_phys_addr(pdev, "wrapper"), SDE_DBG_RSC);
 	return 0;
 }