Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8aad5e04 authored by Tingwei Zhang's avatar Tingwei Zhang
Browse files

soc: qcom: Add snapshot of the memory dump v2 driver 



Add memory dump v2 driver from msm-4.19
commit 034b7f3bfb2c ("msm: cvp: Fix page fault when open 16 cvp sessions").
Remove dmac_flush_range since it's deprecated.

Change-Id: Ibcc42c0d737abbb304a222ac51cfdd94019af534
Signed-off-by: default avatarTingwei Zhang <tingwei@codeaurora.org>
parent 96179058

drivers/soc/qcom/Kconfig

+8 −0
Original line number Diff line number Diff line
@@ -269,6 +269,14 @@ config QCOM_SMD_RPM 
	  Say M here if you want to include support for the Qualcomm RPM as a

	  module. This will build a module called "qcom-smd-rpm".



config QCOM_MEMORY_DUMP_V2

	bool "QCOM Memory Dump V2 Support"

	help

	  This enables memory dump feature. It allows various client

	  subsystems to register respective dump regions. At the time

	  of deadlocks or cpu hangs these dump regions are captured to

	  give a snapshot of the system at the time of the crash.



config QCOM_SMEM_STATE

	bool

drivers/soc/qcom/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ obj-$(CONFIG_QCOM_IPCC) += qcom_ipcc.o 
obj-$(CONFIG_QCOM_APR) += apr.o

obj-$(CONFIG_QCOM_LLCC) += llcc-slice.o

obj-$(CONFIG_QCOM_LAHAINA_LLCC) += llcc-lahaina.o

obj-$(CONFIG_QCOM_MEMORY_DUMP_V2) += memory_dump_v2.o

obj-$(CONFIG_QCOM_SDM845_LLCC) += llcc-sdm845.o

obj-$(CONFIG_QCOM_RPMHPD) += rpmhpd.o

obj-$(CONFIG_QCOM_RPMPD) += rpmpd.o

drivers/soc/qcom/memory_dump_v2.c

0 → 100644
+331 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2014-2017, 2019, The Linux Foundation. All rights reserved.

 */



#include <linux/slab.h>

#include <linux/io.h>

#include <linux/init.h>

#include <linux/export.h>

#include <linux/err.h>

#include <linux/of.h>

#include <linux/of_address.h>

#include <soc/qcom/minidump.h>

#include <soc/qcom/memory_dump.h>

#include <soc/qcom/scm.h>

#include <linux/of_device.h>

#include <linux/dma-mapping.h>

#include <linux/module.h>



#define MSM_DUMP_TABLE_VERSION		MSM_DUMP_MAKE_VERSION(2, 0)



#define SCM_CMD_DEBUG_LAR_UNLOCK	0x4



struct msm_dump_table {

	uint32_t version;

	uint32_t num_entries;

	struct msm_dump_entry entries[MAX_NUM_ENTRIES];

};



struct msm_memory_dump {

	uint64_t table_phys;

	struct msm_dump_table *table;

};



static struct msm_memory_dump memdump;



uint32_t msm_dump_table_version(void)

{

	return MSM_DUMP_TABLE_VERSION;

}

EXPORT_SYMBOL(msm_dump_table_version);



static int msm_dump_table_register(struct msm_dump_entry *entry)

{

	struct msm_dump_entry *e;

	struct msm_dump_table *table = memdump.table;



	if (!table || table->num_entries >= MAX_NUM_ENTRIES)

		return -EINVAL;



	e = &table->entries[table->num_entries];

	e->id = entry->id;

	e->type = MSM_DUMP_TYPE_TABLE;

	e->addr = entry->addr;

	table->num_entries++;



	return 0;

}



static struct msm_dump_table *msm_dump_get_table(enum msm_dump_table_ids id)

{

	struct msm_dump_table *table = memdump.table;

	int i;



	if (!table) {

		pr_err("mem dump base table does not exist\n");

		return ERR_PTR(-EINVAL);

	}



	for (i = 0; i < MAX_NUM_ENTRIES; i++) {

		if (table->entries[i].id == id)

			break;

	}

	if (i == MAX_NUM_ENTRIES || !table->entries[i].addr) {

		pr_err("mem dump base table entry %d invalid\n", id);

		return ERR_PTR(-EINVAL);

	}



	/* Get the apps table pointer */

