android10/kernel/drivers/soc/qcom/llcc-amon.c

/* Copyright (c) 2016, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/sysfs.h>
#include <linux/kobject.h>
#include <linux/regmap.h>
#include <linux/mfd/syscon.h>
#include <linux/platform_device.h>

#define MODULE_NAME "LLCC AMON deadlock detector"
static bool qcom_llcc_amon_panic = IS_ENABLED(
			CONFIG_QCOM_LLCC_AMON_PANIC) ? true:false;
module_param(qcom_llcc_amon_panic, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(qcom_llcc_amon_panic,
		"Enables deadlock detection by AMON");

static int amon_interrupt_mode;
module_param(amon_interrupt_mode, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(amon_interrupt_mode,
		"Controls whether to use interrupt or poll mode");

enum channel_type {
	AMON_READ,
	AMON_WRITE,
	AMON_EVICT,
};

#define LLCC_AMON_FG_CNT_MASK			0x70
#define LLCC_AMON_CG_CNT_MASK			0x380
#define LLCC_AMON_FG_CNT_SHIFT			0x4
#define LLCC_AMON_CG_CNT_SHIFT			0x7
#define LLCC_COMMON_IRQ_AMON			0x8
#define LLCC_AMON_STATUS0_MASK			0x3ff
#define LLCC_AMON_CHAN_SHIFT			0x4
#define LLCC_AMON_CNTR_SATURATED_SOURCE_TYPE(x) (0x1 << x)
#define LLCC_AMON_CFG0_DLDM_SHIFT		0x2

/* AMON register offsets */
#define LLCC_AMON_START			0x3d000
#define LLCC_AMON_CFG0			0x3d000
#define LLCC_AMON_EVICT_REGS		0x3d020
#define LLCC_AMON_WRITE_REGS		0x3d060
#define LLCC_AMON_READ_REGS		0x3d100
#define LLCC_AMON_IRQ_STATUS		0x3d200
#define LLCC_AMON_IRQ_CLEAR		0x3d208
#define LLCC_AMON_IRQ_ENABLE		0x3d20c
#define LLCC_AMON_STATUS_0		0x3d210

/* AMON configuration register bits */
#define LLCC_AMON_CFG0_ENABLE	0x0 /* Enable AMON */
#define LLCC_AMON_CFG0_DLDM	0x2 /* AMON deadlock detection mode */
#define LLCC_AMON_CFG0_SCRM	0x3 /* Enable SCID based deadlock detection */

/* Number of entries maintained by AMON */
#define NR_READ_ENTRIES		40
#define NR_WRITE_ENTRIES	16
#define NR_EVICT_ENTRIES	8
#define AMON_IRQ_BIT		0x0
#define CHAN_OFF(x)		(x << 2)

/**
 * llcc_amon_data: Data structure containing AMON driver data
 *
 * @llcc_amon_regmap: map of AMON register block
 * @dev: LLCC activiy monitor device
 * @amon_irq: LLCC activity monitor irq number
 * @amon_fg_cnt: LLCC activity monitor fine grained counter overflow bit
 * @amon_work: LLCC activity monitor work item to poll and
 * dump AMON CSRs
 * @amon_wq: LLCC activity monitor workqueue to poll and
 * dump AMON CSRs
 * @amon_lock: lock to access and change AMON driver data
 *
 **/
struct llcc_amon_data {
	struct regmap *llcc_amon_regmap;
	struct device *dev;
	u32 amon_irq;
	u32 amon_fg_cnt;
	struct work_struct amon_work;
	struct workqueue_struct *amon_wq;
	struct mutex amon_lock;
};

