/* Copyright (c) 2015, 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/module.h>
#include <linux/kernel.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/cpu_pm.h>
#include <linux/platform_device.h>
#include <soc/qcom/scm.h>

#define MODULE_NAME "gladiator_error_reporting"

/* SCM call service and command ID */
#define SCM_TZ_SVC_INFO			0x6
#define TZ_INFO_GET_SECURE_STATE	0x4

/* Secure State Check */
#define SEC_STATE_VALID(a) (a & (BIT(0) | BIT(2) | BIT(6)))

/* Register Offsets */
#define GLADIATOR_ID_COREID	0x0
#define GLADIATOR_ID_REVISIONID	0x4
#define GLADIATOR_FAULTEN	0x48
#define GLADIATOR_ERRVLD	0x4C
#define GLADIATOR_ERRCLR	0x50
#define GLADIATOR_ERRLOG0	0x54
#define GLADIATOR_ERRLOG1	0x58
#define GLADIATOR_ERRLOG2	0x5C
#define GLADIATOR_ERRLOG3	0x60
#define GLADIATOR_ERRLOG4	0x64
#define GLADIATOR_ERRLOG5	0x68
#define GLADIATOR_ERRLOG6	0x6C
#define GLADIATOR_ERRLOG7	0x70 /* Not used for error reporting */
#define GLADIATOR_ERRLOG8	0x74
#define OBSERVER_0_ID_COREID	0x1000
#define OBSERVER_0_FAULTEN	0x1008
#define OBSERVER_0_ERRVLD	0x100C
#define OBSERVER_0_ERRCLR	0x1010
#define OBSERVER_0_ERRLOG0	0x1014
#define OBSERVER_0_ERRLOG1	0x1018
#define OBSERVER_0_ERRLOG2	0x101C /* Not used for error reporting */
#define OBSERVER_0_ERRLOG3	0x1020
#define OBSERVER_0_ERRLOG4	0x1024
#define OBSERVER_0_ERRLOG5	0x1028
#define OBSERVER_0_ERRLOG6	0x102C /* Not used for error reporting */
#define OBSERVER_0_ERRLOG7	0x1030
#define OBSERVER_0_ERRLOG8	0x1034 /* Not used for error reporting */
#define OBSERVER_0_STALLEN	0x1038
#define OBSERVER_0_REVISIONID	0x1004

#define GLD_TRANS_OPCODE_MASK		0xE
#define GLD_TRANS_OPCODE_SHIFT		1
#define GLD_ERROR_TYPE_MASK		0x700
#define GLD_ERROR_TYPE_SHIFT		8
#define GLD_LEN1_MASK			0x7FF8000
#define GLD_LEN1_SHIFT			16
#define	GLD_TRANS_SOURCEID_MASK		0x7
#define	GLD_TRANS_SOURCEID_SHIFT	0
#define	GLD_TRANS_TARGETID_MASK		0x7
#define	GLD_TRANS_TARGETID_SHIFT	0
#define	GLD_ERRLOG_ERROR		0x7
#define OBS_TRANS_OPCODE_MASK		0x1E
#define OBS_TRANS_OPCODE_SHIFT		1
#define OBS_ERROR_TYPE_MASK		0x700
#define OBS_ERROR_TYPE_SHIFT		8
#define OBS_LEN1_MASK			0x7F0000
#define OBS_LEN1_SHIFT			16

struct msm_gladiator_data {
	void __iomem *gladiator_virt_base;
	int erp_irq;
	struct notifier_block pm_notifier_block;
};

static int enable_panic_on_error;
module_param(enable_panic_on_error, int, 0);

enum gld_trans_opcode {
	GLD_RD,
	GLD_RDX,
	GLD_RDL,
	GLD_RESERVED,
	GLD_WR,
	GLD_WRC,
	GLD_PRE,
};

enum obs_trans_opcode {
	OBS_RD,
	OBS_RDW,
	OBS_RDL,
	OBS_RDX,
	OBS_WR,
	OBS_WRW,
	OBS_WRC,
	OBS_RESERVED,
	OBS_PRE,
	OBS_URG,
};

enum obs_err_code {
	OBS_SLV,
	OBS_DEC,
	OBS_UNS,
	OBS_DISC,
	OBS_SEC,
	OBS_HIDE,
	OBS_TMO,
	OBS_RSV,
};

