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
regmap_reg_write(void * context,unsigned int reg,unsigned int val)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
regmap_reg_read(void * context,unsigned int reg,unsigned int * val)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
regmap_is_volatile(struct device * dev,unsigned int reg)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
count_rec(struct mem_ctl_info * mci,u8 rec_cnt,u32 rec_addr)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
count_un_rec(struct mem_ctl_info * mci,u8 un_rec_cnt,u32 un_rec_addr)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
mcr_isr(int irq,void * arg)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
config_irq(void * ctx,struct platform_device * pdev)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
init_csrows(struct mem_ctl_info * mci)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
aspeed_probe(struct platform_device * pdev)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
aspeed_remove(struct platform_device * pdev)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