diff options
| -rw-r--r-- | Documentation/devicetree/bindings/cache/msm_gladiator_erp.txt | 16 | ||||
| -rw-r--r-- | drivers/soc/qcom/Kconfig | 9 | ||||
| -rw-r--r-- | drivers/soc/qcom/Makefile | 1 | ||||
| -rw-r--r-- | drivers/soc/qcom/gladiator_erp.c | 648 |
4 files changed, 674 insertions, 0 deletions
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 <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"); |