	table = phys_to_virt(table->entries[i].addr);



	return table;

}



static int msm_dump_data_add_minidump(struct msm_dump_entry *entry)

{

	struct msm_dump_data *data;

	struct md_region md_entry;



	data = (struct msm_dump_data *)(phys_to_virt(entry->addr));



	if (!data->addr || !data->len)

		return -EINVAL;



	if (!strcmp(data->name, "")) {

		pr_debug("Entry name is NULL, Use ID %d for minidump\n",

			entry->id);

		snprintf(md_entry.name, sizeof(md_entry.name), "KMDT0x%X",

			entry->id);

	} else {

		strlcpy(md_entry.name, data->name, sizeof(md_entry.name));

	}



	md_entry.phys_addr = data->addr;

	md_entry.virt_addr = (uintptr_t)phys_to_virt(data->addr);

	md_entry.size = data->len;

	md_entry.id = entry->id;



	return msm_minidump_add_region(&md_entry);

}



static int register_dump_table_entry(enum msm_dump_table_ids id,

					struct msm_dump_entry *entry)

{

	struct msm_dump_entry *e;

	struct msm_dump_table *table;



	table = msm_dump_get_table(id);

	if (IS_ERR(table))

		return PTR_ERR(table);



	if (!table || table->num_entries >= MAX_NUM_ENTRIES)

		return -EINVAL;



	e = &table->entries[table->num_entries];

	e->id = entry->id;

	e->type = MSM_DUMP_TYPE_DATA;

	e->addr = entry->addr;

	table->num_entries++;



	return 0;

}



/**

 * msm_dump_data_register - register to dump data and minidump framework

 * @id: ID of the dump table.

 * @entry: dump entry to be registered

 * This api will register the entry passed to dump table and minidump table

 */

int msm_dump_data_register(enum msm_dump_table_ids id,

			   struct msm_dump_entry *entry)

{

	int ret;



	ret = register_dump_table_entry(id, entry);

	if (!ret)

		if (msm_dump_data_add_minidump(entry))

			pr_err("Failed to add entry in Minidump table\n");



	return ret;

}

EXPORT_SYMBOL(msm_dump_data_register);



/**

 * msm_dump_data_register_nominidump - register to dump data framework

 * @id: ID of the dump table.

 * @entry: dump entry to be registered

 * This api will register the entry passed to dump table only

 */

int msm_dump_data_register_nominidump(enum msm_dump_table_ids id,

			   struct msm_dump_entry *entry)

{

	return register_dump_table_entry(id, entry);

}

EXPORT_SYMBOL(msm_dump_data_register_nominidump);



static int __init init_memory_dump(void)

{

	struct msm_dump_table *table;

	struct msm_dump_entry entry;

	struct device_node *np;

	void __iomem *imem_base;

	int ret;



	np = of_find_compatible_node(NULL, NULL,

				     "qcom,msm-imem-mem_dump_table");

	if (!np) {

		pr_err("mem dump base table DT node does not exist\n");

		return -ENODEV;

	}



	imem_base = of_iomap(np, 0);

	if (!imem_base) {

		pr_err("mem dump base table imem offset mapping failed\n");

		return -ENOMEM;

	}



	memdump.table = kzalloc(sizeof(struct msm_dump_table), GFP_KERNEL);

	if (!memdump.table) {

		ret = -ENOMEM;

		goto err0;

	}

	memdump.table->version = MSM_DUMP_TABLE_VERSION;

	memdump.table_phys = virt_to_phys(memdump.table);

	memcpy_toio(imem_base, &memdump.table_phys, sizeof(memdump.table_phys));

	/* Ensure write to imem_base is complete before unmapping */

	mb();

	pr_info("MSM Memory Dump base table set up\n");



	iounmap(imem_base);



	table = kzalloc(sizeof(struct msm_dump_table), GFP_KERNEL);

	if (!table) {

		ret = -ENOMEM;

		goto err1;

	}

	table->version = MSM_DUMP_TABLE_VERSION;



	entry.id = MSM_DUMP_TABLE_APPS;

	entry.addr = virt_to_phys(table);

	ret = msm_dump_table_register(&entry);

	if (ret) {

		pr_info("mem dump apps data table register failed\n");

		goto err2;

	}

	pr_info("MSM Memory Dump apps data table set up\n");



	return 0;

err2:

	kfree(table);

err1:

	kfree(memdump.table);

	return ret;

err0:

	iounmap(imem_base);

	return ret;

}