enum err_log {
	ERR_LOG0,
	ERR_LOG1,
	ERR_LOG2,
	ERR_LOG3,
	ERR_LOG4,
	ERR_LOG5,
	ERR_LOG6,
	ERR_LOG7,
	ERR_LOG8,
	STALLEN,
};

static void clear_gladiator_error(void __iomem *gladiator_virt_base)
{
	writel_relaxed(1, gladiator_virt_base + GLADIATOR_ERRCLR);
	writel_relaxed(1, gladiator_virt_base + OBSERVER_0_ERRCLR);
}

static inline void print_gld_transaction(unsigned int opc)
{
	switch (opc) {
	case GLD_RD:
		pr_alert("Transaction type: READ\n");
		break;
	case GLD_RDX:
		pr_alert("Transaction type: EXCLUSIVE READ\n");
		break;
	case GLD_RDL:
		pr_alert("Transaction type: LINKED READ\n");
		break;
	case GLD_WR:
		pr_alert("Transaction type: WRITE\n");
		break;
	case GLD_WRC:
		pr_alert("Transaction type: CONDITIONAL WRITE\n");
		break;
	case GLD_PRE:
		pr_alert("Transaction: Preamble packet of linked sequence\n");
		break;
	default:
		pr_alert("Transaction type: Unknown; value:%u\n", opc);
	}
}

static inline void print_gld_errtype(unsigned int errtype)
{
	if (errtype == 0)
		pr_alert("Error type: Snoop data transfer\n");
	else if (errtype == 1)
		pr_alert("Error type: DVM error\n");
	else
		pr_alert("Error type: Unknown; value:%u\n", errtype);
}

static void decode_gld_errlog0(u32 err_reg)
{
	unsigned int opc, errtype, len1;

	opc = (err_reg & GLD_TRANS_OPCODE_MASK) >> GLD_TRANS_OPCODE_SHIFT;
	errtype = (err_reg & GLD_ERROR_TYPE_MASK) >> GLD_ERROR_TYPE_SHIFT;
	len1 = (err_reg & GLD_LEN1_MASK) >> GLD_LEN1_SHIFT;

	print_gld_transaction(opc);
	print_gld_errtype(errtype);
	pr_alert("number of payload bytes: %d\n", len1 + 1);
}

static void decode_gld_errlog1(u32 err_reg)
{
	if ((err_reg & GLD_ERRLOG_ERROR) == GLD_ERRLOG_ERROR)
		pr_alert("Transaction issued on IO target generic interface\n");
	else
		pr_alert("Transaction source ID: %d\n",
			(err_reg & GLD_TRANS_SOURCEID_MASK)
				>> GLD_TRANS_SOURCEID_SHIFT);
}

static void decode_gld_errlog2(u32 err_reg)
{
	if ((err_reg & GLD_ERRLOG_ERROR) == GLD_ERRLOG_ERROR)
		pr_alert("Error response coming from: external DVM network\n");
	else
		pr_alert("Error response coming from: Target ID: %d\n",
			(err_reg & GLD_TRANS_TARGETID_MASK)
				>> GLD_TRANS_TARGETID_SHIFT);
}

static void decode_gld_errlog(u32 err_reg, unsigned int err_log)
{
	switch (err_log) {
	case ERR_LOG0:
		decode_gld_errlog0(err_reg);
		break;
	case ERR_LOG1:
		decode_gld_errlog1(err_reg);
		break;
	case ERR_LOG2:
		decode_gld_errlog2(err_reg);
		break;
	case ERR_LOG3:
		pr_alert("Lower 32-bits of error address: %08x\n", err_reg);
		break;
	case ERR_LOG4:
		pr_alert("Upper 32-bits of error address: %08x\n", err_reg);
		break;
	case ERR_LOG5:
		pr_alert("Lower 32-bits of user: %08x\n", err_reg);
		break;
	case ERR_LOG6:
		pr_alert("Mid 32-bits(63-32) of user: %08x\n", err_reg);
		break;
	case ERR_LOG7:
		break;
	case ERR_LOG8:
		pr_alert("Upper 32-bits(95-64) of user: %08x\n", err_reg);
		break;
	default:
		pr_alert("Invalid error register; reg num:%u\n", err_log);
	}
}

