1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2018, 2019 Cisco Systems 4 */ 5 6 #include <linux/edac.h> 7 #include <linux/module.h> 8 #include <linux/init.h> 9 #include <linux/interrupt.h> 10 #include <linux/platform_device.h> 11 #include <linux/stop_machine.h> 12 #include <linux/io.h> 13 #include <linux/of_address.h> 14 #include <linux/regmap.h> 15 #include "edac_module.h" 16 17 18 #define DRV_NAME "aspeed-edac" 19 20 21 #define ASPEED_MCR_PROT 0x00 /* protection key register */ 22 #define ASPEED_MCR_CONF 0x04 /* configuration register */ 23 #define ASPEED_MCR_INTR_CTRL 0x50 /* interrupt control/status register */ 24 #define ASPEED_MCR_ADDR_UNREC 0x58 /* address of first un-recoverable error */ 25 #define ASPEED_MCR_ADDR_REC 0x5c /* address of last recoverable error */ 26 #define ASPEED_MCR_LAST ASPEED_MCR_ADDR_REC 27 28 29 #define ASPEED_MCR_PROT_PASSWD 0xfc600309 30 #define ASPEED_MCR_CONF_DRAM_TYPE BIT(4) 31 #define ASPEED_MCR_CONF_ECC BIT(7) 32 #define ASPEED_MCR_INTR_CTRL_CLEAR BIT(31) 33 #define ASPEED_MCR_INTR_CTRL_CNT_REC GENMASK(23, 16) 34 #define ASPEED_MCR_INTR_CTRL_CNT_UNREC GENMASK(15, 12) 35 #define ASPEED_MCR_INTR_CTRL_ENABLE (BIT(0) | BIT(1)) 36 37 38 static struct regmap *aspeed_regmap; 39 40 41 static int regmap_reg_write(void *context, unsigned int reg, unsigned int val) 42 { 43 void __iomem *regs = (void __iomem *)context; 44 45 /* enable write to MCR register set */ 46 writel(ASPEED_MCR_PROT_PASSWD, regs + ASPEED_MCR_PROT); 47 48 writel(val, regs + reg); 49 50 /* disable write to MCR register set */ 51 writel(~ASPEED_MCR_PROT_PASSWD, regs + ASPEED_MCR_PROT); 52 53 return 0; 54 } 55 56 57 static int regmap_reg_read(void *context, unsigned int reg, unsigned int *val) 58 { 59 void __iomem *regs = (void __iomem *)context; 60 61 *val = readl(regs + reg); 62 63 return 0; 64 } 65 66 static bool regmap_is_volatile(struct device *dev, unsigned int reg) 67 { 68 switch (reg) { 69 case ASPEED_MCR_PROT: 70 case ASPEED_MCR_INTR_CTRL: 71 case ASPEED_MCR_ADDR_UNREC: 72 case ASPEED_MCR_ADDR_REC: 73 return true; 74 default: 75 return false; 76 } 77 } 78 79 80 static const struct regmap_config aspeed_regmap_config = { 81 .reg_bits = 32, 82 .val_bits = 32, 83 .reg_stride = 4, 84 .max_register = ASPEED_MCR_LAST, 85 .reg_write = regmap_reg_write, 86 .reg_read = regmap_reg_read, 87 .volatile_reg = regmap_is_volatile, 88 .fast_io = true, 89 }; 90 91 92 static void count_rec(struct mem_ctl_info *mci, u8 rec_cnt, u32 rec_addr) 93 { 94 struct csrow_info *csrow = mci->csrows[0]; 95 u32 page, offset, syndrome; 96 97 if (!rec_cnt) 98 return; 99 100 /* report first few errors (if there are) */ 101 /* note: no addresses are recorded */ 102 if (rec_cnt > 1) { 103 /* page, offset and syndrome are not available */ 104 page = 0; 105 offset = 0; 106 syndrome = 0; 107 edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, rec_cnt-1, 108 page, offset, syndrome, 0, 0, -1, 109 "address(es) not available", ""); 110 } 111 112 /* report last error */ 113 /* note: rec_addr is the last recoverable error addr */ 114 page = rec_addr >> PAGE_SHIFT; 115 offset = rec_addr & ~PAGE_MASK; 116 /* syndrome is not available */ 117 syndrome = 0; 118 edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, 1, 119 csrow->first_page + page, offset, syndrome, 120 0, 0, -1, "", ""); 121 } 122 123 124 static void count_un_rec(struct mem_ctl_info *mci, u8 un_rec_cnt, 125 u32 un_rec_addr) 126 { 127 struct csrow_info *csrow = mci->csrows[0]; 128 u32 page, offset, syndrome; 129 130 if (!un_rec_cnt) 131 return; 132 133 /* report 1. error */ 134 /* note: un_rec_addr is the first unrecoverable error addr */ 135 page = un_rec_addr >> PAGE_SHIFT; 136 offset = un_rec_addr & ~PAGE_MASK; 137 /* syndrome is not available */ 138 syndrome = 0; 139 edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci, 1, 140 csrow->first_page + page, offset, syndrome, 141 0, 0, -1, "", ""); 142 143 /* report further errors (if there are) */ 144 /* note: no addresses are recorded */ 145 if (un_rec_cnt > 1) { 146 /* page, offset and syndrome are not available */ 147 page = 0; 148 offset = 0; 149 syndrome = 0; 150 edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci, un_rec_cnt-1, 151 page, offset, syndrome, 0, 0, -1, 152 "address(es) not available", ""); 153 } 154 } 155 156 157 static irqreturn_t mcr_isr(int irq, void *arg) 158 { 159 struct mem_ctl_info *mci = arg; 160 u32 rec_addr, un_rec_addr; 161 u32 reg50, reg5c, reg58; 162 u8 rec_cnt, un_rec_cnt; 163 164 regmap_read(aspeed_regmap, ASPEED_MCR_INTR_CTRL, ®50); 165 dev_dbg(mci->pdev, "received edac interrupt w/ mcr register 50: 0x%x\n", 166 reg50); 167 168 /* collect data about recoverable and unrecoverable errors */ 169 rec_cnt = (reg50 & ASPEED_MCR_INTR_CTRL_CNT_REC) >> 16; 170 un_rec_cnt = (reg50 & ASPEED_MCR_INTR_CTRL_CNT_UNREC) >> 12; 171 172 dev_dbg(mci->pdev, "%d recoverable interrupts and %d unrecoverable interrupts\n", 173 rec_cnt, un_rec_cnt); 174 175 regmap_read(aspeed_regmap, ASPEED_MCR_ADDR_UNREC, ®58); 176 un_rec_addr = reg58; 177 178 regmap_read(aspeed_regmap, ASPEED_MCR_ADDR_REC, ®5c); 179 rec_addr = reg5c; 180 181 /* clear interrupt flags and error counters: */ 182 regmap_update_bits(aspeed_regmap, ASPEED_MCR_INTR_CTRL, 183 ASPEED_MCR_INTR_CTRL_CLEAR, 184 ASPEED_MCR_INTR_CTRL_CLEAR); 185 186 regmap_update_bits(aspeed_regmap, ASPEED_MCR_INTR_CTRL, 187 ASPEED_MCR_INTR_CTRL_CLEAR, 0); 188 189 /* process recoverable and unrecoverable errors */ 190 count_rec(mci, rec_cnt, rec_addr); 191 count_un_rec(mci, un_rec_cnt, un_rec_addr); 192 193 if (!rec_cnt && !un_rec_cnt) 194 dev_dbg(mci->pdev, "received edac interrupt, but did not find any ECC counters\n"); 195 196 regmap_read(aspeed_regmap, ASPEED_MCR_INTR_CTRL, ®50); 197 dev_dbg(mci->pdev, "edac interrupt handled. mcr reg 50 is now: 0x%x\n", 198 reg50); 199 200 return IRQ_HANDLED; 201 } 202 203 204 static int config_irq(void *ctx, struct platform_device *pdev) 205 { 206 int irq; 207 int rc; 208 209 /* register interrupt handler */ 210 irq = platform_get_irq(pdev, 0); 211 dev_dbg(&pdev->dev, "got irq %d\n", irq); 212 if (irq < 0) 213 return irq; 214 215 rc = devm_request_irq(&pdev->dev, irq, mcr_isr, IRQF_TRIGGER_HIGH, 216 DRV_NAME, ctx); 217 if (rc) 218 return rc; 219 220 /* enable interrupts */ 221 regmap_update_bits(aspeed_regmap, ASPEED_MCR_INTR_CTRL, 222 ASPEED_MCR_INTR_CTRL_ENABLE, 223 ASPEED_MCR_INTR_CTRL_ENABLE); 224 225 return 0; 226 } 227 228 229 static int init_csrows(struct mem_ctl_info *mci) 230 { 231 struct csrow_info *csrow = mci->csrows[0]; 232 u32 nr_pages, dram_type; 233 struct dimm_info *dimm; 234 struct device_node *np; 235 struct resource r; 236 u32 reg04; 237 int rc; 238 239 /* retrieve info about physical memory from device tree */ 240 np = of_find_node_by_name(NULL, "memory"); 241 if (!np) { 242 dev_err(mci->pdev, "dt: missing /memory node\n"); 243 return -ENODEV; 244 } 245 246 rc = of_address_to_resource(np, 0, &r); 247 248 of_node_put(np); 249 250 if (rc) { 251 dev_err(mci->pdev, "dt: failed requesting resource for /memory node\n"); 252 return rc; 253 } 254 255 dev_dbg(mci->pdev, "dt: /memory node resources: first page %pR, PAGE_SHIFT macro=0x%x\n", 256 &r, PAGE_SHIFT); 257 258 csrow->first_page = r.start >> PAGE_SHIFT; 259 nr_pages = resource_size(&r) >> PAGE_SHIFT; 260 csrow->last_page = csrow->first_page + nr_pages - 1; 261 262 regmap_read(aspeed_regmap, ASPEED_MCR_CONF, ®04); 263 dram_type = (reg04 & ASPEED_MCR_CONF_DRAM_TYPE) ? MEM_DDR4 : MEM_DDR3; 264 265 dimm = csrow->channels[0]->dimm; 266 dimm->mtype = dram_type; 267 dimm->edac_mode = EDAC_SECDED; 268 dimm->nr_pages = nr_pages / csrow->nr_channels; 269 270 dev_dbg(mci->pdev, "initialized dimm with first_page=0x%lx and nr_pages=0x%x\n", 271 csrow->first_page, nr_pages); 272 273 return 0; 274 } 275 276 277 static int aspeed_probe(struct platform_device *pdev) 278 { 279 struct device *dev = &pdev->dev; 280 struct edac_mc_layer layers[2]; 281 struct mem_ctl_info *mci; 282 void __iomem *regs; 283 u32 reg04; 284 int rc; 285 286 regs = devm_platform_ioremap_resource(pdev, 0); 287 if (IS_ERR(regs)) 288 return PTR_ERR(regs); 289 290 aspeed_regmap = devm_regmap_init(dev, NULL, (__force void *)regs, 291 &aspeed_regmap_config); 292 if (IS_ERR(aspeed_regmap)) 293 return PTR_ERR(aspeed_regmap); 294 295 /* bail out if ECC mode is not configured */ 296 regmap_read(aspeed_regmap, ASPEED_MCR_CONF, ®04); 297 if (!(reg04 & ASPEED_MCR_CONF_ECC)) { 298 dev_err(&pdev->dev, "ECC mode is not configured in u-boot\n"); 299 return -EPERM; 300 } 301 302 edac_op_state = EDAC_OPSTATE_INT; 303 304 /* allocate & init EDAC MC data structure */ 305 layers[0].type = EDAC_MC_LAYER_CHIP_SELECT; 306 layers[0].size = 1; 307 layers[0].is_virt_csrow = true; 308 layers[1].type = EDAC_MC_LAYER_CHANNEL; 309 layers[1].size = 1; 310 layers[1].is_virt_csrow = false; 311 312 mci = edac_mc_alloc(0, ARRAY_SIZE(layers), layers, 0); 313 if (!mci) 314 return -ENOMEM; 315 316 mci->pdev = &pdev->dev; 317 mci->mtype_cap = MEM_FLAG_DDR3 | MEM_FLAG_DDR4; 318 mci->edac_ctl_cap = EDAC_FLAG_SECDED; 319 mci->edac_cap = EDAC_FLAG_SECDED; 320 mci->scrub_cap = SCRUB_FLAG_HW_SRC; 321 mci->scrub_mode = SCRUB_HW_SRC; 322 mci->mod_name = DRV_NAME; 323 mci->ctl_name = "MIC"; 324 mci->dev_name = dev_name(&pdev->dev); 325 326 rc = init_csrows(mci); 327 if (rc) { 328 dev_err(&pdev->dev, "failed to init csrows\n"); 329 goto probe_exit02; 330 } 331 332 platform_set_drvdata(pdev, mci); 333 334 /* register with edac core */ 335 rc = edac_mc_add_mc(mci); 336 if (rc) { 337 dev_err(&pdev->dev, "failed to register with EDAC core\n"); 338 goto probe_exit02; 339 } 340 341 /* register interrupt handler and enable interrupts */ 342 rc = config_irq(mci, pdev); 343 if (rc) { 344 dev_err(&pdev->dev, "failed setting up irq\n"); 345 goto probe_exit01; 346 } 347 348 return 0; 349 350 probe_exit01: 351 edac_mc_del_mc(&pdev->dev); 352 probe_exit02: 353 edac_mc_free(mci); 354 return rc; 355 } 356 357 358 static void aspeed_remove(struct platform_device *pdev) 359 { 360 struct mem_ctl_info *mci; 361 362 /* disable interrupts */ 363 regmap_update_bits(aspeed_regmap, ASPEED_MCR_INTR_CTRL, 364 ASPEED_MCR_INTR_CTRL_ENABLE, 0); 365 366 /* free resources */ 367 mci = edac_mc_del_mc(&pdev->dev); 368 if (mci) 369 edac_mc_free(mci); 370 } 371 372 373 static const struct of_device_id aspeed_of_match[] = { 374 { .compatible = "aspeed,ast2400-sdram-edac" }, 375 { .compatible = "aspeed,ast2500-sdram-edac" }, 376 { .compatible = "aspeed,ast2600-sdram-edac" }, 377 {}, 378 }; 379 380 MODULE_DEVICE_TABLE(of, aspeed_of_match); 381 382 static struct platform_driver aspeed_driver = { 383 .driver = { 384 .name = DRV_NAME, 385 .of_match_table = aspeed_of_match 386 }, 387 .probe = aspeed_probe, 388 .remove = aspeed_remove 389 }; 390 module_platform_driver(aspeed_driver); 391 392 MODULE_LICENSE("GPL"); 393 MODULE_AUTHOR("Stefan Schaeckeler <sschaeck@cisco.com>"); 394 MODULE_DESCRIPTION("Aspeed BMC SoC EDAC driver"); 395 MODULE_VERSION("1.0"); 396