static void amon_dump_channel_status(struct device *dev, u32 chnum, u32 type)
{
	u32 llcc_amon_csr;
	struct llcc_amon_data *amon_data = dev_get_drvdata(dev);

	switch (type) {
	case AMON_READ:
		regmap_read(amon_data->llcc_amon_regmap,
			(LLCC_AMON_READ_REGS + CHAN_OFF(chnum)),
			&llcc_amon_csr);
		dev_err(dev, "READ entry %u : %8x\n",
					chnum, llcc_amon_csr);
		break;
	case AMON_WRITE:
		regmap_read(amon_data->llcc_amon_regmap,
			(LLCC_AMON_WRITE_REGS + CHAN_OFF(chnum)),
			&llcc_amon_csr);
		dev_err(dev, "WRITE entry %u : %8x\n",
					chnum, llcc_amon_csr);
		break;
	case AMON_EVICT:
		regmap_read(amon_data->llcc_amon_regmap,
			(LLCC_AMON_EVICT_REGS + CHAN_OFF(chnum)),
			&llcc_amon_csr);
		dev_err(dev, "EVICT entry %u : %8x\n",
					chnum, llcc_amon_csr);
		break;
	}
}

static void amon_dump_read_channel_status(struct device *dev, u32 chnum)
{
	amon_dump_channel_status(dev, chnum, AMON_READ);
}

static void amon_dump_write_channel_status(struct device *dev, u32 chnum)
{
	amon_dump_channel_status(dev, chnum, AMON_WRITE);
}

static void amon_dump_evict_channel_status(struct device *dev, u32 chnum)
{
	amon_dump_channel_status(dev, chnum, AMON_EVICT);
}

static ssize_t amon_fg_count_store(struct device *dev,
			struct device_attribute *attr,
			const char *buf, size_t n)
{
	struct llcc_amon_data *amon_data;
	int ret;
	u32 count;

	amon_data = dev_get_drvdata(dev);
	if (!amon_data)
		return -ENODEV;

	mutex_lock(&amon_data->amon_lock);
	ret = kstrtouint(buf, 0, &count);
	if (ret) {
		dev_err(amon_data->dev, "invalid user input\n");
		mutex_unlock(&amon_data->amon_lock);
		return ret;
	}

	/* Set fine grained counter */
	regmap_update_bits(amon_data->llcc_amon_regmap, LLCC_AMON_CFG0,
		LLCC_AMON_FG_CNT_MASK, (count << LLCC_AMON_FG_CNT_SHIFT));
	mutex_unlock(&amon_data->amon_lock);
	return n;
}

static ssize_t amon_fg_count_show(struct device *dev,
			struct device_attribute *attr,
			char *buf)
{
	struct llcc_amon_data *amon_data;
	int ret;
	u32 count, llcc_amon_cfg0;

	amon_data = dev_get_drvdata(dev);
	if (!amon_data)
		return -ENODEV;

	mutex_lock(&amon_data->amon_lock);
	/* Get fine grained counter */
	regmap_read(amon_data->llcc_amon_regmap, LLCC_AMON_CFG0,
		&llcc_amon_cfg0);
	count = (llcc_amon_cfg0 & LLCC_AMON_FG_CNT_MASK)
					>> LLCC_AMON_FG_CNT_SHIFT;
	ret = snprintf(buf, PAGE_SIZE, "%u\n", count);
	mutex_unlock(&amon_data->amon_lock);
	return ret;
}

static ssize_t amon_deadlock_mode_store(struct device *dev,
			struct device_attribute *attr,
			const char *buf, size_t n)
{
	struct llcc_amon_data *amon_data;
	int ret;
	u32 mode;

	amon_data = dev_get_drvdata(dev);
	if (!amon_data)
		return -ENODEV;

	mutex_lock(&amon_data->amon_lock);
	ret = kstrtouint(buf, 0, &mode);
	if (ret) {
		dev_err(amon_data->dev, "invalid user input\n");
		mutex_unlock(&amon_data->amon_lock);
		return ret;
	}

	/* Set deadlock detection mode */
	regmap_update_bits(amon_data->llcc_amon_regmap, LLCC_AMON_CFG0,
		BIT(LLCC_AMON_CFG0_DLDM), mode);
	mutex_unlock(&amon_data->amon_lock);
	return n;
}