static inline void print_obs_transaction(unsigned int opc)
{
	switch (opc) {
	case OBS_RD:
		pr_alert("Transaction type: READ\n");
		break;
	case OBS_RDW:
		pr_alert("Transaction type: WRAPPED READ\n");
		break;
	case OBS_RDL:
		pr_alert("Transaction type: LINKED READ\n");
		break;
	case OBS_RDX:
		pr_alert("Transaction type: EXCLUSIVE READ\n");
		break;
	case OBS_WR:
		pr_alert("Transaction type: WRITE\n");
		break;
	case OBS_WRW:
		pr_alert("Transaction type: WRAPPED WRITE\n");
		break;
	case OBS_WRC:
		pr_alert("Transaction type: CONDITIONAL WRITE\n");
		break;
	case OBS_PRE:
		pr_alert("Transaction: Preamble packet of linked sequence\n");
		break;
	case OBS_URG:
		pr_alert("Transaction type: Urgency Packet\n");
		break;
	default:
		pr_alert("Transaction type: Unknown; value:%u\n", opc);
	}
}

static inline void print_obs_errcode(unsigned int errcode)
{
	switch (errcode) {
	case OBS_SLV:
		pr_alert("Error code: Target error detected by slave\n");
		pr_alert("Source: Target\n");
		break;
	case OBS_DEC:
		pr_alert("Error code: Address decode error\n");
		pr_alert("Source: Initiator NIU\n");
		break;
	case OBS_UNS:
		pr_alert("Error code: Unsupported request\n");
		pr_alert("Source: Target NIU\n");
		break;
	case OBS_DISC:
		pr_alert("Error code: Disconnected target or domain\n");
		pr_alert("Source: Power Disconnect\n");
		break;
	case OBS_SEC:
		pr_alert("Error code: Security violation\n");
		pr_alert("Source: Initiator NIU or Firewall\n");
		break;
	case OBS_HIDE:
		pr_alert("Error :Hidden security violation, reported as OK\n");
		pr_alert("Source: Firewall\n");
		break;
	case OBS_TMO:
		pr_alert("Error code: Time-out\n");
		pr_alert("Source: Target NIU\n");
		break;
	default:
		pr_alert("Error code: Unknown; code:%u\n", errcode);
	}
}

static void decode_obs_errlog0(u32 err_reg)
{
	unsigned int opc, errcode, len1;

	opc = (err_reg & OBS_TRANS_OPCODE_MASK) >> OBS_TRANS_OPCODE_SHIFT;
	errcode = (err_reg & OBS_ERROR_TYPE_MASK) >> OBS_ERROR_TYPE_SHIFT;
	len1 = (err_reg & OBS_LEN1_MASK) >> OBS_LEN1_SHIFT;

	print_obs_transaction(opc);
	print_obs_errcode(errcode);
	pr_alert("number of payload bytes: %d\n", len1 + 1);
}

static void decode_obs_errlog(u32 err_reg, unsigned int err_log)
{
	switch (err_log) {
	case ERR_LOG0:
		decode_obs_errlog0(err_reg);
		break;
	case ERR_LOG1:
		pr_alert("RouteId of the error: %08x\n", err_reg);
		break;
	case ERR_LOG2:
		/* reserved error log register */
		break;
	case ERR_LOG3:
		pr_alert("Lower 32-bits of error address: %08x\n", err_reg);
		break;
	case ERR_LOG4:
		pr_alert("Upper 12-bits of error address: %08x\n", err_reg);
		break;
	case ERR_LOG5:
		pr_alert("Lower 13-bits of user: %08x\n", err_reg);
		break;
	case ERR_LOG6:
		/* reserved error log register */
		break;
	case ERR_LOG7:
		pr_alert("Security filed of the logged error: %08x\n", err_reg);
		break;
	case ERR_LOG8:
		/* reserved error log register */
		break;
	case STALLEN:
		pr_alert("stall mode of the error logger: %08x\n",
							err_reg & 0x1);
		break;
	default:
		pr_alert("Invalid error register; reg num:%u\n", err_log);
	}
}

static u32 get_gld_offset(unsigned int err_log)
{
	u32 offset = 0;

	switch (err_log) {
	case ERR_LOG0:
		offset = GLADIATOR_ERRLOG0;
		break;
	case ERR_LOG1:
		offset = GLADIATOR_ERRLOG1;
		break;
	case ERR_LOG2:
		offset = GLADIATOR_ERRLOG2;
		break;
	case ERR_LOG3:
		offset = GLADIATOR_ERRLOG3;
		break;
	case ERR_LOG4:
		offset = GLADIATOR_ERRLOG4;
		break;
	case ERR_LOG5:
		offset = GLADIATOR_ERRLOG5;
		break;
	case ERR_LOG6:
		offset = GLADIATOR_ERRLOG6;
		break;
	case ERR_LOG7:
		offset = GLADIATOR_ERRLOG7;
		break;
	case ERR_LOG8:
		offset = GLADIATOR_ERRLOG8;
		break;
	default:
		pr_alert("Invalid gladiator error register; reg num:%u\n",
						err_log);
	}
	return offset;
}

