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