early_initcall(init_memory_dump);



#ifdef CONFIG_MSM_DEBUG_LAR_UNLOCK

static int __init init_debug_lar_unlock(void)

{

	int ret;

	uint32_t argument = 0;

	struct scm_desc desc = {0};



	if (!is_scm_armv8())

		ret = scm_call(SCM_SVC_TZ, SCM_CMD_DEBUG_LAR_UNLOCK, &argument,

			       sizeof(argument), NULL, 0);

	else

		ret = scm_call2(SCM_SIP_FNID(SCM_SVC_TZ,

				SCM_CMD_DEBUG_LAR_UNLOCK), &desc);

	if (ret)

		pr_err("Core Debug Lock unlock failed, ret: %d\n", ret);

	else

		pr_info("Core Debug Lock unlocked\n");



	return ret;

}

early_initcall(init_debug_lar_unlock);

#endif



static int mem_dump_probe(struct platform_device *pdev)

{

	struct device_node *child_node;

	const struct device_node *node = pdev->dev.of_node;

	static dma_addr_t dump_addr;

	static void *dump_vaddr;

	struct msm_dump_data *dump_data;

	struct msm_dump_entry dump_entry;

	int ret;

	u32 size, id;



	for_each_available_child_of_node(node, child_node) {

		ret = of_property_read_u32(child_node, "qcom,dump-size", &size);

		if (ret) {

			dev_err(&pdev->dev, "Unable to find size for %s\n",

					child_node->name);

			continue;

		}



		ret = of_property_read_u32(child_node, "qcom,dump-id", &id);

		if (ret) {

			dev_err(&pdev->dev, "Unable to find id for %s\n",

					child_node->name);

			continue;

		}



		dump_vaddr = dma_alloc_coherent(&pdev->dev, size,

						&dump_addr, GFP_KERNEL);



		if (!dump_vaddr) {

			dev_err(&pdev->dev, "Couldn't get memory for dumping\n");

			continue;

		}



		dump_data = devm_kzalloc(&pdev->dev,

				sizeof(struct msm_dump_data), GFP_KERNEL);

		if (!dump_data) {

			dma_free_coherent(&pdev->dev, size, dump_vaddr,

					dump_addr);

			continue;

		}



		dump_data->addr = dump_addr;

		dump_data->len = size;

		dump_entry.id = id;

		strlcpy(dump_data->name, child_node->name,

					sizeof(dump_data->name));

		dump_entry.addr = virt_to_phys(dump_data);

		ret = msm_dump_data_register(MSM_DUMP_TABLE_APPS, &dump_entry);

		if (ret) {

			dev_err(&pdev->dev, "Data dump setup failed, id = %d\n",

				id);

			dma_free_coherent(&pdev->dev, size, dump_vaddr,

					dump_addr);

			devm_kfree(&pdev->dev, dump_data);

		}

	}

	return 0;

}



static const struct of_device_id mem_dump_match_table[] = {

	{.compatible = "qcom,mem-dump",},

	{}

};



static struct platform_driver mem_dump_driver = {

	.probe = mem_dump_probe,

	.driver = {

		.name = "msm_mem_dump",

		.of_match_table = mem_dump_match_table,

	},

};



static int __init mem_dump_init(void)

{

	return platform_driver_register(&mem_dump_driver);

}



pure_initcall(mem_dump_init);

include/soc/qcom/memory_dump.h

0 → 100644
+134 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-only */

/*

 * Copyright (c) 2012, 2014-2017, 2019, The Linux Foundation. All rights reserved.

 */



#ifndef __MSM_MEMORY_DUMP_H

#define __MSM_MEMORY_DUMP_H



#include <linux/types.h>



enum dump_client_type {

	MSM_CPU_CTXT = 0,

	MSM_L1_CACHE,

	MSM_L2_CACHE,

	MSM_OCMEM,

	MSM_TMC_ETFETB,

	MSM_ETM0_REG,

	MSM_ETM1_REG,

	MSM_ETM2_REG,

	MSM_ETM3_REG,

	MSM_TMC0_REG, /* TMC_ETR */

	MSM_TMC1_REG, /* TMC_ETF */

	MSM_LOG_BUF,

	MSM_LOG_BUF_FIRST_IDX,