static ssize_t amon_deadlock_mode_show(struct device *dev,
			struct device_attribute *attr,
			char *buf)
{
	struct llcc_amon_data *amon_data;
	int ret;
	u32 val, llcc_amon_cfg0;

	amon_data = dev_get_drvdata(dev);
	if (!amon_data)
		return -ENODEV;

	mutex_lock(&amon_data->amon_lock);

	/* Get deadlock detection mode */
	regmap_read(amon_data->llcc_amon_regmap, LLCC_AMON_CFG0,
		&llcc_amon_cfg0);
	val = llcc_amon_cfg0 & BIT(LLCC_AMON_CFG0_DLDM);
	ret = snprintf(buf, PAGE_SIZE, "%d\n",
			val >> LLCC_AMON_CFG0_DLDM_SHIFT);

	mutex_unlock(&amon_data->amon_lock);
	return ret;
}


static DEVICE_ATTR(amon_fg_count, S_IRUGO | S_IWUSR,
				amon_fg_count_show, amon_fg_count_store);
static DEVICE_ATTR(amon_deadlock_mode, S_IRUGO | S_IWUSR,
			amon_deadlock_mode_show, amon_deadlock_mode_store);

static const struct device_attribute *llcc_amon_attrs[] = {
	&dev_attr_amon_fg_count,
	&dev_attr_amon_deadlock_mode,
	NULL,
};

static int amon_create_sysfs_files(struct device *dev,
			const struct device_attribute **attrs)
{
	int ret = 0, i;

	for (i = 0; attrs[i] != NULL; i++) {
		ret = device_create_file(dev, attrs[i]);
		if (ret) {
			dev_err(dev, "AMON: Couldn't create sysfs entry: %s!\n",
				attrs[i]->attr.name);
			break;
		}
	}
	return ret;
}

static int amon_remove_sysfs_files(struct device *dev,
			const struct device_attribute **attrs)
{
	int ret = 0, i;

	for (i = 0; attrs[i] != NULL; i++)
		device_remove_file(dev, attrs[i]);

	return ret;
}

static void enable_qcom_amon_interrupt(struct llcc_amon_data *amon_data)
{

	regmap_update_bits(amon_data->llcc_amon_regmap, LLCC_AMON_IRQ_ENABLE,
		BIT(AMON_IRQ_BIT), BIT(AMON_IRQ_BIT));
}

void disable_qcom_amon_interrupt(struct llcc_amon_data *amon_data)
{
	regmap_update_bits(amon_data->llcc_amon_regmap, LLCC_AMON_IRQ_ENABLE,
		AMON_IRQ_BIT, AMON_IRQ_BIT);
}

static void clear_qcom_amon_interrupt(struct llcc_amon_data *amon_data)
{
	regmap_update_bits(amon_data->llcc_amon_regmap, LLCC_AMON_IRQ_CLEAR,
		BIT(AMON_IRQ_BIT), BIT(AMON_IRQ_BIT));
}

static void amon_poll_work(struct work_struct *work)
{
	u32 llcc_amon_status0, llcc_amon_irq_status, chnum;
	struct llcc_amon_data *amon_data = container_of(work,
				struct llcc_amon_data, amon_work);

	/* Check for deadlock */
	regmap_read(amon_data->llcc_amon_regmap, LLCC_AMON_IRQ_STATUS,
		&llcc_amon_irq_status);
	if (!(llcc_amon_irq_status & BIT(AMON_IRQ_BIT)))
		/* No deadlock interrupt */
		return;

	regmap_read(amon_data->llcc_amon_regmap, LLCC_AMON_STATUS_0,
		&llcc_amon_status0);
	if (!llcc_amon_status0)
		return;

	chnum = (llcc_amon_status0 & LLCC_AMON_STATUS0_MASK) >>
				 LLCC_AMON_CHAN_SHIFT;
	if (llcc_amon_status0 &
		LLCC_AMON_CNTR_SATURATED_SOURCE_TYPE(AMON_READ)) {
		/* Read channel error */
		amon_dump_read_channel_status(amon_data->dev, chnum);
	} else if (llcc_amon_status0 &
		LLCC_AMON_CNTR_SATURATED_SOURCE_TYPE(AMON_WRITE)) {
		/* Write channel error */
		amon_dump_write_channel_status(amon_data->dev, chnum);
	} else if (llcc_amon_status0 &
		LLCC_AMON_CNTR_SATURATED_SOURCE_TYPE(AMON_EVICT)) {
		/* Evict channel error */
		amon_dump_evict_channel_status(amon_data->dev, chnum);
	}

	clear_qcom_amon_interrupt(amon_data);

	if (qcom_llcc_amon_panic)
		panic("AMON deadlock detected");
}