static u32 get_obs_offset(unsigned int err_log)
{
	u32 offset = 0;

	switch (err_log) {
	case ERR_LOG0:
		offset = OBSERVER_0_ERRLOG0;
		break;
	case ERR_LOG1:
		offset = OBSERVER_0_ERRLOG1;
		break;
	case ERR_LOG2:
		offset = OBSERVER_0_ERRLOG2;
		break;
	case ERR_LOG3:
		offset = OBSERVER_0_ERRLOG3;
		break;
	case ERR_LOG4:
		offset = OBSERVER_0_ERRLOG4;
		break;
	case ERR_LOG5:
		offset = OBSERVER_0_ERRLOG5;
		break;
	case ERR_LOG6:
		offset = OBSERVER_0_ERRLOG6;
		break;
	case ERR_LOG7:
		offset = OBSERVER_0_ERRLOG7;
		break;
	case ERR_LOG8:
		offset = OBSERVER_0_ERRLOG8;
		break;
	case STALLEN:
		offset = OBSERVER_0_STALLEN;
		break;
	default:
		pr_alert("Invalid observer error register; reg num:%u\n",
							err_log);
	}
	return offset;
}

static irqreturn_t msm_gladiator_isr(int irq, void *dev_id)
{
	u32 err_reg;
	unsigned int err_log;
	struct msm_gladiator_data *msm_gld_data = dev_id;
	/* Check validity */
	bool gld_err_valid = readl_relaxed(msm_gld_data->gladiator_virt_base +
						GLADIATOR_ERRVLD);
	bool obsrv_err_valid = readl_relaxed(msm_gld_data->gladiator_virt_base +
						OBSERVER_0_ERRVLD);
	if (!gld_err_valid && !obsrv_err_valid) {
		pr_err("%s Invalid Gladiator error reported, clear it\n",
							__func__);
		/* Clear IRQ */
		clear_gladiator_error(msm_gld_data->gladiator_virt_base);
		return IRQ_HANDLED;
	}
	pr_alert("GLADIATOR ERROR DETECTED\n");
	pr_alert("GLADIATOR error log register data:\n");
	for (err_log = ERR_LOG0; err_log <= ERR_LOG8; err_log++) {
		/* skip log register 7 as its reserved */
		if (err_log == ERR_LOG7)
			continue;
		err_reg = readl_relaxed(msm_gld_data->gladiator_virt_base +
					get_gld_offset(err_log));
		decode_gld_errlog(err_reg, err_log);
	}
	pr_alert("Observor error log register data:\n");
	for (err_log = ERR_LOG0; err_log <= STALLEN; err_log++)	{
		/* skip log register 2, 6 and 8 as they are reserved */
		if ((err_log == ERR_LOG2) || (err_log == ERR_LOG6)
					|| (err_log == ERR_LOG8))
			continue;
		err_reg = readl_relaxed(msm_gld_data->gladiator_virt_base +
					get_obs_offset(err_log));
		decode_obs_errlog(err_reg, err_log);
	}
	/* Clear IRQ */
	clear_gladiator_error(msm_gld_data->gladiator_virt_base);
	if (enable_panic_on_error)
		BUG_ON(1);
	else
		WARN(1, "Gladiator Cache Interconnect Error Detected\n");

	return IRQ_HANDLED;
}

static const struct of_device_id gladiator_erp_match_table[] = {
	{ .compatible = "qcom,msm-gladiator" },
	{},
};

static int parse_dt_node(struct platform_device *pdev,
			struct msm_gladiator_data *msm_gld_data)
{
	int ret = 0;
	struct resource *res;

