From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932745AbbJ1QPj (ORCPT ); Wed, 28 Oct 2015 12:15:39 -0400 Received: from mail-bl2on0093.outbound.protection.outlook.com ([65.55.169.93]:32158 "EHLO na01-bl2-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S932537AbbJ1QPg (ORCPT ); Wed, 28 Oct 2015 12:15:36 -0400 Authentication-Results: spf=none (sender IP is 165.204.84.222) smtp.mailfrom=amd.com; alien8.de; dkim=none (message not signed) header.d=none;alien8.de; dmarc=permerror action=none header.from=amd.com; X-WSS-ID: 0NWXUHS-08-DEV-02 X-M-MSG: From: Brijesh Singh To: CC: Brijesh Singh , , , , , , , , , , , , , , , Subject: [PATCH v4] EDAC: Add ARM64 EDAC Date: Wed, 28 Oct 2015 11:13:49 -0500 Message-ID: <1446048829-3359-1-git-send-email-brijeshkumar.singh@amd.com> X-Mailer: git-send-email 1.9.1 MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [10.180.168.240] X-EOPAttributedMessage: 0 X-Forefront-Antispam-Report: CIP:165.204.84.222;CTRY:US;IPV:NLI;EFV:NLI;SFV:NSPM;SFS:(10009020)(6009001)(2980300002)(428002)(189002)(199003)(86362001)(42186005)(105586002)(36756003)(19580395003)(97736004)(575784001)(92566002)(33646002)(87936001)(50986999)(101416001)(106466001)(50226001)(50466002)(5003940100001)(189998001)(48376002)(47776003)(229853001)(110136002)(19580405001)(11100500001)(5008740100001)(2351001)(5004730100002)(5007970100001)(2004002);DIR:OUT;SFP:1101;SCL:1;SRVR:CY1PR12MB0854;H:atltwp02.amd.com;FPR:;SPF:None;PTR:InfoDomainNonexistent;MX:1;A:1;LANG:en; X-Microsoft-Exchange-Diagnostics: 1;CY1PR12MB0854;2:ry9OXx2BdzDriCEWRvMQrLqsYbxnXFYbgPoF4F9fhOOSUgHo0qSFks7yDGz6FbzKivl6dZIEIEYXJwHW4omiKPvFP3qT/cuS6ARs1aRe/Wjit2PNqEAyE3Vi9ThursExMmJoVT+SfcyN2XElJAG/yCfKjY+AIB/qu5J18+qIETs=;3:6POnx4po8yaect/7Jaju6+UuoQCoKVzo7l0HZ3S83bC+4wuKCHB9D98pspoZv9Vs+QaolmTMEz3PiLJhHWZXnXIQUpJLuc/5mqCKzvEk2KQBBXGmhzoJEwlRIzRkvy5ZpGXqUVEtQt9WJlrLd8M3uW8NfWYWPUuErwSTQJNH499Qx8xiLLv8DqU2aYGDu4j4M3NLXEWXL+bX5S692UJuKUSLgmD43aPpQLlH8rP8O/GRZGgqj6kXwVpK0Ddg15J6;25:FZUCom1NQ2YLPN2RSUHa9vE6g7eLivycyeJNP9JB9riucRHHQUAlKwjqMlSN479PqspSTMRI95uoBk0XrxOcfqlkTKDeuuyjtvS6/JRkg0p/js2dB95JzBOLp0TnPnB+tU75TQQsl6A8S3eL3u5c0oWYm6ifXslqOdU6nAVNIuObFuDeasmL7w+lMZTv9Y62l6RizQg8hRzoPyXeBEEwwR7rEz+TrwpWD+twCGhosdwZSRH5HK/pVDhbYAHoGyeP X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:CY1PR12MB0854; X-Microsoft-Exchange-Diagnostics: 1;CY1PR12MB0854;20:NPlvSvYtpWv511Vp5QcUHzIb3VaShSsLMGE6lP3irZ+7noo14PDoNboDOvOkZzPTfiHWI1+59UPlgeFLfJ2Yqlil6yLRbUiEDFjLljYQI8tORyYnMvP+40j5mYeXSaGntnCV0Hw7fqPEi8vbrZ6pdCmKZfk8lqWG7NKrNjA2F2N5YuHXLZR9jlkr65SCi4qdMrwu0MGukLyvc5HX0c6v/MkCbqdLnqwqaPpAltnJGTbqjWXNcqE/78Fwtg4RP+UzjHT+361xsq1L4uCf+dUZFPzxSMXRuCobrPvwggvCRllhWsHrI+nKEEaXd0ClXw5qJdiUiA502ne+jZ0CQmudFBhPId5QMtIg7VZKuNgHE/DJxIAvdfcbjONSVl2vqLEGycayPmVNFTD65F1eh7pRvzezAGsg+Z9Fkpy8aQlbv/u0Qn0ZVjY2ANiScbpuRsIRQiK+CCPaeoaT7YYU2E0jvF3Bi3Ua9+fjDvipvR8WvZnA61HTq3S4GQFfe7RxVQcm;4:H+5qes14rIy69XDsZtZWckzBS9I0e3tWAV8dIY42i6oDJhtmsqJbM5fg0Qi+0sIEt5AX5w1vD88rmVPTC6064S36gFuk2E3O/OFppOJAen6JAz8zoj6WhfQeLTdDpDj2R2tW7gh+nQ9l2Q9tbS2lMcDLJFv/TwfBuzZxJfYi6JfDVsDRyn4uGRojMVzm6IqiuBPS/vEHfcMMtlK5JMyMwL6vfa+89ShNUVvzebAJIKjBrLiQCFtYWWiA577ZT3h2auCFpv9DPsOrqvrRtTADSkmTb6nSMxcX/17pSpo0ATP/QWGf5Ad785AAs0IFPjoimbaIeWYkL4aPmz+DslTGFoGXT6XqdkaLTIHUaGa/KoQthDPxFYlfMF4aJqDQ9DoFUXCZKN+bK+m1Hvi1CtVd4w== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(767451399110); X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(601004)(2401047)(8121501046)(5005006)(520078)(3002001)(10201501046)(102215026);SRVR:CY1PR12MB0854;BCL:0;PCL:0;RULEID:;SRVR:CY1PR12MB0854; X-Forefront-PRVS: 0743E8D0A6 X-Microsoft-Exchange-Diagnostics: 1;CY1PR12MB0854;23:jicNaPUE1695GPoMP2/dp6vyyCmqBHXfMh1iwCzP0s1QrYh41vnsNmbLcS3PpaSz3f1TEtw95IV4k1UmKl80DbAHI4CUd6z6CJ5h+g+lp7dw/7h9XLMZRngdFRPsdvqpruo1PeH2mLgRH7egl8a3fa0XVfzQuL8SJdn09XlraVk9GOd2eFjAeoK8vhybkyllfpXSZ0mdN1mtWz3xEgtQYmsjnhyLad3w746jDH6FnEXHiwqR6pF1slDRls8jR+0Sszc+7V6h5M1D+aeiEz4+/+E47tYni6xX4LS8oe+5TQzj3v4rfvThNiJyRHpmnoCdB243GBshSkh2/zzRjyv+BQuLCWmZf5DBxYOJKAzLYUcb9gL6xG6rCl9NvcSvMN37XzWGQ6eMOl7/MUiDuYlG2YfjxD5qXUBQDQWWPCSEwom042xJb1BY7UZ8DM1xz5W8YTRHEc8ly5H3JWTOr2W09zKTDSLfhXeZbhxh+JSyXMkoRvV/VTJYdyOZDtH32WmUZ6QSFZjkprO79a8tcATtedbWGw6FcPZTCiQIQzvHdqXMX7OzGPPc7vTlYWFrQYzWMXMVJVUcRXqaChdbCV6Qjd65bGFQbyvrgCiltntIZFjqo9eeb3r876JPlKe+aYoeZuD0BNxw33N6QWqpRdf15B2GH0Uo5EOhwnSmxIUrdRSM3pUWiMOCKpvjZpTFzYEbFQxUpDNvVvhCAw0pnuezsmFjf/3VREWdVm6SDCUf3iAKIyrsuOjwX4nz41lcNCVU5+0DP+ra7rF4oe/0bzoaRK9sn/vBtZddfJ74X3vUU/sZ8pP8zlEXr9lhKlXAlQfOJz545Mhj6CqwaMB77XjUGfXO580vQhJOvV3fvO+rjrDXMR5pXzBseHKxePIe2cTzwPaYwKAAbRJ90LLdav+9sXx4Cb8/f1zSTdf4Jq/135o= X-Microsoft-Exchange-Diagnostics: 1;CY1PR12MB0854;5:UCtu0+PCE0jVzNhFkSp5ajvdFdF0hAdn1k9BK2qJPlu09vLiqLI/uHtDyndF1dr9Q68Z4LuCsc++al5ds94roLTlJbnv1b08gb0KSRPZ302tFxn9FO3L9HEwTSn4rQkbq6izNbjtWRSh7JfHMvNuLg==;24:1NrwbN/Waxp7fjDIg7+dhE36JSsmtgBSu25pN6UaPv4CFkXGc50ocfnY6ADboH3w4U2JatTYvy3hfwD45zADP0EQ4CdPtf30Fw1db+yMFz8=;20:tNysko54GIADXngQUI5NEMqFkbEmUCJb12khyCoZTynJoCQeaXu3sAAT0Ot4CXQa28VATvuXteHR61yAci6MrFITieokTF2MV6TOlQZRPn6pWxOaMqjhRwGOpmnnDocid54NQeij7/AvRSAaoMvv1fjR2b0sulp5OoKcinxpQzes7CEt5gei22UanMSMCJAb501CzKIelXB1bPTru4Fan6gPgRsBDu9kdhe9Yr4YA7Kq5HC4GBHjjdB9GKPL65zk SpamDiagnosticOutput: 1:23 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 28 Oct 2015 16:15:30.9866 (UTC) X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d;Ip=[165.204.84.222];Helo=[atltwp02.amd.com] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: CY1PR12MB0854 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add support for Cortex A57 and A53 EDAC driver. Signed-off-by: Brijesh Singh CC: robh+dt@kernel.org CC: pawel.moll@arm.com CC: mark.rutland@arm.com CC: ijc+devicetree@hellion.org.uk CC: galak@codeaurora.org CC: dougthompson@xmission.com CC: bp@alien8.de CC: mchehab@osg.samsung.com CC: devicetree@vger.kernel.org CC: guohanjun@huawei.com CC: andre.przywara@arm.com CC: arnd@arndb.de CC: sboyd@codeaurora.org CC: linux-kernel@vger.kernel.org CC: linux-edac@vger.kernel.org --- Tested error reporting via rasdeamon on AMD seattle platform. v4: * remove THIS_MODULE assignment from platform_driver * use module_platform_driver(), remove module_init() and module_exit() * remove default n from Kconfig v3: * change DT binding compatibilty string to 'cortex-a57-edac' * remove A57/A53 prefix from register bit definition * unify A57 and A53 L1/L2 error parsing functions * use mc trace event function to report the error * update Kconfig default to 'n' v2: * convert into generic arm64 edac driver * remove AMD specific references from dt binding * remove poll_msec property from dt binding * add poll_msec as a module param, default is 100ms * update copyright text * define macro mnemonics for L1 and L2 RAMID * check L2 error per-cluster instead of per core * update function names * use get_online_cpus() and put_online_cpus() to make L1 and L2 register read hotplug-safe * add error check in probe routine .../devicetree/bindings/edac/cortex-arm64-edac.txt | 15 + drivers/edac/Kconfig | 7 + drivers/edac/Makefile | 1 + drivers/edac/cortex_arm64_edac.c | 336 +++++++++++++++++++++ 4 files changed, 359 insertions(+) create mode 100644 Documentation/devicetree/bindings/edac/cortex-arm64-edac.txt create mode 100644 drivers/edac/cortex_arm64_edac.c diff --git a/Documentation/devicetree/bindings/edac/cortex-arm64-edac.txt b/Documentation/devicetree/bindings/edac/cortex-arm64-edac.txt new file mode 100644 index 0000000..552f0c7 --- /dev/null +++ b/Documentation/devicetree/bindings/edac/cortex-arm64-edac.txt @@ -0,0 +1,15 @@ +* ARM Cortex A57 and A53 L1/L2 cache error reporting + +CPU Memory Error Syndrome and L2 Memory Error Syndrome registers can be used +for checking L1 and L2 memory errors. + +The following section describes the Cortex A57/A53 EDAC DT node binding. + +Required properties: +- compatible: Should be "arm,cortex-a57-edac" or "arm,cortex-a53-edac" + +Example: + edac { + compatible = "arm,cortex-a57-edac"; + }; + diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig index ef25000..e8f5306 100644 --- a/drivers/edac/Kconfig +++ b/drivers/edac/Kconfig @@ -390,4 +390,11 @@ config EDAC_XGENE Support for error detection and correction on the APM X-Gene family of SOCs. +config EDAC_CORTEX_ARM64 + tristate "ARM Cortex A57/A53" + depends on EDAC_MM_EDAC && ARM64 + help + Support for error detection and correction on the + ARM Cortex A57 and A53. + endif # EDAC diff --git a/drivers/edac/Makefile b/drivers/edac/Makefile index ae3c5f3..ac01660 100644 --- a/drivers/edac/Makefile +++ b/drivers/edac/Makefile @@ -68,3 +68,4 @@ obj-$(CONFIG_EDAC_OCTEON_PCI) += octeon_edac-pci.o obj-$(CONFIG_EDAC_ALTERA_MC) += altera_edac.o obj-$(CONFIG_EDAC_SYNOPSYS) += synopsys_edac.o obj-$(CONFIG_EDAC_XGENE) += xgene_edac.o +obj-$(CONFIG_EDAC_CORTEX_ARM64) += cortex_arm64_edac.o diff --git a/drivers/edac/cortex_arm64_edac.c b/drivers/edac/cortex_arm64_edac.c new file mode 100644 index 0000000..b2a8723 --- /dev/null +++ b/drivers/edac/cortex_arm64_edac.c @@ -0,0 +1,336 @@ +/* + * Cortex A57 and A53 EDAC + * + * Copyright (c) 2015, Advanced Micro Devices + * Author: Brijesh Singh + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License. + * + * 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 "edac_core.h" + +#define DRV_NAME "cortex_edac" + +#define CPUMERRSR_EL1_INDEX(x, y) ((x) & (y)) +#define CPUMERRSR_EL1_BANK_WAY(x, y) (((x) >> 18) & (y)) +#define CPUMERRSR_EL1_RAMID(x) (((x) >> 24) & 0x7f) +#define CPUMERRSR_EL1_VALID(x) ((x) & (1 << 31)) +#define CPUMERRSR_EL1_REPEAT(x) (((x) >> 32) & 0x7f) +#define CPUMERRSR_EL1_OTHER(x) (((x) >> 40) & 0xff) +#define CPUMERRSR_EL1_FATAL(x) ((x) & (1UL << 63)) +#define L1_I_TAG_RAM 0x00 +#define L1_I_DATA_RAM 0x01 +#define L1_D_TAG_RAM 0x08 +#define L1_D_DATA_RAM 0x09 +#define L1_D_DIRTY_RAM 0x14 +#define TLB_RAM 0x18 + +#define L2MERRSR_EL1_CPUID_WAY(x) (((x) >> 18) & 0xf) +#define L2MERRSR_EL1_RAMID(x) (((x) >> 24) & 0x7f) +#define L2MERRSR_EL1_VALID(x) ((x) & (1 << 31)) +#define L2MERRSR_EL1_REPEAT(x) (((x) >> 32) & 0xff) +#define L2MERRSR_EL1_OTHER(x) (((x) >> 40) & 0xff) +#define L2MERRSR_EL1_FATAL(x) ((x) & (1UL << 63)) +#define L2_TAG_RAM 0x10 +#define L2_DATA_RAM 0x11 +#define L2_SNOOP_RAM 0x12 +#define L2_DIRTY_RAM 0x14 +#define L2_INCLUSION_PF_RAM 0x18 + +#define L1_CACHE 0 +#define L2_CACHE 1 + +#define EDAC_MOD_STR DRV_NAME + +static int poll_msec = 100; + +struct cortex_arm64_edac { + struct edac_device_ctl_info *edac_ctl; +}; + +static inline u64 read_cpumerrsr_el1(void) +{ + u64 val; + + asm volatile("mrs %0, s3_1_c15_c2_2" : "=r" (val)); + return val; +} + +static inline void write_cpumerrsr_el1(u64 val) +{ + asm volatile("msr s3_1_c15_c2_2, %0" :: "r" (val)); +} + +static inline u64 read_l2merrsr_el1(void) +{ + u64 val; + + asm volatile("mrs %0, s3_1_c15_c2_3" : "=r" (val)); + return val; +} + +static inline void write_l2merrsr_el1(u64 val) +{ + asm volatile("msr s3_1_c15_c2_3, %0" :: "r" (val)); +} + +static void parse_cpumerrsr(void *arg) +{ + int cpu, partnum, way; + unsigned int index = 0; + u64 val = read_cpumerrsr_el1(); + int repeat_err, other_err; + + /* we do not support fatal error handling so far */ + if (CPUMERRSR_EL1_FATAL(val)) + return; + + /* check if we have valid error before continuing */ + if (!CPUMERRSR_EL1_VALID(val)) + return; + + cpu = smp_processor_id(); + partnum = read_cpuid_part_number(); + repeat_err = CPUMERRSR_EL1_REPEAT(val); + other_err = CPUMERRSR_EL1_OTHER(val); + + /* way/bank and index address bit ranges are different between + * A57 and A53 */ + if (partnum == ARM_CPU_PART_CORTEX_A57) { + index = CPUMERRSR_EL1_INDEX(val, 0x1ffff); + way = CPUMERRSR_EL1_BANK_WAY(val, 0x1f); + } else { + index = CPUMERRSR_EL1_INDEX(val, 0xfff); + way = CPUMERRSR_EL1_BANK_WAY(val, 0x7); + } + + edac_printk(KERN_CRIT, EDAC_MOD_STR, "CPU%d L1 error detected!\n", cpu); + edac_printk(KERN_CRIT, EDAC_MOD_STR, "index=%#x, RAMID=", index); + + switch (CPUMERRSR_EL1_RAMID(val)) { + case L1_I_TAG_RAM: + pr_cont("'L1-I Tag RAM' (way %d)", way); + break; + case L1_I_DATA_RAM: + pr_cont("'L1-I Data RAM' (bank %d)", way); + break; + case L1_D_TAG_RAM: + pr_cont("'L1-D Tag RAM' (way %d)", way); + break; + case L1_D_DATA_RAM: + pr_cont("'L1-D Data RAM' (bank %d)", way); + break; + case L1_D_DIRTY_RAM: + pr_cont("'L1 Dirty RAM'"); + break; + case TLB_RAM: + pr_cont("'TLB RAM'"); + break; + default: + pr_cont("'unknown'"); + break; + } + + pr_cont(", repeat=%d, other=%d (CPUMERRSR_EL1=%#llx)\n", repeat_err, + other_err, val); + + trace_mc_event(HW_EVENT_ERR_CORRECTED, "L1 non-fatal error", + "", repeat_err, 0, 0, 0, -1, index, 0, 0, DRV_NAME); + write_cpumerrsr_el1(0); +} + +static void a57_parse_l2merrsr_way(u8 ramid, u8 val) +{ + switch (ramid) { + case L2_TAG_RAM: + case L2_DATA_RAM: + case L2_DIRTY_RAM: + pr_cont("(cpu%d tag, way %d)", val / 2, val % 2); + break; + case L2_SNOOP_RAM: + pr_cont("(cpu%d tag, way %d)", (val & 0x6) >> 1, + (val & 0x1)); + break; + } +} + +static void a53_parse_l2merrsr_way(u8 ramid, u8 val) +{ + switch (ramid) { + case L2_TAG_RAM: + pr_cont("(way %d)", val); + case L2_DATA_RAM: + pr_cont("(bank %d)", val); + break; + case L2_SNOOP_RAM: + pr_cont("(cpu%d tag, way %d)", val / 2, val % 4); + break; + } +} + +static void parse_l2merrsr(void *arg) +{ + int cpu, partnum; + unsigned int index; + int repeat_err, other_err; + u64 val = read_l2merrsr_el1(); + + /* we do not support fatal error handling so far */ + if (L2MERRSR_EL1_FATAL(val)) + return; + + /* check if we have valid error before continuing */ + if (!L2MERRSR_EL1_VALID(val)) + return; + + cpu = smp_processor_id(); + partnum = read_cpuid_part_number(); + repeat_err = L2MERRSR_EL1_REPEAT(val); + other_err = L2MERRSR_EL1_OTHER(val); + + /* index address range is different between A57 and A53 */ + if (partnum == ARM_CPU_PART_CORTEX_A57) + index = val & 0x1ffff; + else + index = (val >> 3) & 0x3fff; + + edac_printk(KERN_CRIT, EDAC_MOD_STR, "CPU%d L2 error detected!\n", cpu); + edac_printk(KERN_CRIT, EDAC_MOD_STR, "index=%#x RAMID=", index); + + switch (L2MERRSR_EL1_RAMID(val)) { + case L2_TAG_RAM: + pr_cont("'L2 Tag RAM'"); + break; + case L2_DATA_RAM: + pr_cont("'L2 Data RAM'"); + break; + case L2_SNOOP_RAM: + pr_cont("'L2 Snoop tag RAM'"); + break; + case L2_DIRTY_RAM: + pr_cont("'L2 Dirty RAM'"); + break; + case L2_INCLUSION_PF_RAM: + pr_cont("'L2 inclusion PF RAM'"); + break; + default: + pr_cont("unknown"); + break; + } + + /* cpuid/way bit description is different between A57 and A53 */ + if (partnum == ARM_CPU_PART_CORTEX_A57) + a57_parse_l2merrsr_way(L2MERRSR_EL1_RAMID(val), + L2MERRSR_EL1_CPUID_WAY(val)); + else + a53_parse_l2merrsr_way(L2MERRSR_EL1_RAMID(val), + L2MERRSR_EL1_CPUID_WAY(val)); + + pr_cont(", repeat=%d, other=%d (L2MERRSR_EL1=%#llx)\n", repeat_err, + other_err, val); + trace_mc_event(HW_EVENT_ERR_CORRECTED, "L2 non-fatal error", + "", repeat_err, 0, 0, 0, -1, index, 0, 0, DRV_NAME); + write_l2merrsr_el1(0); +} + +static void cortex_arm64_edac_check(struct edac_device_ctl_info *edac_ctl) +{ + int cpu; + struct cpumask cluster_mask, old_mask; + + cpumask_clear(&cluster_mask); + cpumask_clear(&old_mask); + + get_online_cpus(); + for_each_online_cpu(cpu) { + /* Check CPU L1 error */ + smp_call_function_single(cpu, parse_cpumerrsr, NULL, 0); + cpumask_copy(&cluster_mask, topology_core_cpumask(cpu)); + if (cpumask_equal(&cluster_mask, &old_mask)) + continue; + cpumask_copy(&old_mask, &cluster_mask); + /* Check CPU L2 error */ + smp_call_function_any(&cluster_mask, parse_l2merrsr, NULL, 0); + } + put_online_cpus(); +} + +static int cortex_arm64_edac_probe(struct platform_device *pdev) +{ + int rc; + struct cortex_arm64_edac *drv; + struct device *dev = &pdev->dev; + + drv = devm_kzalloc(dev, sizeof(*drv), GFP_KERNEL); + if (!drv) + return -ENOMEM; + + /* Only POLL mode is supported */ + edac_op_state = EDAC_OPSTATE_POLL; + + drv->edac_ctl = edac_device_alloc_ctl_info(0, "cpu_cache", 1, "L", 2, + 0, NULL, 0, + edac_device_alloc_index()); + if (IS_ERR(drv->edac_ctl)) + return -ENOMEM; + + drv->edac_ctl->poll_msec = poll_msec; + drv->edac_ctl->edac_check = cortex_arm64_edac_check; + drv->edac_ctl->dev = dev; + drv->edac_ctl->mod_name = dev_name(dev); + drv->edac_ctl->dev_name = dev_name(dev); + drv->edac_ctl->ctl_name = "cache_err"; + platform_set_drvdata(pdev, drv); + + rc = edac_device_add_device(drv->edac_ctl); + if (rc) + edac_device_free_ctl_info(drv->edac_ctl); + + return rc; +} + +static int cortex_arm64_edac_remove(struct platform_device *pdev) +{ + struct cortex_arm64_edac *drv = dev_get_drvdata(&pdev->dev); + struct edac_device_ctl_info *edac_ctl = drv->edac_ctl; + + edac_device_del_device(edac_ctl->dev); + edac_device_free_ctl_info(edac_ctl); + + return 0; +} + +static const struct of_device_id cortex_arm64_edac_of_match[] = { + { .compatible = "arm,cortex-a57-edac" }, + { .compatible = "arm,cortex-a53-edac" }, + {} +}; +MODULE_DEVICE_TABLE(of, cortex_arm64_edac_of_match); + +static struct platform_driver cortex_arm64_edac_driver = { + .probe = cortex_arm64_edac_probe, + .remove = cortex_arm64_edac_remove, + .driver = { + .name = DRV_NAME, + .of_match_table = cortex_arm64_edac_of_match, + }, +}; +module_platform_driver(cortex_arm64_edac_driver); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Brijesh Singh "); +MODULE_DESCRIPTION("Cortex A57 and A53 EDAC driver"); +module_param(poll_msec, int, 0444); +MODULE_PARM_DESC(poll_msec, "EDAC monitor poll interval in msec"); -- 1.9.1