	MAX_NUM_CLIENTS,

};



struct msm_client_dump {

	enum dump_client_type id;

	unsigned long start_addr;

	unsigned long end_addr;

};



#ifdef CONFIG_QCOM_MEMORY_DUMP

extern int msm_dump_tbl_register(struct msm_client_dump *client_entry);

#else

static inline int msm_dump_tbl_register(struct msm_client_dump *entry)

{

	return -EIO;

}

#endif





#if defined(CONFIG_QCOM_MEMORY_DUMP) || defined(CONFIG_QCOM_MEMORY_DUMP_V2)

extern uint32_t msm_dump_table_version(void);

#else

static inline uint32_t msm_dump_table_version(void)

{

	return 0;

}

#endif



#define MSM_DUMP_MAKE_VERSION(ma, mi)	((ma << 20) | mi)

#define MSM_DUMP_MAJOR(val)		(val >> 20)

#define MSM_DUMP_MINOR(val)		(val & 0xFFFFF)





#define MAX_NUM_ENTRIES		0x150



enum msm_dump_data_ids {

	MSM_DUMP_DATA_CPU_CTX = 0x00,

	MSM_DUMP_DATA_L1_INST_CACHE = 0x60,

	MSM_DUMP_DATA_L1_DATA_CACHE = 0x80,

	MSM_DUMP_DATA_ETM_REG = 0xA0,

	MSM_DUMP_DATA_L2_CACHE = 0xC0,

	MSM_DUMP_DATA_L3_CACHE = 0xD0,

	MSM_DUMP_DATA_OCMEM = 0xE0,

	MSM_DUMP_DATA_CNSS_WLAN = 0xE1,

	MSM_DUMP_DATA_WIGIG = 0xE2,

	MSM_DUMP_DATA_PMIC = 0xE4,

	MSM_DUMP_DATA_DBGUI_REG = 0xE5,

	MSM_DUMP_DATA_DCC_REG = 0xE6,

	MSM_DUMP_DATA_DCC_SRAM = 0xE7,

	MSM_DUMP_DATA_MISC = 0xE8,

	MSM_DUMP_DATA_VSENSE = 0xE9,

	MSM_DUMP_DATA_RPM = 0xEA,

	MSM_DUMP_DATA_SCANDUMP = 0xEB,

	MSM_DUMP_DATA_RPMH = 0xEC,

	MSM_DUMP_DATA_TMC_ETF = 0xF0,

	MSM_DUMP_DATA_TMC_ETF_SWAO = 0xF1,

	MSM_DUMP_DATA_TMC_REG = 0x100,

	MSM_DUMP_DATA_TMC_ETF_SWAO_REG = 0x102,

	MSM_DUMP_DATA_LOG_BUF = 0x110,

	MSM_DUMP_DATA_LOG_BUF_FIRST_IDX = 0x111,

	MSM_DUMP_DATA_SCANDUMP_PER_CPU = 0x130,

	MSM_DUMP_DATA_LLCC_PER_INSTANCE = 0x140,

	MSM_DUMP_DATA_MAX = MAX_NUM_ENTRIES,

};



enum msm_dump_table_ids {

	MSM_DUMP_TABLE_APPS,

	MSM_DUMP_TABLE_MAX = MAX_NUM_ENTRIES,

};



enum msm_dump_type {

	MSM_DUMP_TYPE_DATA,

	MSM_DUMP_TYPE_TABLE,

};



struct msm_dump_data {

	uint32_t version;

	uint32_t magic;

	char name[32];

	uint64_t addr;

	uint64_t len;

	uint32_t reserved;

};



struct msm_dump_entry {

	uint32_t id;

	char name[32];

	uint32_t type;

	uint64_t addr;

};



#ifdef CONFIG_QCOM_MEMORY_DUMP_V2

extern int msm_dump_data_register(enum msm_dump_table_ids id,

				  struct msm_dump_entry *entry);

extern int msm_dump_data_register_nominidump(enum msm_dump_table_ids id,

				  struct msm_dump_entry *entry);

#else

static inline int msm_dump_data_register(enum msm_dump_table_ids id,

					 struct msm_dump_entry *entry)

{

	return -EINVAL;

}

static inline int msm_dump_data_register_nominidump(enum msm_dump_table_ids id,

					 struct msm_dump_entry *entry)

{

	return -EINVAL;

}

#endif



#endif