static irqreturn_t llcc_amon_irq_handler(int irq, void *dev_data)
{
	u32 llcc_amon_status0, llcc_amon_irq_status;
	int chnum;
	struct llcc_amon_data *amon_data = dev_data;

	regmap_read(amon_data->llcc_amon_regmap, LLCC_AMON_IRQ_STATUS,
		&llcc_amon_irq_status);
	if (!(llcc_amon_irq_status & BIT(AMON_IRQ_BIT)))
		/* No deadlock interrupt */
		return IRQ_NONE;

	regmap_read(amon_data->llcc_amon_regmap, LLCC_AMON_STATUS_0,
		&llcc_amon_status0);
	if (unlikely(llcc_amon_status0 == 0))
		return IRQ_NONE;

	/*
	 * Check type of interrupt and channel number.
	 * Call corresponding handler with channel number.
	 */

	chnum = (llcc_amon_status0 & LLCC_AMON_STATUS0_MASK) >>
			 LLCC_AMON_CHAN_SHIFT;
	if (llcc_amon_status0 &
		LLCC_AMON_CNTR_SATURATED_SOURCE_TYPE(AMON_READ)) {
		/* Read channel error */
		amon_dump_read_channel_status(amon_data->dev, chnum);
	} else if (llcc_amon_status0 &
		LLCC_AMON_CNTR_SATURATED_SOURCE_TYPE(AMON_WRITE)) {
		/* Write channel error */
		amon_dump_write_channel_status(amon_data->dev, chnum);
	} else if (llcc_amon_status0 &
		LLCC_AMON_CNTR_SATURATED_SOURCE_TYPE(AMON_EVICT)) {
		/* Evict channel error */
		amon_dump_evict_channel_status(amon_data->dev, chnum);
	}

	clear_qcom_amon_interrupt(amon_data);

	if (qcom_llcc_amon_panic)
		panic("AMON deadlock detected");

	return IRQ_HANDLED;
}


static int qcom_llcc_amon_dt_to_pdata(struct platform_device *pdev,
					struct llcc_amon_data *pdata)
{
	struct device_node *node = pdev->dev.of_node;

	pdata->dev = &pdev->dev;

	pdata->llcc_amon_regmap = syscon_node_to_regmap(
				pdata->dev->parent->of_node);
	if (IS_ERR(pdata->llcc_amon_regmap)) {
		dev_err(pdata->dev, "No regmap for syscon amon parent\n");
		return -ENOMEM;
	}

	pdata->amon_irq = platform_get_irq(pdev, 0);
	if (!pdata->amon_irq)
		return -ENODEV;

	of_property_read_u32(node, "qcom,fg-cnt",
				&pdata->amon_fg_cnt);
	return 0;
}