	res = platform_get_resource_byname(pdev,
			IORESOURCE_MEM, "gladiator_base");
	if (!res)
		return -ENODEV;
	if (!devm_request_mem_region(&pdev->dev, res->start,
					       resource_size(res),
					       "msm-gladiator-erp")) {

		dev_err(&pdev->dev, "%s cannot reserve gladiator erp region\n",
								__func__);
		return -ENXIO;
	}
	msm_gld_data->gladiator_virt_base  = devm_ioremap(&pdev->dev,
					res->start, resource_size(res));
	if (!msm_gld_data->gladiator_virt_base) {
		dev_err(&pdev->dev, "%s cannot map gladiator register space\n",
				__func__);
		return -ENXIO;
	}
	msm_gld_data->erp_irq = platform_get_irq(pdev, 0);
	if (!msm_gld_data->erp_irq)
		return -ENODEV;

	/* clear existing errors before enabling the interrupt */
	clear_gladiator_error(msm_gld_data->gladiator_virt_base);
	ret = devm_request_irq(&pdev->dev, msm_gld_data->erp_irq,
			msm_gladiator_isr, IRQF_TRIGGER_HIGH,
					"gladiator-error", msm_gld_data);
	if (ret)
		dev_err(&pdev->dev, "Failed to register irq handler\n");

	return ret;
}

static inline void gladiator_irq_init(void __iomem *gladiator_virt_base)
{
	writel_relaxed(1, gladiator_virt_base + GLADIATOR_FAULTEN);
	writel_relaxed(1, gladiator_virt_base + OBSERVER_0_FAULTEN);
}

#define CCI_LEVEL 2
static int gladiator_erp_pm_callback(struct notifier_block *nb,
		unsigned long val, void *data)
{
	unsigned int level = (unsigned long) data;
	struct msm_gladiator_data *msm_gld_data = container_of(nb,
			struct msm_gladiator_data, pm_notifier_block);

	if (level != CCI_LEVEL)
		return NOTIFY_DONE;

	switch (val) {
	case CPU_CLUSTER_PM_EXIT:
			 gladiator_irq_init(msm_gld_data->gladiator_virt_base);
			 break;
	default:
			 return NOTIFY_DONE;
	}

	 return NOTIFY_OK;
}

static int gladiator_erp_probe(struct platform_device *pdev)
{
	int ret;
	struct msm_gladiator_data *msm_gld_data;

	msm_gld_data = devm_kzalloc(&pdev->dev,
			sizeof(struct msm_gladiator_data), GFP_KERNEL);
	if (!msm_gld_data) {
		ret = -ENOMEM;
		goto bail;
	}

	ret = parse_dt_node(pdev, msm_gld_data);
	if (ret)
		goto free_data;
	msm_gld_data->pm_notifier_block.notifier_call =
					gladiator_erp_pm_callback;
	gladiator_irq_init(msm_gld_data->gladiator_virt_base);
	platform_set_drvdata(pdev, msm_gld_data);
	cpu_pm_register_notifier(&msm_gld_data->pm_notifier_block);
#ifdef CONFIG_PANIC_ON_GLADIATOR_ERROR
	enable_panic_on_error = 1;
#endif
	dev_info(&pdev->dev, "MSM Gladiator Error Reporting Initialized\n");
	return 0;

free_data:
	devm_kfree(&pdev->dev, msm_gld_data);
bail:
	dev_err(&pdev->dev, "Probe failed bailing out\n");
	return ret;
}

static int scm_is_gladiator_erp_available(void)
{
	int ret;
	struct scm_desc desc = {0};

	desc.args[0] = 0;
	desc.arginfo = 0;
	ret = scm_call2(SCM_SIP_FNID(SCM_TZ_SVC_INFO,
				TZ_INFO_GET_SECURE_STATE),
				&desc);
	if (ret) {
		pr_err("gladiator_error_reporting: SCM call failed\n");
		return -ENODEV;
	}

	if (SEC_STATE_VALID(desc.ret[0]))
		return 0;
	else
		return -ENODEV;
}

static struct platform_driver gladiator_erp_driver = {
	.probe = gladiator_erp_probe,
	.driver = {
		.name = MODULE_NAME,
		.owner = THIS_MODULE,
		.of_match_table = gladiator_erp_match_table,
	},
};

static int init_gladiator_erp(void)
{
	int ret;

	ret = scm_is_gladiator_erp_available();
	if (ret) {
		pr_info("Gladiator Error Reporting not available\n");
		return -ENODEV;
	}

	return platform_driver_register(&gladiator_erp_driver);
}

subsys_initcall(init_gladiator_erp);
MODULE_DESCRIPTION("Gladiator Error Reporting");
MODULE_LICENSE("GPL v2");