drivers/edac/xgene_edac.c

   1 /*
   2  * APM X-Gene SoC EDAC (error detection and correction)
   3  *
   4  * Copyright (c) 2015, Applied Micro Circuits Corporation
   5  * Author: Feng Kan <fkan@apm.com>
   6  *         Loc Ho <lho@apm.com>
   7  *
   8  * This program is free software; you can redistribute  it and/or modify it
   9  * under  the terms of  the GNU General  Public License as published by the
  10  * Free Software Foundation;  either version 2 of the  License, or (at your
  11  * option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <linux/ctype.h>
  23 #include <linux/edac.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/mfd/syscon.h>
  26 #include <linux/module.h>
  27 #include <linux/of.h>
  28 #include <linux/of_address.h>
  29 #include <linux/regmap.h>
  30
  31 #include "edac_core.h"
  32 #include "edac_module.h"
  33
  34 #define EDAC_MOD_STR                    "xgene_edac"
  35
  36 /* Global error configuration status registers (CSR) */
  37 #define PCPHPERRINTSTS                  0x0000
  38 #define PCPHPERRINTMSK                  0x0004
  39 #define  MCU_CTL_ERR_MASK               BIT(12)
  40 #define  IOB_PA_ERR_MASK                BIT(11)
  41 #define  IOB_BA_ERR_MASK                BIT(10)
  42 #define  IOB_XGIC_ERR_MASK              BIT(9)
  43 #define  IOB_RB_ERR_MASK                BIT(8)
  44 #define  L3C_UNCORR_ERR_MASK            BIT(5)
  45 #define  MCU_UNCORR_ERR_MASK            BIT(4)
  46 #define  PMD3_MERR_MASK                 BIT(3)
  47 #define  PMD2_MERR_MASK                 BIT(2)
  48 #define  PMD1_MERR_MASK                 BIT(1)
  49 #define  PMD0_MERR_MASK                 BIT(0)
  50 #define PCPLPERRINTSTS                  0x0008
  51 #define PCPLPERRINTMSK                  0x000C
  52 #define  CSW_SWITCH_TRACE_ERR_MASK      BIT(2)
  53 #define  L3C_CORR_ERR_MASK              BIT(1)
  54 #define  MCU_CORR_ERR_MASK              BIT(0)
  55 #define MEMERRINTSTS                    0x0010
  56 #define MEMERRINTMSK                    0x0014
  57
  58 struct xgene_edac {
  59         struct device           *dev;
  60         struct regmap           *csw_map;
  61         struct regmap           *mcba_map;
  62         struct regmap           *mcbb_map;
  63         struct regmap           *efuse_map;
  64         void __iomem            *pcp_csr;
  65         spinlock_t              lock;
  66         struct dentry           *dfs;
  67
  68         struct list_head        mcus;
  69         struct list_head        pmds;
  70         struct list_head        l3s;
  71         struct list_head        socs;
  72
  73         struct mutex            mc_lock;
  74         int                     mc_active_mask;
  75         int                     mc_registered_mask;
  76 };
  77
  78 static void xgene_edac_pcp_rd(struct xgene_edac *edac, u32 reg, u32 *val)
  79 {
  80         *val = readl(edac->pcp_csr + reg);
  81 }
  82
  83 static void xgene_edac_pcp_clrbits(struct xgene_edac *edac, u32 reg,
  84                                    u32 bits_mask)
  85 {
  86         u32 val;
  87
  88         spin_lock(&edac->lock);
  89         val = readl(edac->pcp_csr + reg);
  90         val &= ~bits_mask;
  91         writel(val, edac->pcp_csr + reg);
  92         spin_unlock(&edac->lock);
  93 }
  94
  95 static void xgene_edac_pcp_setbits(struct xgene_edac *edac, u32 reg,
  96                                    u32 bits_mask)
  97 {
  98         u32 val;
  99
 100         spin_lock(&edac->lock);
 101         val = readl(edac->pcp_csr + reg);
 102         val |= bits_mask;
 103         writel(val, edac->pcp_csr + reg);
 104         spin_unlock(&edac->lock);
 105 }
 106
 107 /* Memory controller error CSR */
 108 #define MCU_MAX_RANK                    8
 109 #define MCU_RANK_STRIDE                 0x40
 110
 111 #define MCUGECR                         0x0110
 112 #define  MCU_GECR_DEMANDUCINTREN_MASK   BIT(0)
 113 #define  MCU_GECR_BACKUCINTREN_MASK     BIT(1)
 114 #define  MCU_GECR_CINTREN_MASK          BIT(2)
 115 #define  MUC_GECR_MCUADDRERREN_MASK     BIT(9)
 116 #define MCUGESR                         0x0114
 117 #define  MCU_GESR_ADDRNOMATCH_ERR_MASK  BIT(7)
 118 #define  MCU_GESR_ADDRMULTIMATCH_ERR_MASK       BIT(6)
 119 #define  MCU_GESR_PHYP_ERR_MASK         BIT(3)
 120 #define MCUESRR0                        0x0314
 121 #define  MCU_ESRR_MULTUCERR_MASK        BIT(3)
 122 #define  MCU_ESRR_BACKUCERR_MASK        BIT(2)
 123 #define  MCU_ESRR_DEMANDUCERR_MASK      BIT(1)
 124 #define  MCU_ESRR_CERR_MASK             BIT(0)
 125 #define MCUESRRA0                       0x0318
 126 #define MCUEBLRR0                       0x031c
 127 #define  MCU_EBLRR_ERRBANK_RD(src)      (((src) & 0x00000007) >> 0)
 128 #define MCUERCRR0                       0x0320
 129 #define  MCU_ERCRR_ERRROW_RD(src)       (((src) & 0xFFFF0000) >> 16)
 130 #define  MCU_ERCRR_ERRCOL_RD(src)       ((src) & 0x00000FFF)
 131 #define MCUSBECNT0                      0x0324
 132 #define MCU_SBECNT_COUNT(src)           ((src) & 0xFFFF)
 133
 134 #define CSW_CSWCR                       0x0000
 135 #define  CSW_CSWCR_DUALMCB_MASK         BIT(0)
 136
 137 #define MCBADDRMR                       0x0000
 138 #define  MCBADDRMR_MCU_INTLV_MODE_MASK  BIT(3)
 139 #define  MCBADDRMR_DUALMCU_MODE_MASK    BIT(2)
 140 #define  MCBADDRMR_MCB_INTLV_MODE_MASK  BIT(1)
 141 #define  MCBADDRMR_ADDRESS_MODE_MASK    BIT(0)
 142
 143 struct xgene_edac_mc_ctx {
 144         struct list_head        next;
 145         char                    *name;
 146         struct mem_ctl_info     *mci;
 147         struct xgene_edac       *edac;
 148         void __iomem            *mcu_csr;
 149         u32                     mcu_id;
 150 };
 151
 152 static ssize_t xgene_edac_mc_err_inject_write(struct file *file,
 153                                               const char __user *data,
 154                                               size_t count, loff_t *ppos)
 155 {
 156         struct mem_ctl_info *mci = file->private_data;
 157         struct xgene_edac_mc_ctx *ctx = mci->pvt_info;
 158         int i;
 159
 160         for (i = 0; i < MCU_MAX_RANK; i++) {
 161                 writel(MCU_ESRR_MULTUCERR_MASK | MCU_ESRR_BACKUCERR_MASK |
 162                        MCU_ESRR_DEMANDUCERR_MASK | MCU_ESRR_CERR_MASK,
 163                        ctx->mcu_csr + MCUESRRA0 + i * MCU_RANK_STRIDE);
 164         }
 165         return count;
 166 }
 167
 168 static const struct file_operations xgene_edac_mc_debug_inject_fops = {
 169         .open = simple_open,
 170         .write = xgene_edac_mc_err_inject_write,
 171         .llseek = generic_file_llseek,
 172 };
 173
 174 static void xgene_edac_mc_create_debugfs_node(struct mem_ctl_info *mci)
 175 {
 176         if (!IS_ENABLED(CONFIG_EDAC_DEBUG))
 177                 return;
 178
 179         if (!mci->debugfs)
 180                 return;
 181
 182         edac_debugfs_create_file("inject_ctrl", S_IWUSR, mci->debugfs, mci,
 183                                  &xgene_edac_mc_debug_inject_fops);
 184 }
 185
 186 static void xgene_edac_mc_check(struct mem_ctl_info *mci)
 187 {
 188         struct xgene_edac_mc_ctx *ctx = mci->pvt_info;
 189         unsigned int pcp_hp_stat;
 190         unsigned int pcp_lp_stat;
 191         u32 reg;
 192         u32 rank;
 193         u32 bank;
 194         u32 count;
 195         u32 col_row;
 196
 197         xgene_edac_pcp_rd(ctx->edac, PCPHPERRINTSTS, &pcp_hp_stat);
 198         xgene_edac_pcp_rd(ctx->edac, PCPLPERRINTSTS, &pcp_lp_stat);
 199         if (!((MCU_UNCORR_ERR_MASK & pcp_hp_stat) ||
 200               (MCU_CTL_ERR_MASK & pcp_hp_stat) ||
 201               (MCU_CORR_ERR_MASK & pcp_lp_stat)))
 202                 return;
 203
 204         for (rank = 0; rank < MCU_MAX_RANK; rank++) {
 205                 reg = readl(ctx->mcu_csr + MCUESRR0 + rank * MCU_RANK_STRIDE);
 206
 207                 /* Detect uncorrectable memory error */
 208                 if (reg & (MCU_ESRR_DEMANDUCERR_MASK |
 209                            MCU_ESRR_BACKUCERR_MASK)) {
 210                         /* Detected uncorrectable memory error */
 211                         edac_mc_chipset_printk(mci, KERN_ERR, "X-Gene",
 212                                 "MCU uncorrectable error at rank %d\n", rank);
 213
 214                         edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci,
 215                                 1, 0, 0, 0, 0, 0, -1, mci->ctl_name, "");
 216                 }
 217
 218                 /* Detect correctable memory error */
 219                 if (reg & MCU_ESRR_CERR_MASK) {
 220                         bank = readl(ctx->mcu_csr + MCUEBLRR0 +
 221                                      rank * MCU_RANK_STRIDE);
 222                         col_row = readl(ctx->mcu_csr + MCUERCRR0 +
 223                                         rank * MCU_RANK_STRIDE);
 224                         count = readl(ctx->mcu_csr + MCUSBECNT0 +
 225                                       rank * MCU_RANK_STRIDE);
 226                         edac_mc_chipset_printk(mci, KERN_WARNING, "X-Gene",
 227                                 "MCU correctable error at rank %d bank %d column %d row %d count %d\n",
 228                                 rank, MCU_EBLRR_ERRBANK_RD(bank),
 229                                 MCU_ERCRR_ERRCOL_RD(col_row),
 230                                 MCU_ERCRR_ERRROW_RD(col_row),
 231                                 MCU_SBECNT_COUNT(count));
 232
 233                         edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci,
 234                                 1, 0, 0, 0, 0, 0, -1, mci->ctl_name, "");
 235                 }
 236
 237                 /* Clear all error registers */
 238                 writel(0x0, ctx->mcu_csr + MCUEBLRR0 + rank * MCU_RANK_STRIDE);
 239                 writel(0x0, ctx->mcu_csr + MCUERCRR0 + rank * MCU_RANK_STRIDE);
 240                 writel(0x0, ctx->mcu_csr + MCUSBECNT0 +
 241                        rank * MCU_RANK_STRIDE);
 242                 writel(reg, ctx->mcu_csr + MCUESRR0 + rank * MCU_RANK_STRIDE);
 243         }
 244
 245         /* Detect memory controller error */
 246         reg = readl(ctx->mcu_csr + MCUGESR);
 247         if (reg) {
 248                 if (reg & MCU_GESR_ADDRNOMATCH_ERR_MASK)
 249                         edac_mc_chipset_printk(mci, KERN_WARNING, "X-Gene",
 250                                 "MCU address miss-match error\n");
 251                 if (reg & MCU_GESR_ADDRMULTIMATCH_ERR_MASK)
 252                         edac_mc_chipset_printk(mci, KERN_WARNING, "X-Gene",
 253                                 "MCU address multi-match error\n");
 254
 255                 writel(reg, ctx->mcu_csr + MCUGESR);
 256         }
 257 }
 258
 259 static void xgene_edac_mc_irq_ctl(struct mem_ctl_info *mci, bool enable)
 260 {
 261         struct xgene_edac_mc_ctx *ctx = mci->pvt_info;
 262         unsigned int val;
 263
 264         if (edac_op_state != EDAC_OPSTATE_INT)
 265                 return;
 266
 267         mutex_lock(&ctx->edac->mc_lock);
 268
 269         /*
 270          * As there is only single bit for enable error and interrupt mask,
 271          * we must only enable top level interrupt after all MCUs are
 272          * registered. Otherwise, if there is an error and the corresponding
 273          * MCU has not registered, the interrupt will never get cleared. To
 274          * determine all MCU have registered, we will keep track of active
 275          * MCUs and registered MCUs.
 276          */
 277         if (enable) {
 278                 /* Set registered MCU bit */
 279                 ctx->edac->mc_registered_mask |= 1 << ctx->mcu_id;
 280
 281                 /* Enable interrupt after all active MCU registered */
 282                 if (ctx->edac->mc_registered_mask ==
 283                     ctx->edac->mc_active_mask) {
 284                         /* Enable memory controller top level interrupt */
 285                         xgene_edac_pcp_clrbits(ctx->edac, PCPHPERRINTMSK,
 286                                                MCU_UNCORR_ERR_MASK |
 287                                                MCU_CTL_ERR_MASK);
 288                         xgene_edac_pcp_clrbits(ctx->edac, PCPLPERRINTMSK,
 289                                                MCU_CORR_ERR_MASK);
 290                 }
 291
 292                 /* Enable MCU interrupt and error reporting */
 293                 val = readl(ctx->mcu_csr + MCUGECR);
 294                 val |= MCU_GECR_DEMANDUCINTREN_MASK |
 295                        MCU_GECR_BACKUCINTREN_MASK |
 296                        MCU_GECR_CINTREN_MASK |
 297                        MUC_GECR_MCUADDRERREN_MASK;
 298                 writel(val, ctx->mcu_csr + MCUGECR);
 299         } else {
 300                 /* Disable MCU interrupt */
 301                 val = readl(ctx->mcu_csr + MCUGECR);
 302                 val &= ~(MCU_GECR_DEMANDUCINTREN_MASK |
 303                          MCU_GECR_BACKUCINTREN_MASK |
 304                          MCU_GECR_CINTREN_MASK |
 305                          MUC_GECR_MCUADDRERREN_MASK);
 306                 writel(val, ctx->mcu_csr + MCUGECR);
 307
 308                 /* Disable memory controller top level interrupt */
 309                 xgene_edac_pcp_setbits(ctx->edac, PCPHPERRINTMSK,
 310                                        MCU_UNCORR_ERR_MASK | MCU_CTL_ERR_MASK);
 311                 xgene_edac_pcp_setbits(ctx->edac, PCPLPERRINTMSK,
 312                                        MCU_CORR_ERR_MASK);
 313
 314                 /* Clear registered MCU bit */
 315                 ctx->edac->mc_registered_mask &= ~(1 << ctx->mcu_id);
 316         }
 317
 318         mutex_unlock(&ctx->edac->mc_lock);
 319 }
 320
 321 static int xgene_edac_mc_is_active(struct xgene_edac_mc_ctx *ctx, int mc_idx)
 322 {
 323         unsigned int reg;
 324         u32 mcu_mask;
 325
 326         if (regmap_read(ctx->edac->csw_map, CSW_CSWCR, &reg))
 327                 return 0;
 328
 329         if (reg & CSW_CSWCR_DUALMCB_MASK) {
 330                 /*
 331                  * Dual MCB active - Determine if all 4 active or just MCU0
 332                  * and MCU2 active
 333                  */
 334                 if (regmap_read(ctx->edac->mcbb_map, MCBADDRMR, &reg))
 335                         return 0;
 336                 mcu_mask = (reg & MCBADDRMR_DUALMCU_MODE_MASK) ? 0xF : 0x5;
 337         } else {
 338                 /*
 339                  * Single MCB active - Determine if MCU0/MCU1 or just MCU0
 340                  * active
 341                  */
 342                 if (regmap_read(ctx->edac->mcba_map, MCBADDRMR, &reg))
 343                         return 0;
 344                 mcu_mask = (reg & MCBADDRMR_DUALMCU_MODE_MASK) ? 0x3 : 0x1;
 345         }
 346
 347         /* Save active MC mask if hasn't set already */
 348         if (!ctx->edac->mc_active_mask)
 349                 ctx->edac->mc_active_mask = mcu_mask;
 350
 351         return (mcu_mask & (1 << mc_idx)) ? 1 : 0;
 352 }
 353
 354 static int xgene_edac_mc_add(struct xgene_edac *edac, struct device_node *np)
 355 {
 356         struct mem_ctl_info *mci;
 357         struct edac_mc_layer layers[2];
 358         struct xgene_edac_mc_ctx tmp_ctx;
 359         struct xgene_edac_mc_ctx *ctx;
 360         struct resource res;
 361         int rc;
 362
 363         memset(&tmp_ctx, 0, sizeof(tmp_ctx));
 364         tmp_ctx.edac = edac;
 365
 366         if (!devres_open_group(edac->dev, xgene_edac_mc_add, GFP_KERNEL))
 367                 return -ENOMEM;
 368
 369         rc = of_address_to_resource(np, 0, &res);
 370         if (rc < 0) {
 371                 dev_err(edac->dev, "no MCU resource address\n");
 372                 goto err_group;
 373         }
 374         tmp_ctx.mcu_csr = devm_ioremap_resource(edac->dev, &res);
 375         if (IS_ERR(tmp_ctx.mcu_csr)) {
 376                 dev_err(edac->dev, "unable to map MCU resource\n");
 377                 rc = PTR_ERR(tmp_ctx.mcu_csr);
 378                 goto err_group;
 379         }
 380
 381         /* Ignore non-active MCU */
 382         if (of_property_read_u32(np, "memory-controller", &tmp_ctx.mcu_id)) {
 383                 dev_err(edac->dev, "no memory-controller property\n");
 384                 rc = -ENODEV;
 385                 goto err_group;
 386         }
 387         if (!xgene_edac_mc_is_active(&tmp_ctx, tmp_ctx.mcu_id)) {
 388                 rc = -ENODEV;
 389                 goto err_group;
 390         }
 391
 392         layers[0].type = EDAC_MC_LAYER_CHIP_SELECT;
 393         layers[0].size = 4;
 394         layers[0].is_virt_csrow = true;
 395         layers[1].type = EDAC_MC_LAYER_CHANNEL;
 396         layers[1].size = 2;
 397         layers[1].is_virt_csrow = false;
 398         mci = edac_mc_alloc(tmp_ctx.mcu_id, ARRAY_SIZE(layers), layers,
 399                             sizeof(*ctx));
 400         if (!mci) {
 401                 rc = -ENOMEM;
 402                 goto err_group;
 403         }
 404
 405         ctx = mci->pvt_info;
 406         *ctx = tmp_ctx;         /* Copy over resource value */
 407         ctx->name = "xgene_edac_mc_err";
 408         ctx->mci = mci;
 409         mci->pdev = &mci->dev;
 410         mci->ctl_name = ctx->name;
 411         mci->dev_name = ctx->name;
 412
 413         mci->mtype_cap = MEM_FLAG_RDDR | MEM_FLAG_RDDR2 | MEM_FLAG_RDDR3 |
 414                          MEM_FLAG_DDR | MEM_FLAG_DDR2 | MEM_FLAG_DDR3;
 415         mci->edac_ctl_cap = EDAC_FLAG_SECDED;
 416         mci->edac_cap = EDAC_FLAG_SECDED;
 417         mci->mod_name = EDAC_MOD_STR;
 418         mci->mod_ver = "0.1";
 419         mci->ctl_page_to_phys = NULL;
 420         mci->scrub_cap = SCRUB_FLAG_HW_SRC;
 421         mci->scrub_mode = SCRUB_HW_SRC;
 422
 423         if (edac_op_state == EDAC_OPSTATE_POLL)
 424                 mci->edac_check = xgene_edac_mc_check;
 425
 426         if (edac_mc_add_mc(mci)) {
 427                 dev_err(edac->dev, "edac_mc_add_mc failed\n");
 428                 rc = -EINVAL;
 429                 goto err_free;
 430         }
 431
 432         xgene_edac_mc_create_debugfs_node(mci);
 433
 434         list_add(&ctx->next, &edac->mcus);
 435
 436         xgene_edac_mc_irq_ctl(mci, true);
 437
 438         devres_remove_group(edac->dev, xgene_edac_mc_add);
 439
 440         dev_info(edac->dev, "X-Gene EDAC MC registered\n");
 441         return 0;
 442
 443 err_free:
 444         edac_mc_free(mci);
 445 err_group:
 446         devres_release_group(edac->dev, xgene_edac_mc_add);
 447         return rc;
 448 }
 449
 450 static int xgene_edac_mc_remove(struct xgene_edac_mc_ctx *mcu)
 451 {
 452         xgene_edac_mc_irq_ctl(mcu->mci, false);
 453         edac_mc_del_mc(&mcu->mci->dev);
 454         edac_mc_free(mcu->mci);
 455         return 0;
 456 }
 457
 458 /* CPU L1/L2 error CSR */
 459 #define MAX_CPU_PER_PMD                         2
 460 #define CPU_CSR_STRIDE                          0x00100000
 461 #define CPU_L2C_PAGE                            0x000D0000
 462 #define CPU_MEMERR_L2C_PAGE                     0x000E0000
 463 #define CPU_MEMERR_CPU_PAGE                     0x000F0000
 464
 465 #define MEMERR_CPU_ICFECR_PAGE_OFFSET           0x0000
 466 #define MEMERR_CPU_ICFESR_PAGE_OFFSET           0x0004
 467 #define  MEMERR_CPU_ICFESR_ERRWAY_RD(src)       (((src) & 0xFF000000) >> 24)
 468 #define  MEMERR_CPU_ICFESR_ERRINDEX_RD(src)     (((src) & 0x003F0000) >> 16)
 469 #define  MEMERR_CPU_ICFESR_ERRINFO_RD(src)      (((src) & 0x0000FF00) >> 8)
 470 #define  MEMERR_CPU_ICFESR_ERRTYPE_RD(src)      (((src) & 0x00000070) >> 4)
 471 #define  MEMERR_CPU_ICFESR_MULTCERR_MASK        BIT(2)
 472 #define  MEMERR_CPU_ICFESR_CERR_MASK            BIT(0)
 473 #define MEMERR_CPU_LSUESR_PAGE_OFFSET           0x000c
 474 #define  MEMERR_CPU_LSUESR_ERRWAY_RD(src)       (((src) & 0xFF000000) >> 24)
 475 #define  MEMERR_CPU_LSUESR_ERRINDEX_RD(src)     (((src) & 0x003F0000) >> 16)
 476 #define  MEMERR_CPU_LSUESR_ERRINFO_RD(src)      (((src) & 0x0000FF00) >> 8)
 477 #define  MEMERR_CPU_LSUESR_ERRTYPE_RD(src)      (((src) & 0x00000070) >> 4)
 478 #define  MEMERR_CPU_LSUESR_MULTCERR_MASK        BIT(2)
 479 #define  MEMERR_CPU_LSUESR_CERR_MASK            BIT(0)
 480 #define MEMERR_CPU_LSUECR_PAGE_OFFSET           0x0008
 481 #define MEMERR_CPU_MMUECR_PAGE_OFFSET           0x0010
 482 #define MEMERR_CPU_MMUESR_PAGE_OFFSET           0x0014
 483 #define  MEMERR_CPU_MMUESR_ERRWAY_RD(src)       (((src) & 0xFF000000) >> 24)
 484 #define  MEMERR_CPU_MMUESR_ERRINDEX_RD(src)     (((src) & 0x007F0000) >> 16)
 485 #define  MEMERR_CPU_MMUESR_ERRINFO_RD(src)      (((src) & 0x0000FF00) >> 8)
 486 #define  MEMERR_CPU_MMUESR_ERRREQSTR_LSU_MASK   BIT(7)
 487 #define  MEMERR_CPU_MMUESR_ERRTYPE_RD(src)      (((src) & 0x00000070) >> 4)
 488 #define  MEMERR_CPU_MMUESR_MULTCERR_MASK        BIT(2)
 489 #define  MEMERR_CPU_MMUESR_CERR_MASK            BIT(0)
 490 #define MEMERR_CPU_ICFESRA_PAGE_OFFSET          0x0804
 491 #define MEMERR_CPU_LSUESRA_PAGE_OFFSET          0x080c
 492 #define MEMERR_CPU_MMUESRA_PAGE_OFFSET          0x0814
 493
 494 #define MEMERR_L2C_L2ECR_PAGE_OFFSET            0x0000
 495 #define MEMERR_L2C_L2ESR_PAGE_OFFSET            0x0004
 496 #define  MEMERR_L2C_L2ESR_ERRSYN_RD(src)        (((src) & 0xFF000000) >> 24)
 497 #define  MEMERR_L2C_L2ESR_ERRWAY_RD(src)        (((src) & 0x00FC0000) >> 18)
 498 #define  MEMERR_L2C_L2ESR_ERRCPU_RD(src)        (((src) & 0x00020000) >> 17)
 499 #define  MEMERR_L2C_L2ESR_ERRGROUP_RD(src)      (((src) & 0x0000E000) >> 13)
 500 #define  MEMERR_L2C_L2ESR_ERRACTION_RD(src)     (((src) & 0x00001C00) >> 10)
 501 #define  MEMERR_L2C_L2ESR_ERRTYPE_RD(src)       (((src) & 0x00000300) >> 8)
 502 #define  MEMERR_L2C_L2ESR_MULTUCERR_MASK        BIT(3)
 503 #define  MEMERR_L2C_L2ESR_MULTICERR_MASK        BIT(2)
 504 #define  MEMERR_L2C_L2ESR_UCERR_MASK            BIT(1)
 505 #define  MEMERR_L2C_L2ESR_ERR_MASK              BIT(0)
 506 #define MEMERR_L2C_L2EALR_PAGE_OFFSET           0x0008
 507 #define CPUX_L2C_L2RTOCR_PAGE_OFFSET            0x0010
 508 #define MEMERR_L2C_L2EAHR_PAGE_OFFSET           0x000c
 509 #define CPUX_L2C_L2RTOSR_PAGE_OFFSET            0x0014
 510 #define  MEMERR_L2C_L2RTOSR_MULTERR_MASK        BIT(1)
 511 #define  MEMERR_L2C_L2RTOSR_ERR_MASK            BIT(0)
 512 #define CPUX_L2C_L2RTOALR_PAGE_OFFSET           0x0018
 513 #define CPUX_L2C_L2RTOAHR_PAGE_OFFSET           0x001c
 514 #define MEMERR_L2C_L2ESRA_PAGE_OFFSET           0x0804
 515
 516 /*
 517  * Processor Module Domain (PMD) context - Context for a pair of processsors.
 518  * Each PMD consists of 2 CPUs and a shared L2 cache. Each CPU consists of
 519  * its own L1 cache.
 520  */
 521 struct xgene_edac_pmd_ctx {
 522         struct list_head        next;
 523         struct device           ddev;
 524         char                    *name;
 525         struct xgene_edac       *edac;
 526         struct edac_device_ctl_info *edac_dev;
 527         void __iomem            *pmd_csr;
 528         u32                     pmd;
 529         int                     version;
 530 };
 531
 532 static void xgene_edac_pmd_l1_check(struct edac_device_ctl_info *edac_dev,
 533                                     int cpu_idx)
 534 {
 535         struct xgene_edac_pmd_ctx *ctx = edac_dev->pvt_info;
 536         void __iomem *pg_f;
 537         u32 val;
 538
 539         pg_f = ctx->pmd_csr + cpu_idx * CPU_CSR_STRIDE + CPU_MEMERR_CPU_PAGE;
 540
 541         val = readl(pg_f + MEMERR_CPU_ICFESR_PAGE_OFFSET);
 542         if (!val)
 543                 goto chk_lsu;
 544         dev_err(edac_dev->dev,
 545                 "CPU%d L1 memory error ICF 0x%08X Way 0x%02X Index 0x%02X Info 0x%02X\n",
 546                 ctx->pmd * MAX_CPU_PER_PMD + cpu_idx, val,
 547                 MEMERR_CPU_ICFESR_ERRWAY_RD(val),
 548                 MEMERR_CPU_ICFESR_ERRINDEX_RD(val),
 549                 MEMERR_CPU_ICFESR_ERRINFO_RD(val));
 550         if (val & MEMERR_CPU_ICFESR_CERR_MASK)
 551                 dev_err(edac_dev->dev, "One or more correctable error\n");
 552         if (val & MEMERR_CPU_ICFESR_MULTCERR_MASK)
 553                 dev_err(edac_dev->dev, "Multiple correctable error\n");
 554         switch (MEMERR_CPU_ICFESR_ERRTYPE_RD(val)) {
 555         case 1:
 556                 dev_err(edac_dev->dev, "L1 TLB multiple hit\n");
 557                 break;
 558         case 2:
 559                 dev_err(edac_dev->dev, "Way select multiple hit\n");
 560                 break;
 561         case 3:
 562                 dev_err(edac_dev->dev, "Physical tag parity error\n");
 563                 break;
 564         case 4:
 565         case 5:
 566                 dev_err(edac_dev->dev, "L1 data parity error\n");
 567                 break;
 568         case 6:
 569                 dev_err(edac_dev->dev, "L1 pre-decode parity error\n");
 570                 break;
 571         }
 572
 573         /* Clear any HW errors */
 574         writel(val, pg_f + MEMERR_CPU_ICFESR_PAGE_OFFSET);
 575
 576         if (val & (MEMERR_CPU_ICFESR_CERR_MASK |
 577                    MEMERR_CPU_ICFESR_MULTCERR_MASK))
 578                 edac_device_handle_ce(edac_dev, 0, 0, edac_dev->ctl_name);
 579
 580 chk_lsu:
 581         val = readl(pg_f + MEMERR_CPU_LSUESR_PAGE_OFFSET);
 582         if (!val)
 583                 goto chk_mmu;
 584         dev_err(edac_dev->dev,
 585                 "CPU%d memory error LSU 0x%08X Way 0x%02X Index 0x%02X Info 0x%02X\n",
 586                 ctx->pmd * MAX_CPU_PER_PMD + cpu_idx, val,
 587                 MEMERR_CPU_LSUESR_ERRWAY_RD(val),
 588                 MEMERR_CPU_LSUESR_ERRINDEX_RD(val),
 589                 MEMERR_CPU_LSUESR_ERRINFO_RD(val));
 590         if (val & MEMERR_CPU_LSUESR_CERR_MASK)
 591                 dev_err(edac_dev->dev, "One or more correctable error\n");
 592         if (val & MEMERR_CPU_LSUESR_MULTCERR_MASK)
 593                 dev_err(edac_dev->dev, "Multiple correctable error\n");
 594         switch (MEMERR_CPU_LSUESR_ERRTYPE_RD(val)) {
 595         case 0:
 596                 dev_err(edac_dev->dev, "Load tag error\n");
 597                 break;
 598         case 1:
 599                 dev_err(edac_dev->dev, "Load data error\n");
 600                 break;
 601         case 2:
 602                 dev_err(edac_dev->dev, "WSL multihit error\n");
 603                 break;
 604         case 3:
 605                 dev_err(edac_dev->dev, "Store tag error\n");
 606                 break;
 607         case 4:
 608                 dev_err(edac_dev->dev,
 609                         "DTB multihit from load pipeline error\n");
 610                 break;
 611         case 5:
 612                 dev_err(edac_dev->dev,
 613                         "DTB multihit from store pipeline error\n");
 614                 break;
 615         }
 616
 617         /* Clear any HW errors */
 618         writel(val, pg_f + MEMERR_CPU_LSUESR_PAGE_OFFSET);
 619
 620         if (val & (MEMERR_CPU_LSUESR_CERR_MASK |
 621                    MEMERR_CPU_LSUESR_MULTCERR_MASK))
 622                 edac_device_handle_ce(edac_dev, 0, 0, edac_dev->ctl_name);
 623
 624 chk_mmu:
 625         val = readl(pg_f + MEMERR_CPU_MMUESR_PAGE_OFFSET);
 626         if (!val)
 627                 return;
 628         dev_err(edac_dev->dev,
 629                 "CPU%d memory error MMU 0x%08X Way 0x%02X Index 0x%02X Info 0x%02X %s\n",
 630                 ctx->pmd * MAX_CPU_PER_PMD + cpu_idx, val,
 631                 MEMERR_CPU_MMUESR_ERRWAY_RD(val),
 632                 MEMERR_CPU_MMUESR_ERRINDEX_RD(val),
 633                 MEMERR_CPU_MMUESR_ERRINFO_RD(val),
 634                 val & MEMERR_CPU_MMUESR_ERRREQSTR_LSU_MASK ? "LSU" : "ICF");
 635         if (val & MEMERR_CPU_MMUESR_CERR_MASK)
 636                 dev_err(edac_dev->dev, "One or more correctable error\n");
 637         if (val & MEMERR_CPU_MMUESR_MULTCERR_MASK)
 638                 dev_err(edac_dev->dev, "Multiple correctable error\n");
 639         switch (MEMERR_CPU_MMUESR_ERRTYPE_RD(val)) {
 640         case 0:
 641                 dev_err(edac_dev->dev, "Stage 1 UTB hit error\n");
 642                 break;
 643         case 1:
 644                 dev_err(edac_dev->dev, "Stage 1 UTB miss error\n");
 645                 break;
 646         case 2:
 647                 dev_err(edac_dev->dev, "Stage 1 UTB allocate error\n");
 648                 break;
 649         case 3:
 650                 dev_err(edac_dev->dev, "TMO operation single bank error\n");
 651                 break;
 652         case 4:
 653                 dev_err(edac_dev->dev, "Stage 2 UTB error\n");
 654                 break;
 655         case 5:
 656                 dev_err(edac_dev->dev, "Stage 2 UTB miss error\n");
 657                 break;
 658         case 6:
 659                 dev_err(edac_dev->dev, "Stage 2 UTB allocate error\n");
 660                 break;
 661         case 7:
 662                 dev_err(edac_dev->dev, "TMO operation multiple bank error\n");
 663                 break;
 664         }
 665
 666         /* Clear any HW errors */
 667         writel(val, pg_f + MEMERR_CPU_MMUESR_PAGE_OFFSET);
 668
 669         edac_device_handle_ce(edac_dev, 0, 0, edac_dev->ctl_name);
 670 }
 671
 672 static void xgene_edac_pmd_l2_check(struct edac_device_ctl_info *edac_dev)
 673 {
 674         struct xgene_edac_pmd_ctx *ctx = edac_dev->pvt_info;
 675         void __iomem *pg_d;
 676         void __iomem *pg_e;
 677         u32 val_hi;
 678         u32 val_lo;
 679         u32 val;
 680
 681         /* Check L2 */
 682         pg_e = ctx->pmd_csr + CPU_MEMERR_L2C_PAGE;
 683         val = readl(pg_e + MEMERR_L2C_L2ESR_PAGE_OFFSET);
 684         if (!val)
 685                 goto chk_l2c;
 686         val_lo = readl(pg_e + MEMERR_L2C_L2EALR_PAGE_OFFSET);
 687         val_hi = readl(pg_e + MEMERR_L2C_L2EAHR_PAGE_OFFSET);
 688         dev_err(edac_dev->dev,
 689                 "PMD%d memory error L2C L2ESR 0x%08X @ 0x%08X.%08X\n",
 690                 ctx->pmd, val, val_hi, val_lo);
 691         dev_err(edac_dev->dev,
 692                 "ErrSyndrome 0x%02X ErrWay 0x%02X ErrCpu %d ErrGroup 0x%02X ErrAction 0x%02X\n",
 693                 MEMERR_L2C_L2ESR_ERRSYN_RD(val),
 694                 MEMERR_L2C_L2ESR_ERRWAY_RD(val),
 695                 MEMERR_L2C_L2ESR_ERRCPU_RD(val),
 696                 MEMERR_L2C_L2ESR_ERRGROUP_RD(val),
 697                 MEMERR_L2C_L2ESR_ERRACTION_RD(val));
 698
 699         if (val & MEMERR_L2C_L2ESR_ERR_MASK)
 700                 dev_err(edac_dev->dev, "One or more correctable error\n");
 701         if (val & MEMERR_L2C_L2ESR_MULTICERR_MASK)
 702                 dev_err(edac_dev->dev, "Multiple correctable error\n");
 703         if (val & MEMERR_L2C_L2ESR_UCERR_MASK)
 704                 dev_err(edac_dev->dev, "One or more uncorrectable error\n");
 705         if (val & MEMERR_L2C_L2ESR_MULTUCERR_MASK)
 706                 dev_err(edac_dev->dev, "Multiple uncorrectable error\n");
 707
 708         switch (MEMERR_L2C_L2ESR_ERRTYPE_RD(val)) {
 709         case 0:
 710                 dev_err(edac_dev->dev, "Outbound SDB parity error\n");
 711                 break;
 712         case 1:
 713                 dev_err(edac_dev->dev, "Inbound SDB parity error\n");
 714                 break;
 715         case 2:
 716                 dev_err(edac_dev->dev, "Tag ECC error\n");
 717                 break;
 718         case 3:
 719                 dev_err(edac_dev->dev, "Data ECC error\n");
 720                 break;
 721         }
 722
 723         /* Clear any HW errors */
 724         writel(val, pg_e + MEMERR_L2C_L2ESR_PAGE_OFFSET);
 725
 726         if (val & (MEMERR_L2C_L2ESR_ERR_MASK |
 727                    MEMERR_L2C_L2ESR_MULTICERR_MASK))
 728                 edac_device_handle_ce(edac_dev, 0, 0, edac_dev->ctl_name);
 729         if (val & (MEMERR_L2C_L2ESR_UCERR_MASK |
 730                    MEMERR_L2C_L2ESR_MULTUCERR_MASK))
 731                 edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name);
 732
 733 chk_l2c:
 734         /* Check if any memory request timed out on L2 cache */
 735         pg_d = ctx->pmd_csr + CPU_L2C_PAGE;
 736         val = readl(pg_d + CPUX_L2C_L2RTOSR_PAGE_OFFSET);
 737         if (val) {
 738                 val_lo = readl(pg_d + CPUX_L2C_L2RTOALR_PAGE_OFFSET);
 739                 val_hi = readl(pg_d + CPUX_L2C_L2RTOAHR_PAGE_OFFSET);
 740                 dev_err(edac_dev->dev,
 741                         "PMD%d L2C error L2C RTOSR 0x%08X @ 0x%08X.%08X\n",
 742                         ctx->pmd, val, val_hi, val_lo);
 743                 writel(val, pg_d + CPUX_L2C_L2RTOSR_PAGE_OFFSET);
 744         }
 745 }
 746
 747 static void xgene_edac_pmd_check(struct edac_device_ctl_info *edac_dev)
 748 {
 749         struct xgene_edac_pmd_ctx *ctx = edac_dev->pvt_info;
 750         unsigned int pcp_hp_stat;
 751         int i;
 752
 753         xgene_edac_pcp_rd(ctx->edac, PCPHPERRINTSTS, &pcp_hp_stat);
 754         if (!((PMD0_MERR_MASK << ctx->pmd) & pcp_hp_stat))
 755                 return;
 756
 757         /* Check CPU L1 error */
 758         for (i = 0; i < MAX_CPU_PER_PMD; i++)
 759                 xgene_edac_pmd_l1_check(edac_dev, i);
 760
 761         /* Check CPU L2 error */
 762         xgene_edac_pmd_l2_check(edac_dev);
 763 }
 764
 765 static void xgene_edac_pmd_cpu_hw_cfg(struct edac_device_ctl_info *edac_dev,
 766                                       int cpu)
 767 {
 768         struct xgene_edac_pmd_ctx *ctx = edac_dev->pvt_info;
 769         void __iomem *pg_f = ctx->pmd_csr + cpu * CPU_CSR_STRIDE +
 770                              CPU_MEMERR_CPU_PAGE;
 771
 772         /*
 773          * Enable CPU memory error:
 774          *  MEMERR_CPU_ICFESRA, MEMERR_CPU_LSUESRA, and MEMERR_CPU_MMUESRA
 775          */
 776         writel(0x00000301, pg_f + MEMERR_CPU_ICFECR_PAGE_OFFSET);
 777         writel(0x00000301, pg_f + MEMERR_CPU_LSUECR_PAGE_OFFSET);
 778         writel(0x00000101, pg_f + MEMERR_CPU_MMUECR_PAGE_OFFSET);
 779 }
 780
 781 static void xgene_edac_pmd_hw_cfg(struct edac_device_ctl_info *edac_dev)
 782 {
 783         struct xgene_edac_pmd_ctx *ctx = edac_dev->pvt_info;
 784         void __iomem *pg_d = ctx->pmd_csr + CPU_L2C_PAGE;
 785         void __iomem *pg_e = ctx->pmd_csr + CPU_MEMERR_L2C_PAGE;
 786
 787         /* Enable PMD memory error - MEMERR_L2C_L2ECR and L2C_L2RTOCR */
 788         writel(0x00000703, pg_e + MEMERR_L2C_L2ECR_PAGE_OFFSET);
 789         /* Configure L2C HW request time out feature if supported */
 790         if (ctx->version > 1)
 791                 writel(0x00000119, pg_d + CPUX_L2C_L2RTOCR_PAGE_OFFSET);
 792 }
 793
 794 static void xgene_edac_pmd_hw_ctl(struct edac_device_ctl_info *edac_dev,
 795                                   bool enable)
 796 {
 797         struct xgene_edac_pmd_ctx *ctx = edac_dev->pvt_info;
 798         int i;
 799
 800         /* Enable PMD error interrupt */
 801         if (edac_dev->op_state == OP_RUNNING_INTERRUPT) {
 802                 if (enable)
 803                         xgene_edac_pcp_clrbits(ctx->edac, PCPHPERRINTMSK,
 804                                                PMD0_MERR_MASK << ctx->pmd);
 805                 else
 806                         xgene_edac_pcp_setbits(ctx->edac, PCPHPERRINTMSK,
 807                                                PMD0_MERR_MASK << ctx->pmd);
 808         }
 809
 810         if (enable) {
 811                 xgene_edac_pmd_hw_cfg(edac_dev);
 812
 813                 /* Two CPUs per a PMD */
 814                 for (i = 0; i < MAX_CPU_PER_PMD; i++)
 815                         xgene_edac_pmd_cpu_hw_cfg(edac_dev, i);
 816         }
 817 }
 818
 819 static ssize_t xgene_edac_pmd_l1_inject_ctrl_write(struct file *file,
 820                                                    const char __user *data,
 821                                                    size_t count, loff_t *ppos)
 822 {
 823         struct edac_device_ctl_info *edac_dev = file->private_data;
 824         struct xgene_edac_pmd_ctx *ctx = edac_dev->pvt_info;
 825         void __iomem *cpux_pg_f;
 826         int i;
 827
 828         for (i = 0; i < MAX_CPU_PER_PMD; i++) {
 829                 cpux_pg_f = ctx->pmd_csr + i * CPU_CSR_STRIDE +
 830                             CPU_MEMERR_CPU_PAGE;
 831
 832                 writel(MEMERR_CPU_ICFESR_MULTCERR_MASK |
 833                        MEMERR_CPU_ICFESR_CERR_MASK,
 834                        cpux_pg_f + MEMERR_CPU_ICFESRA_PAGE_OFFSET);
 835                 writel(MEMERR_CPU_LSUESR_MULTCERR_MASK |
 836                        MEMERR_CPU_LSUESR_CERR_MASK,
 837                        cpux_pg_f + MEMERR_CPU_LSUESRA_PAGE_OFFSET);
 838                 writel(MEMERR_CPU_MMUESR_MULTCERR_MASK |
 839                        MEMERR_CPU_MMUESR_CERR_MASK,
 840                        cpux_pg_f + MEMERR_CPU_MMUESRA_PAGE_OFFSET);
 841         }
 842         return count;
 843 }
 844
 845 static ssize_t xgene_edac_pmd_l2_inject_ctrl_write(struct file *file,
 846                                                    const char __user *data,
 847                                                    size_t count, loff_t *ppos)
 848 {
 849         struct edac_device_ctl_info *edac_dev = file->private_data;
 850         struct xgene_edac_pmd_ctx *ctx = edac_dev->pvt_info;
 851         void __iomem *pg_e = ctx->pmd_csr + CPU_MEMERR_L2C_PAGE;
 852
 853         writel(MEMERR_L2C_L2ESR_MULTUCERR_MASK |
 854                MEMERR_L2C_L2ESR_MULTICERR_MASK |
 855                MEMERR_L2C_L2ESR_UCERR_MASK |
 856                MEMERR_L2C_L2ESR_ERR_MASK,
 857                pg_e + MEMERR_L2C_L2ESRA_PAGE_OFFSET);
 858         return count;
 859 }
 860
 861 static const struct file_operations xgene_edac_pmd_debug_inject_fops[] = {
 862         {
 863         .open = simple_open,
 864         .write = xgene_edac_pmd_l1_inject_ctrl_write,
 865         .llseek = generic_file_llseek, },
 866         {
 867         .open = simple_open,
 868         .write = xgene_edac_pmd_l2_inject_ctrl_write,
 869         .llseek = generic_file_llseek, },
 870         { }
 871 };
 872
 873 static void
 874 xgene_edac_pmd_create_debugfs_nodes(struct edac_device_ctl_info *edac_dev)
 875 {
 876         struct xgene_edac_pmd_ctx *ctx = edac_dev->pvt_info;
 877         struct dentry *dbgfs_dir;
 878         char name[10];
 879
 880         if (!IS_ENABLED(CONFIG_EDAC_DEBUG) || !ctx->edac->dfs)
 881                 return;
 882
 883         snprintf(name, sizeof(name), "PMD%d", ctx->pmd);
 884         dbgfs_dir = edac_debugfs_create_dir_at(name, ctx->edac->dfs);
 885         if (!dbgfs_dir)
 886                 return;
 887
 888         edac_debugfs_create_file("l1_inject_ctrl", S_IWUSR, dbgfs_dir, edac_dev,
 889                                  &xgene_edac_pmd_debug_inject_fops[0]);
 890         edac_debugfs_create_file("l2_inject_ctrl", S_IWUSR, dbgfs_dir, edac_dev,
 891                                  &xgene_edac_pmd_debug_inject_fops[1]);
 892 }
 893
 894 static int xgene_edac_pmd_available(u32 efuse, int pmd)
 895 {
 896         return (efuse & (1 << pmd)) ? 0 : 1;
 897 }
 898
 899 static int xgene_edac_pmd_add(struct xgene_edac *edac, struct device_node *np,
 900                               int version)
 901 {
 902         struct edac_device_ctl_info *edac_dev;
 903         struct xgene_edac_pmd_ctx *ctx;
 904         struct resource res;
 905         char edac_name[10];
 906         u32 pmd;
 907         int rc;
 908         u32 val;
 909
 910         if (!devres_open_group(edac->dev, xgene_edac_pmd_add, GFP_KERNEL))
 911                 return -ENOMEM;
 912
 913         /* Determine if this PMD is disabled */
 914         if (of_property_read_u32(np, "pmd-controller", &pmd)) {
 915                 dev_err(edac->dev, "no pmd-controller property\n");
 916                 rc = -ENODEV;
 917                 goto err_group;
 918         }
 919         rc = regmap_read(edac->efuse_map, 0, &val);
 920         if (rc)
 921                 goto err_group;
 922         if (!xgene_edac_pmd_available(val, pmd)) {
 923                 rc = -ENODEV;
 924                 goto err_group;
 925         }
 926
 927         snprintf(edac_name, sizeof(edac_name), "l2c%d", pmd);
 928         edac_dev = edac_device_alloc_ctl_info(sizeof(*ctx),
 929                                               edac_name, 1, "l2c", 1, 2, NULL,
 930                                               0, edac_device_alloc_index());
 931         if (!edac_dev) {
 932                 rc = -ENOMEM;
 933                 goto err_group;
 934         }
 935
 936         ctx = edac_dev->pvt_info;
 937         ctx->name = "xgene_pmd_err";
 938         ctx->pmd = pmd;
 939         ctx->edac = edac;
 940         ctx->edac_dev = edac_dev;
 941         ctx->ddev = *edac->dev;
 942         ctx->version = version;
 943         edac_dev->dev = &ctx->ddev;
 944         edac_dev->ctl_name = ctx->name;
 945         edac_dev->dev_name = ctx->name;
 946         edac_dev->mod_name = EDAC_MOD_STR;
 947
 948         rc = of_address_to_resource(np, 0, &res);
 949         if (rc < 0) {
 950                 dev_err(edac->dev, "no PMD resource address\n");
 951                 goto err_free;
 952         }
 953         ctx->pmd_csr = devm_ioremap_resource(edac->dev, &res);
 954         if (IS_ERR(ctx->pmd_csr)) {
 955                 dev_err(edac->dev,
 956                         "devm_ioremap_resource failed for PMD resource address\n");
 957                 rc = PTR_ERR(ctx->pmd_csr);
 958                 goto err_free;
 959         }
 960
 961         if (edac_op_state == EDAC_OPSTATE_POLL)
 962                 edac_dev->edac_check = xgene_edac_pmd_check;
 963
 964         xgene_edac_pmd_create_debugfs_nodes(edac_dev);
 965
 966         rc = edac_device_add_device(edac_dev);
 967         if (rc > 0) {
 968                 dev_err(edac->dev, "edac_device_add_device failed\n");
 969                 rc = -ENOMEM;
 970                 goto err_free;
 971         }
 972
 973         if (edac_op_state == EDAC_OPSTATE_INT)
 974                 edac_dev->op_state = OP_RUNNING_INTERRUPT;
 975
 976         list_add(&ctx->next, &edac->pmds);
 977
 978         xgene_edac_pmd_hw_ctl(edac_dev, 1);
 979
 980         devres_remove_group(edac->dev, xgene_edac_pmd_add);
 981
 982         dev_info(edac->dev, "X-Gene EDAC PMD%d registered\n", ctx->pmd);
 983         return 0;
 984
 985 err_free:
 986         edac_device_free_ctl_info(edac_dev);
 987 err_group:
 988         devres_release_group(edac->dev, xgene_edac_pmd_add);
 989         return rc;
 990 }
 991
 992 static int xgene_edac_pmd_remove(struct xgene_edac_pmd_ctx *pmd)
 993 {
 994         struct edac_device_ctl_info *edac_dev = pmd->edac_dev;
 995
 996         xgene_edac_pmd_hw_ctl(edac_dev, 0);
 997         edac_device_del_device(edac_dev->dev);
 998         edac_device_free_ctl_info(edac_dev);
 999         return 0;
1000 }
1001
1002 /* L3 Error device */
1003 #define L3C_ESR                         (0x0A * 4)
1004 #define  L3C_ESR_DATATAG_MASK           BIT(9)
1005 #define  L3C_ESR_MULTIHIT_MASK          BIT(8)
1006 #define  L3C_ESR_UCEVICT_MASK           BIT(6)
1007 #define  L3C_ESR_MULTIUCERR_MASK        BIT(5)
1008 #define  L3C_ESR_MULTICERR_MASK         BIT(4)
1009 #define  L3C_ESR_UCERR_MASK             BIT(3)
1010 #define  L3C_ESR_CERR_MASK              BIT(2)
1011 #define  L3C_ESR_UCERRINTR_MASK         BIT(1)
1012 #define  L3C_ESR_CERRINTR_MASK          BIT(0)
1013 #define L3C_ECR                         (0x0B * 4)
1014 #define  L3C_ECR_UCINTREN               BIT(3)
1015 #define  L3C_ECR_CINTREN                BIT(2)
1016 #define  L3C_UCERREN                    BIT(1)
1017 #define  L3C_CERREN                     BIT(0)
1018 #define L3C_ELR                         (0x0C * 4)
1019 #define  L3C_ELR_ERRSYN(src)            ((src & 0xFF800000) >> 23)
1020 #define  L3C_ELR_ERRWAY(src)            ((src & 0x007E0000) >> 17)
1021 #define  L3C_ELR_AGENTID(src)           ((src & 0x0001E000) >> 13)
1022 #define  L3C_ELR_ERRGRP(src)            ((src & 0x00000F00) >> 8)
1023 #define  L3C_ELR_OPTYPE(src)            ((src & 0x000000F0) >> 4)
1024 #define  L3C_ELR_PADDRHIGH(src)         (src & 0x0000000F)
1025 #define L3C_AELR                        (0x0D * 4)
1026 #define L3C_BELR                        (0x0E * 4)
1027 #define  L3C_BELR_BANK(src)             (src & 0x0000000F)
1028
1029 struct xgene_edac_dev_ctx {
1030         struct list_head        next;
1031         struct device           ddev;
1032         char                    *name;
1033         struct xgene_edac       *edac;
1034         struct edac_device_ctl_info *edac_dev;
1035         int                     edac_idx;
1036         void __iomem            *dev_csr;
1037         int                     version;
1038 };
1039
1040 /*
1041  * Version 1 of the L3 controller has broken single bit correctable logic for
1042  * certain error syndromes. Log them as uncorrectable in that case.
1043  */
1044 static bool xgene_edac_l3_promote_to_uc_err(u32 l3cesr, u32 l3celr)
1045 {
1046         if (l3cesr & L3C_ESR_DATATAG_MASK) {
1047                 switch (L3C_ELR_ERRSYN(l3celr)) {
1048                 case 0x13C:
1049                 case 0x0B4:
1050                 case 0x007:
1051                 case 0x00D:
1052                 case 0x00E:
1053                 case 0x019:
1054                 case 0x01A:
1055                 case 0x01C:
1056                 case 0x04E:
1057                 case 0x041:
1058                         return true;
1059                 }
1060         } else if (L3C_ELR_ERRSYN(l3celr) == 9)
1061                 return true;
1062
1063         return false;
1064 }
1065
1066 static void xgene_edac_l3_check(struct edac_device_ctl_info *edac_dev)
1067 {
1068         struct xgene_edac_dev_ctx *ctx = edac_dev->pvt_info;
1069         u32 l3cesr;
1070         u32 l3celr;
1071         u32 l3caelr;
1072         u32 l3cbelr;
1073
1074         l3cesr = readl(ctx->dev_csr + L3C_ESR);
1075         if (!(l3cesr & (L3C_ESR_UCERR_MASK | L3C_ESR_CERR_MASK)))
1076                 return;
1077
1078         if (l3cesr & L3C_ESR_UCERR_MASK)
1079                 dev_err(edac_dev->dev, "L3C uncorrectable error\n");
1080         if (l3cesr & L3C_ESR_CERR_MASK)
1081                 dev_warn(edac_dev->dev, "L3C correctable error\n");
1082
1083         l3celr = readl(ctx->dev_csr + L3C_ELR);
1084         l3caelr = readl(ctx->dev_csr + L3C_AELR);
1085         l3cbelr = readl(ctx->dev_csr + L3C_BELR);
1086         if (l3cesr & L3C_ESR_MULTIHIT_MASK)
1087                 dev_err(edac_dev->dev, "L3C multiple hit error\n");
1088         if (l3cesr & L3C_ESR_UCEVICT_MASK)
1089                 dev_err(edac_dev->dev,
1090                         "L3C dropped eviction of line with error\n");
1091         if (l3cesr & L3C_ESR_MULTIUCERR_MASK)
1092                 dev_err(edac_dev->dev, "L3C multiple uncorrectable error\n");
1093         if (l3cesr & L3C_ESR_DATATAG_MASK)
1094                 dev_err(edac_dev->dev,
1095                         "L3C data error syndrome 0x%X group 0x%X\n",
1096                         L3C_ELR_ERRSYN(l3celr), L3C_ELR_ERRGRP(l3celr));
1097         else
1098                 dev_err(edac_dev->dev,
1099                         "L3C tag error syndrome 0x%X Way of Tag 0x%X Agent ID 0x%X Operation type 0x%X\n",
1100                         L3C_ELR_ERRSYN(l3celr), L3C_ELR_ERRWAY(l3celr),
1101                         L3C_ELR_AGENTID(l3celr), L3C_ELR_OPTYPE(l3celr));
1102         /*
1103          * NOTE: Address [41:38] in L3C_ELR_PADDRHIGH(l3celr).
1104          *       Address [37:6] in l3caelr. Lower 6 bits are zero.
1105          */
1106         dev_err(edac_dev->dev, "L3C error address 0x%08X.%08X bank %d\n",
1107                 L3C_ELR_PADDRHIGH(l3celr) << 6 | (l3caelr >> 26),
1108                 (l3caelr & 0x3FFFFFFF) << 6, L3C_BELR_BANK(l3cbelr));
1109         dev_err(edac_dev->dev,
1110                 "L3C error status register value 0x%X\n", l3cesr);
1111
1112         /* Clear L3C error interrupt */
1113         writel(0, ctx->dev_csr + L3C_ESR);
1114
1115         if (ctx->version <= 1 &&
1116             xgene_edac_l3_promote_to_uc_err(l3cesr, l3celr)) {
1117                 edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name);
1118                 return;
1119         }
1120         if (l3cesr & L3C_ESR_CERR_MASK)
1121                 edac_device_handle_ce(edac_dev, 0, 0, edac_dev->ctl_name);
1122         if (l3cesr & L3C_ESR_UCERR_MASK)
1123                 edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name);
1124 }
1125
1126 static void xgene_edac_l3_hw_init(struct edac_device_ctl_info *edac_dev,
1127                                   bool enable)
1128 {
1129         struct xgene_edac_dev_ctx *ctx = edac_dev->pvt_info;
1130         u32 val;
1131
1132         val = readl(ctx->dev_csr + L3C_ECR);
1133         val |= L3C_UCERREN | L3C_CERREN;
1134         /* On disable, we just disable interrupt but keep error enabled */
1135         if (edac_dev->op_state == OP_RUNNING_INTERRUPT) {
1136                 if (enable)
1137                         val |= L3C_ECR_UCINTREN | L3C_ECR_CINTREN;
1138                 else
1139                         val &= ~(L3C_ECR_UCINTREN | L3C_ECR_CINTREN);
1140         }
1141         writel(val, ctx->dev_csr + L3C_ECR);
1142
1143         if (edac_dev->op_state == OP_RUNNING_INTERRUPT) {
1144                 /* Enable/disable L3 error top level interrupt */
1145                 if (enable) {
1146                         xgene_edac_pcp_clrbits(ctx->edac, PCPHPERRINTMSK,
1147                                                L3C_UNCORR_ERR_MASK);
1148                         xgene_edac_pcp_clrbits(ctx->edac, PCPLPERRINTMSK,
1149                                                L3C_CORR_ERR_MASK);
1150                 } else {
1151                         xgene_edac_pcp_setbits(ctx->edac, PCPHPERRINTMSK,
1152                                                L3C_UNCORR_ERR_MASK);
1153                         xgene_edac_pcp_setbits(ctx->edac, PCPLPERRINTMSK,
1154                                                L3C_CORR_ERR_MASK);
1155                 }
1156         }
1157 }
1158
1159 static ssize_t xgene_edac_l3_inject_ctrl_write(struct file *file,
1160                                                const char __user *data,
1161                                                size_t count, loff_t *ppos)
1162 {
1163         struct edac_device_ctl_info *edac_dev = file->private_data;
1164         struct xgene_edac_dev_ctx *ctx = edac_dev->pvt_info;
1165
1166         /* Generate all errors */
1167         writel(0xFFFFFFFF, ctx->dev_csr + L3C_ESR);
1168         return count;
1169 }
1170
1171 static const struct file_operations xgene_edac_l3_debug_inject_fops = {
1172         .open = simple_open,
1173         .write = xgene_edac_l3_inject_ctrl_write,
1174         .llseek = generic_file_llseek
1175 };
1176
1177 static void
1178 xgene_edac_l3_create_debugfs_nodes(struct edac_device_ctl_info *edac_dev)
1179 {
1180         struct xgene_edac_dev_ctx *ctx = edac_dev->pvt_info;
1181         struct dentry *dbgfs_dir;
1182         char name[10];
1183
1184         if (!IS_ENABLED(CONFIG_EDAC_DEBUG) || !ctx->edac->dfs)
1185                 return;
1186
1187         snprintf(name, sizeof(name), "l3c%d", ctx->edac_idx);
1188         dbgfs_dir = edac_debugfs_create_dir_at(name, ctx->edac->dfs);
1189         if (!dbgfs_dir)
1190                 return;
1191
1192         debugfs_create_file("l3_inject_ctrl", S_IWUSR, dbgfs_dir, edac_dev,
1193                             &xgene_edac_l3_debug_inject_fops);
1194 }
1195
1196 static int xgene_edac_l3_add(struct xgene_edac *edac, struct device_node *np,
1197                              int version)
1198 {
1199         struct edac_device_ctl_info *edac_dev;
1200         struct xgene_edac_dev_ctx *ctx;
1201         struct resource res;
1202         void __iomem *dev_csr;
1203         int edac_idx;
1204         int rc = 0;
1205
1206         if (!devres_open_group(edac->dev, xgene_edac_l3_add, GFP_KERNEL))
1207                 return -ENOMEM;
1208
1209         rc = of_address_to_resource(np, 0, &res);
1210         if (rc < 0) {
1211                 dev_err(edac->dev, "no L3 resource address\n");
1212                 goto err_release_group;
1213         }
1214         dev_csr = devm_ioremap_resource(edac->dev, &res);
1215         if (IS_ERR(dev_csr)) {
1216                 dev_err(edac->dev,
1217                         "devm_ioremap_resource failed for L3 resource address\n");
1218                 rc = PTR_ERR(dev_csr);
1219                 goto err_release_group;
1220         }
1221
1222         edac_idx = edac_device_alloc_index();
1223         edac_dev = edac_device_alloc_ctl_info(sizeof(*ctx),
1224                                               "l3c", 1, "l3c", 1, 0, NULL, 0,
1225                                               edac_idx);
1226         if (!edac_dev) {
1227                 rc = -ENOMEM;
1228                 goto err_release_group;
1229         }
1230
1231         ctx = edac_dev->pvt_info;
1232         ctx->dev_csr = dev_csr;
1233         ctx->name = "xgene_l3_err";
1234         ctx->edac_idx = edac_idx;
1235         ctx->edac = edac;
1236         ctx->edac_dev = edac_dev;
1237         ctx->ddev = *edac->dev;
1238         ctx->version = version;
1239         edac_dev->dev = &ctx->ddev;
1240         edac_dev->ctl_name = ctx->name;
1241         edac_dev->dev_name = ctx->name;
1242         edac_dev->mod_name = EDAC_MOD_STR;
1243
1244         if (edac_op_state == EDAC_OPSTATE_POLL)
1245                 edac_dev->edac_check = xgene_edac_l3_check;
1246
1247         xgene_edac_l3_create_debugfs_nodes(edac_dev);
1248
1249         rc = edac_device_add_device(edac_dev);
1250         if (rc > 0) {
1251                 dev_err(edac->dev, "failed edac_device_add_device()\n");
1252                 rc = -ENOMEM;
1253                 goto err_ctl_free;
1254         }
1255
1256         if (edac_op_state == EDAC_OPSTATE_INT)
1257                 edac_dev->op_state = OP_RUNNING_INTERRUPT;
1258
1259         list_add(&ctx->next, &edac->l3s);
1260
1261         xgene_edac_l3_hw_init(edac_dev, 1);
1262
1263         devres_remove_group(edac->dev, xgene_edac_l3_add);
1264
1265         dev_info(edac->dev, "X-Gene EDAC L3 registered\n");
1266         return 0;
1267
1268 err_ctl_free:
1269         edac_device_free_ctl_info(edac_dev);
1270 err_release_group:
1271         devres_release_group(edac->dev, xgene_edac_l3_add);
1272         return rc;
1273 }
1274
1275 static int xgene_edac_l3_remove(struct xgene_edac_dev_ctx *l3)
1276 {
1277         struct edac_device_ctl_info *edac_dev = l3->edac_dev;
1278
1279         xgene_edac_l3_hw_init(edac_dev, 0);
1280         edac_device_del_device(l3->edac->dev);
1281         edac_device_free_ctl_info(edac_dev);
1282         return 0;
1283 }
1284
1285 /* SoC error device */
1286 #define IOBAXIS0TRANSERRINTSTS          0x0000
1287 #define  IOBAXIS0_M_ILLEGAL_ACCESS_MASK BIT(1)
1288 #define  IOBAXIS0_ILLEGAL_ACCESS_MASK   BIT(0)
1289 #define IOBAXIS0TRANSERRINTMSK          0x0004
1290 #define IOBAXIS0TRANSERRREQINFOL        0x0008
1291 #define IOBAXIS0TRANSERRREQINFOH        0x000c
1292 #define  REQTYPE_RD(src)                (((src) & BIT(0)))
1293 #define  ERRADDRH_RD(src)               (((src) & 0xffc00000) >> 22)
1294 #define IOBAXIS1TRANSERRINTSTS          0x0010
1295 #define IOBAXIS1TRANSERRINTMSK          0x0014
1296 #define IOBAXIS1TRANSERRREQINFOL        0x0018
1297 #define IOBAXIS1TRANSERRREQINFOH        0x001c
1298 #define IOBPATRANSERRINTSTS             0x0020
1299 #define  IOBPA_M_REQIDRAM_CORRUPT_MASK  BIT(7)
1300 #define  IOBPA_REQIDRAM_CORRUPT_MASK    BIT(6)
1301 #define  IOBPA_M_TRANS_CORRUPT_MASK     BIT(5)
1302 #define  IOBPA_TRANS_CORRUPT_MASK       BIT(4)
1303 #define  IOBPA_M_WDATA_CORRUPT_MASK     BIT(3)
1304 #define  IOBPA_WDATA_CORRUPT_MASK       BIT(2)
1305 #define  IOBPA_M_RDATA_CORRUPT_MASK     BIT(1)
1306 #define  IOBPA_RDATA_CORRUPT_MASK       BIT(0)
1307 #define IOBBATRANSERRINTSTS             0x0030
1308 #define  M_ILLEGAL_ACCESS_MASK          BIT(15)
1309 #define  ILLEGAL_ACCESS_MASK            BIT(14)
1310 #define  M_WIDRAM_CORRUPT_MASK          BIT(13)
1311 #define  WIDRAM_CORRUPT_MASK            BIT(12)
1312 #define  M_RIDRAM_CORRUPT_MASK          BIT(11)
1313 #define  RIDRAM_CORRUPT_MASK            BIT(10)
1314 #define  M_TRANS_CORRUPT_MASK           BIT(9)
1315 #define  TRANS_CORRUPT_MASK             BIT(8)
1316 #define  M_WDATA_CORRUPT_MASK           BIT(7)
1317 #define  WDATA_CORRUPT_MASK             BIT(6)
1318 #define  M_RBM_POISONED_REQ_MASK        BIT(5)
1319 #define  RBM_POISONED_REQ_MASK          BIT(4)
1320 #define  M_XGIC_POISONED_REQ_MASK       BIT(3)
1321 #define  XGIC_POISONED_REQ_MASK         BIT(2)
1322 #define  M_WRERR_RESP_MASK              BIT(1)
1323 #define  WRERR_RESP_MASK                BIT(0)
1324 #define IOBBATRANSERRREQINFOL           0x0038
1325 #define IOBBATRANSERRREQINFOH           0x003c
1326 #define  REQTYPE_F2_RD(src)             ((src) & BIT(0))
1327 #define  ERRADDRH_F2_RD(src)            (((src) & 0xffc00000) >> 22)
1328 #define IOBBATRANSERRCSWREQID           0x0040
1329 #define XGICTRANSERRINTSTS              0x0050
1330 #define  M_WR_ACCESS_ERR_MASK           BIT(3)
1331 #define  WR_ACCESS_ERR_MASK             BIT(2)
1332 #define  M_RD_ACCESS_ERR_MASK           BIT(1)
1333 #define  RD_ACCESS_ERR_MASK             BIT(0)
1334 #define XGICTRANSERRINTMSK              0x0054
1335 #define XGICTRANSERRREQINFO             0x0058
1336 #define  REQTYPE_MASK                   BIT(26)
1337 #define  ERRADDR_RD(src)                ((src) & 0x03ffffff)
1338 #define GLBL_ERR_STS                    0x0800
1339 #define  MDED_ERR_MASK                  BIT(3)
1340 #define  DED_ERR_MASK                   BIT(2)
1341 #define  MSEC_ERR_MASK                  BIT(1)
1342 #define  SEC_ERR_MASK                   BIT(0)
1343 #define GLBL_SEC_ERRL                   0x0810
1344 #define GLBL_SEC_ERRH                   0x0818
1345 #define GLBL_MSEC_ERRL                  0x0820
1346 #define GLBL_MSEC_ERRH                  0x0828
1347 #define GLBL_DED_ERRL                   0x0830
1348 #define GLBL_DED_ERRLMASK               0x0834
1349 #define GLBL_DED_ERRH                   0x0838
1350 #define GLBL_DED_ERRHMASK               0x083c
1351 #define GLBL_MDED_ERRL                  0x0840
1352 #define GLBL_MDED_ERRLMASK              0x0844
1353 #define GLBL_MDED_ERRH                  0x0848
1354 #define GLBL_MDED_ERRHMASK              0x084c
1355
1356 static const char * const soc_mem_err_v1[] = {
1357         "10GbE0",
1358         "10GbE1",
1359         "Security",
1360         "SATA45",
1361         "SATA23/ETH23",
1362         "SATA01/ETH01",
1363         "USB1",
1364         "USB0",
1365         "QML",
1366         "QM0",
1367         "QM1 (XGbE01)",
1368         "PCIE4",
1369         "PCIE3",
1370         "PCIE2",
1371         "PCIE1",
1372         "PCIE0",
1373         "CTX Manager",
1374         "OCM",
1375         "1GbE",
1376         "CLE",
1377         "AHBC",
1378         "PktDMA",
1379         "GFC",
1380         "MSLIM",
1381         "10GbE2",
1382         "10GbE3",
1383         "QM2 (XGbE23)",
1384         "IOB",
1385         "unknown",
1386         "unknown",
1387         "unknown",
1388         "unknown",
1389 };
1390
1391 static void xgene_edac_iob_gic_report(struct edac_device_ctl_info *edac_dev)
1392 {
1393         struct xgene_edac_dev_ctx *ctx = edac_dev->pvt_info;
1394         u32 err_addr_lo;
1395         u32 err_addr_hi;
1396         u32 reg;
1397         u32 info;
1398
1399         /* GIC transaction error interrupt */
1400         reg = readl(ctx->dev_csr + XGICTRANSERRINTSTS);
1401         if (!reg)
1402                 goto chk_iob_err;
1403         dev_err(edac_dev->dev, "XGIC transaction error\n");
1404         if (reg & RD_ACCESS_ERR_MASK)
1405                 dev_err(edac_dev->dev, "XGIC read size error\n");
1406         if (reg & M_RD_ACCESS_ERR_MASK)
1407                 dev_err(edac_dev->dev, "Multiple XGIC read size error\n");
1408         if (reg & WR_ACCESS_ERR_MASK)
1409                 dev_err(edac_dev->dev, "XGIC write size error\n");
1410         if (reg & M_WR_ACCESS_ERR_MASK)
1411                 dev_err(edac_dev->dev, "Multiple XGIC write size error\n");
1412         info = readl(ctx->dev_csr + XGICTRANSERRREQINFO);
1413         dev_err(edac_dev->dev, "XGIC %s access @ 0x%08X (0x%08X)\n",
1414                 info & REQTYPE_MASK ? "read" : "write", ERRADDR_RD(info),
1415                 info);
1416         writel(reg, ctx->dev_csr + XGICTRANSERRINTSTS);
1417
1418 chk_iob_err:
1419         /* IOB memory error */
1420         reg = readl(ctx->dev_csr + GLBL_ERR_STS);
1421         if (!reg)
1422                 return;
1423         if (reg & SEC_ERR_MASK) {
1424                 err_addr_lo = readl(ctx->dev_csr + GLBL_SEC_ERRL);
1425                 err_addr_hi = readl(ctx->dev_csr + GLBL_SEC_ERRH);
1426                 dev_err(edac_dev->dev,
1427                         "IOB single-bit correctable memory at 0x%08X.%08X error\n",
1428                         err_addr_lo, err_addr_hi);
1429                 writel(err_addr_lo, ctx->dev_csr + GLBL_SEC_ERRL);
1430                 writel(err_addr_hi, ctx->dev_csr + GLBL_SEC_ERRH);
1431         }
1432         if (reg & MSEC_ERR_MASK) {
1433                 err_addr_lo = readl(ctx->dev_csr + GLBL_MSEC_ERRL);
1434                 err_addr_hi = readl(ctx->dev_csr + GLBL_MSEC_ERRH);
1435                 dev_err(edac_dev->dev,
1436                         "IOB multiple single-bit correctable memory at 0x%08X.%08X error\n",
1437                         err_addr_lo, err_addr_hi);
1438                 writel(err_addr_lo, ctx->dev_csr + GLBL_MSEC_ERRL);
1439                 writel(err_addr_hi, ctx->dev_csr + GLBL_MSEC_ERRH);
1440         }
1441         if (reg & (SEC_ERR_MASK | MSEC_ERR_MASK))
1442                 edac_device_handle_ce(edac_dev, 0, 0, edac_dev->ctl_name);
1443
1444         if (reg & DED_ERR_MASK) {
1445                 err_addr_lo = readl(ctx->dev_csr + GLBL_DED_ERRL);
1446                 err_addr_hi = readl(ctx->dev_csr + GLBL_DED_ERRH);
1447                 dev_err(edac_dev->dev,
1448                         "IOB double-bit uncorrectable memory at 0x%08X.%08X error\n",
1449                         err_addr_lo, err_addr_hi);
1450                 writel(err_addr_lo, ctx->dev_csr + GLBL_DED_ERRL);
1451                 writel(err_addr_hi, ctx->dev_csr + GLBL_DED_ERRH);
1452         }
1453         if (reg & MDED_ERR_MASK) {
1454                 err_addr_lo = readl(ctx->dev_csr + GLBL_MDED_ERRL);
1455                 err_addr_hi = readl(ctx->dev_csr + GLBL_MDED_ERRH);
1456                 dev_err(edac_dev->dev,
1457                         "Multiple IOB double-bit uncorrectable memory at 0x%08X.%08X error\n",
1458                         err_addr_lo, err_addr_hi);
1459                 writel(err_addr_lo, ctx->dev_csr + GLBL_MDED_ERRL);
1460                 writel(err_addr_hi, ctx->dev_csr + GLBL_MDED_ERRH);
1461         }
1462         if (reg & (DED_ERR_MASK | MDED_ERR_MASK))
1463                 edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name);
1464 }
1465
1466 static void xgene_edac_rb_report(struct edac_device_ctl_info *edac_dev)
1467 {
1468         struct xgene_edac_dev_ctx *ctx = edac_dev->pvt_info;
1469         u32 err_addr_lo;
1470         u32 err_addr_hi;
1471         u32 reg;
1472
1473         /* IOB Bridge agent transaction error interrupt */
1474         reg = readl(ctx->dev_csr + IOBBATRANSERRINTSTS);
1475         if (!reg)
1476                 return;
1477
1478         dev_err(edac_dev->dev, "IOB bridge agent (BA) transaction error\n");
1479         if (reg & WRERR_RESP_MASK)
1480                 dev_err(edac_dev->dev, "IOB BA write response error\n");
1481         if (reg & M_WRERR_RESP_MASK)
1482                 dev_err(edac_dev->dev,
1483                         "Multiple IOB BA write response error\n");
1484         if (reg & XGIC_POISONED_REQ_MASK)
1485                 dev_err(edac_dev->dev, "IOB BA XGIC poisoned write error\n");
1486         if (reg & M_XGIC_POISONED_REQ_MASK)
1487                 dev_err(edac_dev->dev,
1488                         "Multiple IOB BA XGIC poisoned write error\n");
1489         if (reg & RBM_POISONED_REQ_MASK)
1490                 dev_err(edac_dev->dev, "IOB BA RBM poisoned write error\n");
1491         if (reg & M_RBM_POISONED_REQ_MASK)
1492                 dev_err(edac_dev->dev,
1493                         "Multiple IOB BA RBM poisoned write error\n");
1494         if (reg & WDATA_CORRUPT_MASK)
1495                 dev_err(edac_dev->dev, "IOB BA write error\n");
1496         if (reg & M_WDATA_CORRUPT_MASK)
1497                 dev_err(edac_dev->dev, "Multiple IOB BA write error\n");
1498         if (reg & TRANS_CORRUPT_MASK)
1499                 dev_err(edac_dev->dev, "IOB BA transaction error\n");
1500         if (reg & M_TRANS_CORRUPT_MASK)
1501                 dev_err(edac_dev->dev, "Multiple IOB BA transaction error\n");
1502         if (reg & RIDRAM_CORRUPT_MASK)
1503                 dev_err(edac_dev->dev,
1504                         "IOB BA RDIDRAM read transaction ID error\n");
1505         if (reg & M_RIDRAM_CORRUPT_MASK)
1506                 dev_err(edac_dev->dev,
1507                         "Multiple IOB BA RDIDRAM read transaction ID error\n");
1508         if (reg & WIDRAM_CORRUPT_MASK)
1509                 dev_err(edac_dev->dev,
1510                         "IOB BA RDIDRAM write transaction ID error\n");
1511         if (reg & M_WIDRAM_CORRUPT_MASK)
1512                 dev_err(edac_dev->dev,
1513                         "Multiple IOB BA RDIDRAM write transaction ID error\n");
1514         if (reg & ILLEGAL_ACCESS_MASK)
1515                 dev_err(edac_dev->dev,
1516                         "IOB BA XGIC/RB illegal access error\n");
1517         if (reg & M_ILLEGAL_ACCESS_MASK)
1518                 dev_err(edac_dev->dev,
1519                         "Multiple IOB BA XGIC/RB illegal access error\n");
1520
1521         err_addr_lo = readl(ctx->dev_csr + IOBBATRANSERRREQINFOL);
1522         err_addr_hi = readl(ctx->dev_csr + IOBBATRANSERRREQINFOH);
1523         dev_err(edac_dev->dev, "IOB BA %s access at 0x%02X.%08X (0x%08X)\n",
1524                 REQTYPE_F2_RD(err_addr_hi) ? "read" : "write",
1525                 ERRADDRH_F2_RD(err_addr_hi), err_addr_lo, err_addr_hi);
1526         if (reg & WRERR_RESP_MASK)
1527                 dev_err(edac_dev->dev, "IOB BA requestor ID 0x%08X\n",
1528                         readl(ctx->dev_csr + IOBBATRANSERRCSWREQID));
1529         writel(reg, ctx->dev_csr + IOBBATRANSERRINTSTS);
1530 }
1531
1532 static void xgene_edac_pa_report(struct edac_device_ctl_info *edac_dev)
1533 {
1534         struct xgene_edac_dev_ctx *ctx = edac_dev->pvt_info;
1535         u32 err_addr_lo;
1536         u32 err_addr_hi;
1537         u32 reg;
1538
1539         /* IOB Processing agent transaction error interrupt */
1540         reg = readl(ctx->dev_csr + IOBPATRANSERRINTSTS);
1541         if (!reg)
1542                 goto chk_iob_axi0;
1543         dev_err(edac_dev->dev, "IOB procesing agent (PA) transaction error\n");
1544         if (reg & IOBPA_RDATA_CORRUPT_MASK)
1545                 dev_err(edac_dev->dev, "IOB PA read data RAM error\n");
1546         if (reg & IOBPA_M_RDATA_CORRUPT_MASK)
1547                 dev_err(edac_dev->dev,
1548                         "Mutilple IOB PA read data RAM error\n");
1549         if (reg & IOBPA_WDATA_CORRUPT_MASK)
1550                 dev_err(edac_dev->dev, "IOB PA write data RAM error\n");
1551         if (reg & IOBPA_M_WDATA_CORRUPT_MASK)
1552                 dev_err(edac_dev->dev,
1553                         "Mutilple IOB PA write data RAM error\n");
1554         if (reg & IOBPA_TRANS_CORRUPT_MASK)
1555                 dev_err(edac_dev->dev, "IOB PA transaction error\n");
1556         if (reg & IOBPA_M_TRANS_CORRUPT_MASK)
1557                 dev_err(edac_dev->dev, "Mutilple IOB PA transaction error\n");
1558         if (reg & IOBPA_REQIDRAM_CORRUPT_MASK)
1559                 dev_err(edac_dev->dev, "IOB PA transaction ID RAM error\n");
1560         if (reg & IOBPA_M_REQIDRAM_CORRUPT_MASK)
1561                 dev_err(edac_dev->dev,
1562                         "Multiple IOB PA transaction ID RAM error\n");
1563         writel(reg, ctx->dev_csr + IOBPATRANSERRINTSTS);
1564
1565 chk_iob_axi0:
1566         /* IOB AXI0 Error */
1567         reg = readl(ctx->dev_csr + IOBAXIS0TRANSERRINTSTS);
1568         if (!reg)
1569                 goto chk_iob_axi1;
1570         err_addr_lo = readl(ctx->dev_csr + IOBAXIS0TRANSERRREQINFOL);
1571         err_addr_hi = readl(ctx->dev_csr + IOBAXIS0TRANSERRREQINFOH);
1572         dev_err(edac_dev->dev,
1573                 "%sAXI slave 0 illegal %s access @ 0x%02X.%08X (0x%08X)\n",
1574                 reg & IOBAXIS0_M_ILLEGAL_ACCESS_MASK ? "Multiple " : "",
1575                 REQTYPE_RD(err_addr_hi) ? "read" : "write",
1576                 ERRADDRH_RD(err_addr_hi), err_addr_lo, err_addr_hi);
1577         writel(reg, ctx->dev_csr + IOBAXIS0TRANSERRINTSTS);
1578
1579 chk_iob_axi1:
1580         /* IOB AXI1 Error */
1581         reg = readl(ctx->dev_csr + IOBAXIS1TRANSERRINTSTS);
1582         if (!reg)
1583                 return;
1584         err_addr_lo = readl(ctx->dev_csr + IOBAXIS1TRANSERRREQINFOL);
1585         err_addr_hi = readl(ctx->dev_csr + IOBAXIS1TRANSERRREQINFOH);
1586         dev_err(edac_dev->dev,
1587                 "%sAXI slave 1 illegal %s access @ 0x%02X.%08X (0x%08X)\n",
1588                 reg & IOBAXIS0_M_ILLEGAL_ACCESS_MASK ? "Multiple " : "",
1589                 REQTYPE_RD(err_addr_hi) ? "read" : "write",
1590                 ERRADDRH_RD(err_addr_hi), err_addr_lo, err_addr_hi);
1591         writel(reg, ctx->dev_csr + IOBAXIS1TRANSERRINTSTS);
1592 }
1593
1594 static void xgene_edac_soc_check(struct edac_device_ctl_info *edac_dev)
1595 {
1596         struct xgene_edac_dev_ctx *ctx = edac_dev->pvt_info;
1597         const char * const *soc_mem_err = NULL;
1598         u32 pcp_hp_stat;
1599         u32 pcp_lp_stat;
1600         u32 reg;
1601         int i;
1602
1603         xgene_edac_pcp_rd(ctx->edac, PCPHPERRINTSTS, &pcp_hp_stat);
1604         xgene_edac_pcp_rd(ctx->edac, PCPLPERRINTSTS, &pcp_lp_stat);
1605         xgene_edac_pcp_rd(ctx->edac, MEMERRINTSTS, &reg);
1606         if (!((pcp_hp_stat & (IOB_PA_ERR_MASK | IOB_BA_ERR_MASK |
1607                               IOB_XGIC_ERR_MASK | IOB_RB_ERR_MASK)) ||
1608               (pcp_lp_stat & CSW_SWITCH_TRACE_ERR_MASK) || reg))
1609                 return;
1610
1611         if (pcp_hp_stat & IOB_XGIC_ERR_MASK)
1612                 xgene_edac_iob_gic_report(edac_dev);
1613
1614         if (pcp_hp_stat & (IOB_RB_ERR_MASK | IOB_BA_ERR_MASK))
1615                 xgene_edac_rb_report(edac_dev);
1616
1617         if (pcp_hp_stat & IOB_PA_ERR_MASK)
1618                 xgene_edac_pa_report(edac_dev);
1619
1620         if (pcp_lp_stat & CSW_SWITCH_TRACE_ERR_MASK) {
1621                 dev_info(edac_dev->dev,
1622                          "CSW switch trace correctable memory parity error\n");
1623                 edac_device_handle_ce(edac_dev, 0, 0, edac_dev->ctl_name);
1624         }
1625
1626         if (!reg)
1627                 return;
1628         if (ctx->version == 1)
1629                 soc_mem_err = soc_mem_err_v1;
1630         if (!soc_mem_err) {
1631                 dev_err(edac_dev->dev, "SoC memory parity error 0x%08X\n",
1632                         reg);
1633                 edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name);
1634                 return;
1635         }
1636         for (i = 0; i < 31; i++) {
1637                 if (reg & (1 << i)) {
1638                         dev_err(edac_dev->dev, "%s memory parity error\n",
1639                                 soc_mem_err[i]);
1640                         edac_device_handle_ue(edac_dev, 0, 0,
1641                                               edac_dev->ctl_name);
1642                 }
1643         }
1644 }
1645
1646 static void xgene_edac_soc_hw_init(struct edac_device_ctl_info *edac_dev,
1647                                    bool enable)
1648 {
1649         struct xgene_edac_dev_ctx *ctx = edac_dev->pvt_info;
1650
1651         /* Enable SoC IP error interrupt */
1652         if (edac_dev->op_state == OP_RUNNING_INTERRUPT) {
1653                 if (enable) {
1654                         xgene_edac_pcp_clrbits(ctx->edac, PCPHPERRINTMSK,
1655                                                IOB_PA_ERR_MASK |
1656                                                IOB_BA_ERR_MASK |
1657                                                IOB_XGIC_ERR_MASK |
1658                                                IOB_RB_ERR_MASK);
1659                         xgene_edac_pcp_clrbits(ctx->edac, PCPLPERRINTMSK,
1660                                                CSW_SWITCH_TRACE_ERR_MASK);
1661                 } else {
1662                         xgene_edac_pcp_setbits(ctx->edac, PCPHPERRINTMSK,
1663                                                IOB_PA_ERR_MASK |
1664                                                IOB_BA_ERR_MASK |
1665                                                IOB_XGIC_ERR_MASK |
1666                                                IOB_RB_ERR_MASK);
1667                         xgene_edac_pcp_setbits(ctx->edac, PCPLPERRINTMSK,
1668                                                CSW_SWITCH_TRACE_ERR_MASK);
1669                 }
1670
1671                 writel(enable ? 0x0 : 0xFFFFFFFF,
1672                        ctx->dev_csr + IOBAXIS0TRANSERRINTMSK);
1673                 writel(enable ? 0x0 : 0xFFFFFFFF,
1674                        ctx->dev_csr + IOBAXIS1TRANSERRINTMSK);
1675                 writel(enable ? 0x0 : 0xFFFFFFFF,
1676                        ctx->dev_csr + XGICTRANSERRINTMSK);
1677
1678                 xgene_edac_pcp_setbits(ctx->edac, MEMERRINTMSK,
1679                                        enable ? 0x0 : 0xFFFFFFFF);
1680         }
1681 }
1682
1683 static int xgene_edac_soc_add(struct xgene_edac *edac, struct device_node *np,
1684                               int version)
1685 {
1686         struct edac_device_ctl_info *edac_dev;
1687         struct xgene_edac_dev_ctx *ctx;
1688         void __iomem *dev_csr;
1689         struct resource res;
1690         int edac_idx;
1691         int rc;
1692
1693         if (!devres_open_group(edac->dev, xgene_edac_soc_add, GFP_KERNEL))
1694                 return -ENOMEM;
1695
1696         rc = of_address_to_resource(np, 0, &res);
1697         if (rc < 0) {
1698                 dev_err(edac->dev, "no SoC resource address\n");
1699                 goto err_release_group;
1700         }
1701         dev_csr = devm_ioremap_resource(edac->dev, &res);
1702         if (IS_ERR(dev_csr)) {
1703                 dev_err(edac->dev,
1704                         "devm_ioremap_resource failed for soc resource address\n");
1705                 rc = PTR_ERR(dev_csr);
1706                 goto err_release_group;
1707         }
1708
1709         edac_idx = edac_device_alloc_index();
1710         edac_dev = edac_device_alloc_ctl_info(sizeof(*ctx),
1711                                               "SOC", 1, "SOC", 1, 2, NULL, 0,
1712                                               edac_idx);
1713         if (!edac_dev) {
1714                 rc = -ENOMEM;
1715                 goto err_release_group;
1716         }
1717
1718         ctx = edac_dev->pvt_info;
1719         ctx->dev_csr = dev_csr;
1720         ctx->name = "xgene_soc_err";
1721         ctx->edac_idx = edac_idx;
1722         ctx->edac = edac;
1723         ctx->edac_dev = edac_dev;
1724         ctx->ddev = *edac->dev;
1725         ctx->version = version;
1726         edac_dev->dev = &ctx->ddev;
1727         edac_dev->ctl_name = ctx->name;
1728         edac_dev->dev_name = ctx->name;
1729         edac_dev->mod_name = EDAC_MOD_STR;
1730
1731         if (edac_op_state == EDAC_OPSTATE_POLL)
1732                 edac_dev->edac_check = xgene_edac_soc_check;
1733
1734         rc = edac_device_add_device(edac_dev);
1735         if (rc > 0) {
1736                 dev_err(edac->dev, "failed edac_device_add_device()\n");
1737                 rc = -ENOMEM;
1738                 goto err_ctl_free;
1739         }
1740
1741         if (edac_op_state == EDAC_OPSTATE_INT)
1742                 edac_dev->op_state = OP_RUNNING_INTERRUPT;
1743
1744         list_add(&ctx->next, &edac->socs);
1745
1746         xgene_edac_soc_hw_init(edac_dev, 1);
1747
1748         devres_remove_group(edac->dev, xgene_edac_soc_add);
1749
1750         dev_info(edac->dev, "X-Gene EDAC SoC registered\n");
1751
1752         return 0;
1753
1754 err_ctl_free:
1755         edac_device_free_ctl_info(edac_dev);
1756 err_release_group:
1757         devres_release_group(edac->dev, xgene_edac_soc_add);
1758         return rc;
1759 }
1760
1761 static int xgene_edac_soc_remove(struct xgene_edac_dev_ctx *soc)
1762 {
1763         struct edac_device_ctl_info *edac_dev = soc->edac_dev;
1764
1765         xgene_edac_soc_hw_init(edac_dev, 0);
1766         edac_device_del_device(soc->edac->dev);
1767         edac_device_free_ctl_info(edac_dev);
1768         return 0;
1769 }
1770
1771 static irqreturn_t xgene_edac_isr(int irq, void *dev_id)
1772 {
1773         struct xgene_edac *ctx = dev_id;
1774         struct xgene_edac_pmd_ctx *pmd;
1775         struct xgene_edac_dev_ctx *node;
1776         unsigned int pcp_hp_stat;
1777         unsigned int pcp_lp_stat;
1778
1779         xgene_edac_pcp_rd(ctx, PCPHPERRINTSTS, &pcp_hp_stat);
1780         xgene_edac_pcp_rd(ctx, PCPLPERRINTSTS, &pcp_lp_stat);
1781         if ((MCU_UNCORR_ERR_MASK & pcp_hp_stat) ||
1782             (MCU_CTL_ERR_MASK & pcp_hp_stat) ||
1783             (MCU_CORR_ERR_MASK & pcp_lp_stat)) {
1784                 struct xgene_edac_mc_ctx *mcu;
1785
1786                 list_for_each_entry(mcu, &ctx->mcus, next)
1787                         xgene_edac_mc_check(mcu->mci);
1788         }
1789
1790         list_for_each_entry(pmd, &ctx->pmds, next) {
1791                 if ((PMD0_MERR_MASK << pmd->pmd) & pcp_hp_stat)
1792                         xgene_edac_pmd_check(pmd->edac_dev);
1793         }
1794
1795         list_for_each_entry(node, &ctx->l3s, next)
1796                 xgene_edac_l3_check(node->edac_dev);
1797
1798         list_for_each_entry(node, &ctx->socs, next)
1799                 xgene_edac_soc_check(node->edac_dev);
1800
1801         return IRQ_HANDLED;
1802 }
1803
1804 static int xgene_edac_probe(struct platform_device *pdev)
1805 {
1806         struct xgene_edac *edac;
1807         struct device_node *child;
1808         struct resource *res;
1809         int rc;
1810
1811         edac = devm_kzalloc(&pdev->dev, sizeof(*edac), GFP_KERNEL);
1812         if (!edac)
1813                 return -ENOMEM;
1814
1815         edac->dev = &pdev->dev;
1816         platform_set_drvdata(pdev, edac);
1817         INIT_LIST_HEAD(&edac->mcus);
1818         INIT_LIST_HEAD(&edac->pmds);
1819         INIT_LIST_HEAD(&edac->l3s);
1820         INIT_LIST_HEAD(&edac->socs);
1821         spin_lock_init(&edac->lock);
1822         mutex_init(&edac->mc_lock);
1823
1824         edac->csw_map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
1825                                                         "regmap-csw");
1826         if (IS_ERR(edac->csw_map)) {
1827                 dev_err(edac->dev, "unable to get syscon regmap csw\n");
1828                 rc = PTR_ERR(edac->csw_map);
1829                 goto out_err;
1830         }
1831
1832         edac->mcba_map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
1833                                                          "regmap-mcba");
1834         if (IS_ERR(edac->mcba_map)) {
1835                 dev_err(edac->dev, "unable to get syscon regmap mcba\n");
1836                 rc = PTR_ERR(edac->mcba_map);
1837                 goto out_err;
1838         }
1839
1840         edac->mcbb_map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
1841                                                          "regmap-mcbb");
1842         if (IS_ERR(edac->mcbb_map)) {
1843                 dev_err(edac->dev, "unable to get syscon regmap mcbb\n");
1844                 rc = PTR_ERR(edac->mcbb_map);
1845                 goto out_err;
1846         }
1847         edac->efuse_map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
1848                                                           "regmap-efuse");
1849         if (IS_ERR(edac->efuse_map)) {
1850                 dev_err(edac->dev, "unable to get syscon regmap efuse\n");
1851                 rc = PTR_ERR(edac->efuse_map);
1852                 goto out_err;
1853         }
1854
1855         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1856         edac->pcp_csr = devm_ioremap_resource(&pdev->dev, res);
1857         if (IS_ERR(edac->pcp_csr)) {
1858                 dev_err(&pdev->dev, "no PCP resource address\n");
1859                 rc = PTR_ERR(edac->pcp_csr);
1860                 goto out_err;
1861         }
1862
1863         if (edac_op_state == EDAC_OPSTATE_INT) {
1864                 int irq;
1865                 int i;
1866
1867                 for (i = 0; i < 3; i++) {
1868                         irq = platform_get_irq(pdev, i);
1869                         if (irq < 0) {
1870                                 dev_err(&pdev->dev, "No IRQ resource\n");
1871                                 rc = -EINVAL;
1872                                 goto out_err;
1873                         }
1874                         rc = devm_request_irq(&pdev->dev, irq,
1875                                               xgene_edac_isr, IRQF_SHARED,
1876                                               dev_name(&pdev->dev), edac);
1877                         if (rc) {
1878                                 dev_err(&pdev->dev,
1879                                         "Could not request IRQ %d\n", irq);
1880                                 goto out_err;
1881                         }
1882                 }
1883         }
1884
1885         edac->dfs = edac_debugfs_create_dir(pdev->dev.kobj.name);
1886
1887         for_each_child_of_node(pdev->dev.of_node, child) {
1888                 if (!of_device_is_available(child))
1889                         continue;
1890                 if (of_device_is_compatible(child, "apm,xgene-edac-mc"))
1891                         xgene_edac_mc_add(edac, child);
1892                 if (of_device_is_compatible(child, "apm,xgene-edac-pmd"))
1893                         xgene_edac_pmd_add(edac, child, 1);
1894                 if (of_device_is_compatible(child, "apm,xgene-edac-pmd-v2"))
1895                         xgene_edac_pmd_add(edac, child, 2);
1896                 if (of_device_is_compatible(child, "apm,xgene-edac-l3"))
1897                         xgene_edac_l3_add(edac, child, 1);
1898                 if (of_device_is_compatible(child, "apm,xgene-edac-l3-v2"))
1899                         xgene_edac_l3_add(edac, child, 2);
1900                 if (of_device_is_compatible(child, "apm,xgene-edac-soc"))
1901                         xgene_edac_soc_add(edac, child, 0);
1902                 if (of_device_is_compatible(child, "apm,xgene-edac-soc-v1"))
1903                         xgene_edac_soc_add(edac, child, 1);
1904         }
1905
1906         return 0;
1907
1908 out_err:
1909         return rc;
1910 }
1911
1912 static int xgene_edac_remove(struct platform_device *pdev)
1913 {
1914         struct xgene_edac *edac = dev_get_drvdata(&pdev->dev);
1915         struct xgene_edac_mc_ctx *mcu;
1916         struct xgene_edac_mc_ctx *temp_mcu;
1917         struct xgene_edac_pmd_ctx *pmd;
1918         struct xgene_edac_pmd_ctx *temp_pmd;
1919         struct xgene_edac_dev_ctx *node;
1920         struct xgene_edac_dev_ctx *temp_node;
1921
1922         list_for_each_entry_safe(mcu, temp_mcu, &edac->mcus, next)
1923                 xgene_edac_mc_remove(mcu);
1924
1925         list_for_each_entry_safe(pmd, temp_pmd, &edac->pmds, next)
1926                 xgene_edac_pmd_remove(pmd);
1927
1928         list_for_each_entry_safe(node, temp_node, &edac->l3s, next)
1929                 xgene_edac_l3_remove(node);
1930
1931         list_for_each_entry_safe(node, temp_node, &edac->socs, next)
1932                 xgene_edac_soc_remove(node);
1933
1934         return 0;
1935 }
1936
1937 static const struct of_device_id xgene_edac_of_match[] = {
1938         { .compatible = "apm,xgene-edac" },
1939         {},
1940 };
1941 MODULE_DEVICE_TABLE(of, xgene_edac_of_match);
1942
1943 static struct platform_driver xgene_edac_driver = {
1944         .probe = xgene_edac_probe,
1945         .remove = xgene_edac_remove,
1946         .driver = {
1947                 .name = "xgene-edac",
1948                 .of_match_table = xgene_edac_of_match,
1949         },
1950 };
1951
1952 static int __init xgene_edac_init(void)
1953 {
1954         int rc;
1955
1956         /* Make sure error reporting method is sane */
1957         switch (edac_op_state) {
1958         case EDAC_OPSTATE_POLL:
1959         case EDAC_OPSTATE_INT:
1960                 break;
1961         default:
1962                 edac_op_state = EDAC_OPSTATE_INT;
1963                 break;
1964         }
1965
1966         rc = platform_driver_register(&xgene_edac_driver);
1967         if (rc) {
1968                 edac_printk(KERN_ERR, EDAC_MOD_STR,
1969                             "EDAC fails to register\n");
1970                 goto reg_failed;
1971         }
1972
1973         return 0;
1974
1975 reg_failed:
1976         return rc;
1977 }
1978 module_init(xgene_edac_init);
1979
1980 static void __exit xgene_edac_exit(void)
1981 {
1982         platform_driver_unregister(&xgene_edac_driver);
1983 }
1984 module_exit(xgene_edac_exit);
1985
1986 MODULE_LICENSE("GPL");
1987 MODULE_AUTHOR("Feng Kan <fkan@apm.com>");
1988 MODULE_DESCRIPTION("APM X-Gene EDAC driver");
1989 module_param(edac_op_state, int, 0444);
1990 MODULE_PARM_DESC(edac_op_state,
1991                  "EDAC error reporting state: 0=Poll, 2=Interrupt");