static int qcom_llcc_amon_probe(struct platform_device *pdev)
{
	int ret;
	struct llcc_amon_data *amon_data;
	u32 cnt;

	if (!pdev->dev.of_node)
		return -ENODEV;

	amon_data = devm_kzalloc(&pdev->dev, sizeof(struct llcc_amon_data),
				GFP_KERNEL);
	if (!amon_data)
		return -ENOMEM;

	ret = qcom_llcc_amon_dt_to_pdata(pdev, amon_data);
	if (ret) {
		dev_err(amon_data->dev, "failed to get amon data\n");
		return ret;
	}

	amon_data->dev = &pdev->dev;


	platform_set_drvdata(pdev, amon_data);

	/* Enable Activity Monitor */
	regmap_update_bits(amon_data->llcc_amon_regmap, LLCC_AMON_CFG0,
		BIT(LLCC_AMON_CFG0_ENABLE), 0x1);

	/* Enable Activity Monitor (AMON) as deadlock detector */
	regmap_update_bits(amon_data->llcc_amon_regmap, LLCC_AMON_CFG0,
		BIT(LLCC_AMON_CFG0_DLDM), BIT(LLCC_AMON_CFG0_DLDM));

	/* Set fine grained counter */
	cnt = amon_data->amon_fg_cnt << LLCC_AMON_FG_CNT_SHIFT;
	if (cnt)
		regmap_update_bits(amon_data->llcc_amon_regmap,
			LLCC_AMON_CFG0,	LLCC_AMON_FG_CNT_MASK, cnt);

	mutex_init(&amon_data->amon_lock);
	ret = amon_create_sysfs_files(&pdev->dev, llcc_amon_attrs);
	if (ret) {
		dev_err(amon_data->dev,
			"failed to create sysfs entries\n");
		platform_set_drvdata(pdev, NULL);
		return ret;
	}

	if (amon_interrupt_mode) { /* Interrupt mode */
		ret = devm_request_irq(amon_data->dev, amon_data->amon_irq,
				llcc_amon_irq_handler, IRQF_TRIGGER_RISING,
				"amon_deadlock", amon_data);
		if (ret) {
			dev_err(amon_data->dev,
				"failed to request amon deadlock irq\n");
			platform_set_drvdata(pdev, NULL);
			return ret;
		}
		enable_qcom_amon_interrupt(amon_data);
	} else { /* Polling mode */
		amon_data->amon_wq = create_singlethread_workqueue(
						"amon_deadlock_detector");
		if (!amon_data->amon_wq) {
			dev_err(amon_data->dev,
				"failed to create polling work queue\n");
			platform_set_drvdata(pdev, NULL);
			return -ENOMEM;
		}
		INIT_WORK(&amon_data->amon_work, amon_poll_work);
		queue_work(amon_data->amon_wq, &amon_data->amon_work);
	}

	return 0;
}

static int qcom_llcc_amon_remove(struct platform_device *pdev)
{
	struct llcc_amon_data *amon_data = platform_get_drvdata(pdev);

	disable_qcom_amon_interrupt(amon_data);
	clear_qcom_amon_interrupt(amon_data);
	/* Disable Activity Monitor (AMON) as deadlock detector */
	regmap_update_bits(amon_data->llcc_amon_regmap, LLCC_AMON_CFG0,
		BIT(LLCC_AMON_CFG0_DLDM), 0x0);
	/* Disable Activity Monitor */
	regmap_update_bits(amon_data->llcc_amon_regmap, LLCC_AMON_CFG0,
		BIT(LLCC_AMON_CFG0_ENABLE), 0x0);

	amon_remove_sysfs_files(&pdev->dev, llcc_amon_attrs);
	destroy_workqueue(amon_data->amon_wq);
	platform_set_drvdata(pdev, NULL);
	return 0;
}

static const struct of_device_id qcom_llcc_amon_match_table[] = {
	{ .compatible = "qcom,llcc-amon" },
	{},
};

static struct platform_driver qcom_llcc_amon_driver = {
	.probe = qcom_llcc_amon_probe,
	.remove = qcom_llcc_amon_remove,
	.driver = {
		.name = MODULE_NAME,
		.owner = THIS_MODULE,
		.of_match_table = qcom_llcc_amon_match_table,
	},
};

static int __init init_qcom_llcc_amon(void)
{
	return platform_driver_register(&qcom_llcc_amon_driver);
}
module_init(init_qcom_llcc_amon);

static void __exit exit_qcom_llcc_amon(void)
{
	return platform_driver_unregister(&qcom_llcc_amon_driver);
}
module_exit(exit_qcom_llcc_amon);

MODULE_DESCRIPTION("QTI LLCC Activity Monitor Driver");
MODULE_LICENSE("GPL v2");