From 33f308b99921c02c9e97cb98de644cab58b6f5ad Mon Sep 17 00:00:00 2001 From: Abhimanyu Kapur Date: Fri, 13 Feb 2015 16:42:38 -0800 Subject: [PATCH] soc: qcom: Add support for gladiator error reporting Add support for gladiator cache interconnect error detection and reporting. The Gladiator is the cache coherent interconnect in between two or more CPU clusters. This driver helps detect the errors related to snoop data transfer and Distributed Virtual Memory(DVM) on READ/WRITE transactions. Change-Id: Ic1aa2066df239672a8ed3d99a63318ed32a11af2 Signed-off-by: Abhimanyu Kapur Signed-off-by: Srinivas Ramana --- .../bindings/cache/msm_gladiator_erp.txt | 16 + drivers/soc/qcom/Kconfig | 9 + drivers/soc/qcom/Makefile | 1 + drivers/soc/qcom/gladiator_erp.c | 648 +++++++++++++++++++++ 4 files changed, 674 insertions(+) create mode 100644 Documentation/devicetree/bindings/cache/msm_gladiator_erp.txt create mode 100644 drivers/soc/qcom/gladiator_erp.c diff --git a/Documentation/devicetree/bindings/cache/msm_gladiator_erp.txt b/Documentation/devicetree/bindings/cache/msm_gladiator_erp.txt new file mode 100644 index 000000000000..5d022586e021 --- /dev/null +++ b/Documentation/devicetree/bindings/cache/msm_gladiator_erp.txt @@ -0,0 +1,16 @@ +* MSM Gladiator error reporting driver + +Required properties: +- compatible: Should be "qcom,msm-gladiator" +- reg: I/O address Gladiator H/W block +- reg-names: Should be "gladiator_base" +- interrupts: Should contain the gladiator error interrupt number. + +Example: + +qcom,msm-gladiator@b1c0000 { + compatible = "qcom,msm-gladiator"; + reg = <0xB1C0000 0x4000>; + reg-names = "gladiator_base"; + interrupts = <0 34 0>; +} diff --git a/drivers/soc/qcom/Kconfig b/drivers/soc/qcom/Kconfig index 613f0ade8fe8..663d6a8511e6 100644 --- a/drivers/soc/qcom/Kconfig +++ b/drivers/soc/qcom/Kconfig @@ -314,6 +314,15 @@ config MSM_SECURE_BUFFER use this memory and no unauthorized access is made to the buffer +config MSM_GLADIATOR_ERP + tristate "GLADIATOR coherency interconnect error reporting driver" + help + Support dumping debug information for the GLADIATOR + cache interconnect in the error interrupt handler. + Meant to be used for debug scenarios only. + + If unsure, say N. + endif # ARCH_QCOM config MSM_SUBSYSTEM_RESTART diff --git a/drivers/soc/qcom/Makefile b/drivers/soc/qcom/Makefile index bf67d9fa3621..d167316687a0 100644 --- a/drivers/soc/qcom/Makefile +++ b/drivers/soc/qcom/Makefile @@ -51,3 +51,4 @@ obj-$(CONFIG_QCOM_BUS_SCALING) += msm_bus/ obj-$(CONFIG_MSM_SECURE_BUFFER) += secure_buffer.o obj-$(CONFIG_MSM_MPM_OF) += mpm-of.o obj-$(CONFIG_MSM_EVENT_TIMER) += event_timer.o +obj-$(CONFIG_MSM_GLADIATOR_ERP) += gladiator_erp.o diff --git a/drivers/soc/qcom/gladiator_erp.c b/drivers/soc/qcom/gladiator_erp.c new file mode 100644 index 000000000000..df7749d278f8 --- /dev/null +++ b/drivers/soc/qcom/gladiator_erp.c @@ -0,0 +1,648 @@ +/* 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 +#include +#include +#include +#include +#include +#include +#include +#include + +#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"); -- 2.11.0