de69163ff5b35b40facfa589c55ef164b7183fd6
[linux-2.6.git] / drivers / edac / mv64x60_edac.c
1 /*
2  * Marvell MV64x60 Memory Controller kernel module for PPC platforms
3  *
4  * Author: Dave Jiang <djiang@mvista.com>
5  *
6  * 2006-2007 (c) MontaVista Software, Inc. This file is licensed under
7  * the terms of the GNU General Public License version 2. This program
8  * is licensed "as is" without any warranty of any kind, whether express
9  * or implied.
10  *
11  */
12
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/interrupt.h>
17 #include <linux/io.h>
18 #include <linux/edac.h>
19
20 #include "edac_core.h"
21 #include "edac_module.h"
22 #include "mv64x60_edac.h"
23
24 static const char *mv64x60_ctl_name = "MV64x60";
25 static int edac_dev_idx;
26 static int edac_pci_idx;
27 static int edac_mc_idx;
28
29 /*********************** PCI err device **********************************/
30 #ifdef CONFIG_PCI
31 static void mv64x60_pci_check(struct edac_pci_ctl_info *pci)
32 {
33         struct mv64x60_pci_pdata *pdata = pci->pvt_info;
34         u32 cause;
35
36         cause = in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE);
37         if (!cause)
38                 return;
39
40         printk(KERN_ERR "Error in PCI %d Interface\n", pdata->pci_hose);
41         printk(KERN_ERR "Cause register: 0x%08x\n", cause);
42         printk(KERN_ERR "Address Low: 0x%08x\n",
43                in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_ADDR_LO));
44         printk(KERN_ERR "Address High: 0x%08x\n",
45                in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_ADDR_HI));
46         printk(KERN_ERR "Attribute: 0x%08x\n",
47                in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_ATTR));
48         printk(KERN_ERR "Command: 0x%08x\n",
49                in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_CMD));
50         out_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE, ~cause);
51
52         if (cause & MV64X60_PCI_PE_MASK)
53                 edac_pci_handle_pe(pci, pci->ctl_name);
54
55         if (!(cause & MV64X60_PCI_PE_MASK))
56                 edac_pci_handle_npe(pci, pci->ctl_name);
57 }
58
59 static irqreturn_t mv64x60_pci_isr(int irq, void *dev_id)
60 {
61         struct edac_pci_ctl_info *pci = dev_id;
62         struct mv64x60_pci_pdata *pdata = pci->pvt_info;
63         u32 val;
64
65         val = in_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE);
66         if (!val)
67                 return IRQ_NONE;
68
69         mv64x60_pci_check(pci);
70
71         return IRQ_HANDLED;
72 }
73
74 static int __devinit mv64x60_pci_err_probe(struct platform_device *pdev)
75 {
76         struct edac_pci_ctl_info *pci;
77         struct mv64x60_pci_pdata *pdata;
78         struct resource *r;
79         int res = 0;
80
81         if (!devres_open_group(&pdev->dev, mv64x60_pci_err_probe, GFP_KERNEL))
82                 return -ENOMEM;
83
84         pci = edac_pci_alloc_ctl_info(sizeof(*pdata), "mv64x60_pci_err");
85         if (!pci)
86                 return -ENOMEM;
87
88         pdata = pci->pvt_info;
89
90         pdata->pci_hose = pdev->id;
91         pdata->name = "mpc85xx_pci_err";
92         pdata->irq = NO_IRQ;
93         platform_set_drvdata(pdev, pci);
94         pci->dev = &pdev->dev;
95         pci->dev_name = pdev->dev.bus_id;
96         pci->mod_name = EDAC_MOD_STR;
97         pci->ctl_name = pdata->name;
98
99         if (edac_op_state == EDAC_OPSTATE_POLL)
100                 pci->edac_check = mv64x60_pci_check;
101
102         pdata->edac_idx = edac_pci_idx++;
103
104         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
105         if (!r) {
106                 printk(KERN_ERR "%s: Unable to get resource for "
107                        "PCI err regs\n", __func__);
108                 res = -ENOENT;
109                 goto err;
110         }
111
112         if (!devm_request_mem_region(&pdev->dev,
113                                      r->start,
114                                      r->end - r->start + 1,
115                                      pdata->name)) {
116                 printk(KERN_ERR "%s: Error while requesting mem region\n",
117                        __func__);
118                 res = -EBUSY;
119                 goto err;
120         }
121
122         pdata->pci_vbase = devm_ioremap(&pdev->dev,
123                                         r->start,
124                                         r->end - r->start + 1);
125         if (!pdata->pci_vbase) {
126                 printk(KERN_ERR "%s: Unable to setup PCI err regs\n", __func__);
127                 res = -ENOMEM;
128                 goto err;
129         }
130
131         out_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_CAUSE, 0);
132         out_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_MASK, 0);
133         out_le32(pdata->pci_vbase + MV64X60_PCI_ERROR_MASK,
134                  MV64X60_PCIx_ERR_MASK_VAL);
135
136         if (edac_pci_add_device(pci, pdata->edac_idx) > 0) {
137                 debugf3("%s(): failed edac_pci_add_device()\n", __func__);
138                 goto err;
139         }
140
141         if (edac_op_state == EDAC_OPSTATE_INT) {
142                 pdata->irq = platform_get_irq(pdev, 0);
143                 res = devm_request_irq(&pdev->dev,
144                                        pdata->irq,
145                                        mv64x60_pci_isr,
146                                        IRQF_DISABLED,
147                                        "[EDAC] PCI err",
148                                        pci);
149                 if (res < 0) {
150                         printk(KERN_ERR "%s: Unable to request irq %d for "
151                                "MV64x60 PCI ERR\n", __func__, pdata->irq);
152                         res = -ENODEV;
153                         goto err2;
154                 }
155                 printk(KERN_INFO EDAC_MOD_STR " acquired irq %d for PCI Err\n",
156                        pdata->irq);
157         }
158
159         devres_remove_group(&pdev->dev, mv64x60_pci_err_probe);
160
161         /* get this far and it's successful */
162         debugf3("%s(): success\n", __func__);
163
164         return 0;
165
166 err2:
167         edac_pci_del_device(&pdev->dev);
168 err:
169         edac_pci_free_ctl_info(pci);
170         devres_release_group(&pdev->dev, mv64x60_pci_err_probe);
171         return res;
172 }
173
174 static int mv64x60_pci_err_remove(struct platform_device *pdev)
175 {
176         struct edac_pci_ctl_info *pci = platform_get_drvdata(pdev);
177
178         debugf0("%s()\n", __func__);
179
180         edac_pci_del_device(&pdev->dev);
181
182         edac_pci_free_ctl_info(pci);
183
184         return 0;
185 }
186
187 static struct platform_driver mv64x60_pci_err_driver = {
188         .probe = mv64x60_pci_err_probe,
189         .remove = __devexit_p(mv64x60_pci_err_remove),
190         .driver = {
191                    .name = "mv64x60_pci_err",
192         }
193 };
194
195 #endif /* CONFIG_PCI */
196
197 /*********************** SRAM err device **********************************/
198 static void mv64x60_sram_check(struct edac_device_ctl_info *edac_dev)
199 {
200         struct mv64x60_sram_pdata *pdata = edac_dev->pvt_info;
201         u32 cause;
202
203         cause = in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE);
204         if (!cause)
205                 return;
206
207         printk(KERN_ERR "Error in internal SRAM\n");
208         printk(KERN_ERR "Cause register: 0x%08x\n", cause);
209         printk(KERN_ERR "Address Low: 0x%08x\n",
210                in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_ADDR_LO));
211         printk(KERN_ERR "Address High: 0x%08x\n",
212                in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_ADDR_HI));
213         printk(KERN_ERR "Data Low: 0x%08x\n",
214                in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_DATA_LO));
215         printk(KERN_ERR "Data High: 0x%08x\n",
216                in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_DATA_HI));
217         printk(KERN_ERR "Parity: 0x%08x\n",
218                in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_PARITY));
219         out_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE, 0);
220
221         edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name);
222 }
223
224 static irqreturn_t mv64x60_sram_isr(int irq, void *dev_id)
225 {
226         struct edac_device_ctl_info *edac_dev = dev_id;
227         struct mv64x60_sram_pdata *pdata = edac_dev->pvt_info;
228         u32 cause;
229
230         cause = in_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE);
231         if (!cause)
232                 return IRQ_NONE;
233
234         mv64x60_sram_check(edac_dev);
235
236         return IRQ_HANDLED;
237 }
238
239 static int __devinit mv64x60_sram_err_probe(struct platform_device *pdev)
240 {
241         struct edac_device_ctl_info *edac_dev;
242         struct mv64x60_sram_pdata *pdata;
243         struct resource *r;
244         int res = 0;
245
246         if (!devres_open_group(&pdev->dev, mv64x60_sram_err_probe, GFP_KERNEL))
247                 return -ENOMEM;
248
249         edac_dev = edac_device_alloc_ctl_info(sizeof(*pdata),
250                                               "sram", 1, NULL, 0, 0, NULL, 0,
251                                               edac_dev_idx);
252         if (!edac_dev) {
253                 devres_release_group(&pdev->dev, mv64x60_sram_err_probe);
254                 return -ENOMEM;
255         }
256
257         pdata = edac_dev->pvt_info;
258         pdata->name = "mv64x60_sram_err";
259         pdata->irq = NO_IRQ;
260         edac_dev->dev = &pdev->dev;
261         platform_set_drvdata(pdev, edac_dev);
262         edac_dev->dev_name = pdev->dev.bus_id;
263
264         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
265         if (!r) {
266                 printk(KERN_ERR "%s: Unable to get resource for "
267                        "SRAM err regs\n", __func__);
268                 res = -ENOENT;
269                 goto err;
270         }
271
272         if (!devm_request_mem_region(&pdev->dev,
273                                      r->start,
274                                      r->end - r->start + 1,
275                                      pdata->name)) {
276                 printk(KERN_ERR "%s: Error while request mem region\n",
277                        __func__);
278                 res = -EBUSY;
279                 goto err;
280         }
281
282         pdata->sram_vbase = devm_ioremap(&pdev->dev,
283                                          r->start,
284                                          r->end - r->start + 1);
285         if (!pdata->sram_vbase) {
286                 printk(KERN_ERR "%s: Unable to setup SRAM err regs\n",
287                        __func__);
288                 res = -ENOMEM;
289                 goto err;
290         }
291
292         /* setup SRAM err registers */
293         out_le32(pdata->sram_vbase + MV64X60_SRAM_ERR_CAUSE, 0);
294
295         edac_dev->mod_name = EDAC_MOD_STR;
296         edac_dev->ctl_name = pdata->name;
297
298         if (edac_op_state == EDAC_OPSTATE_POLL)
299                 edac_dev->edac_check = mv64x60_sram_check;
300
301         pdata->edac_idx = edac_dev_idx++;
302
303         if (edac_device_add_device(edac_dev) > 0) {
304                 debugf3("%s(): failed edac_device_add_device()\n", __func__);
305                 goto err;
306         }
307
308         if (edac_op_state == EDAC_OPSTATE_INT) {
309                 pdata->irq = platform_get_irq(pdev, 0);
310                 res = devm_request_irq(&pdev->dev,
311                                        pdata->irq,
312                                        mv64x60_sram_isr,
313                                        IRQF_DISABLED,
314                                        "[EDAC] SRAM err",
315                                        edac_dev);
316                 if (res < 0) {
317                         printk(KERN_ERR
318                                "%s: Unable to request irq %d for "
319                                "MV64x60 SRAM ERR\n", __func__, pdata->irq);
320                         res = -ENODEV;
321                         goto err2;
322                 }
323
324                 printk(KERN_INFO EDAC_MOD_STR " acquired irq %d for SRAM Err\n",
325                        pdata->irq);
326         }
327
328         devres_remove_group(&pdev->dev, mv64x60_sram_err_probe);
329
330         /* get this far and it's successful */
331         debugf3("%s(): success\n", __func__);
332
333         return 0;
334
335 err2:
336         edac_device_del_device(&pdev->dev);
337 err:
338         devres_release_group(&pdev->dev, mv64x60_sram_err_probe);
339         edac_device_free_ctl_info(edac_dev);
340         return res;
341 }
342
343 static int mv64x60_sram_err_remove(struct platform_device *pdev)
344 {
345         struct edac_device_ctl_info *edac_dev = platform_get_drvdata(pdev);
346
347         debugf0("%s()\n", __func__);
348
349         edac_device_del_device(&pdev->dev);
350         edac_device_free_ctl_info(edac_dev);
351
352         return 0;
353 }
354
355 static struct platform_driver mv64x60_sram_err_driver = {
356         .probe = mv64x60_sram_err_probe,
357         .remove = mv64x60_sram_err_remove,
358         .driver = {
359                    .name = "mv64x60_sram_err",
360         }
361 };
362
363 /*********************** CPU err device **********************************/
364 static void mv64x60_cpu_check(struct edac_device_ctl_info *edac_dev)
365 {
366         struct mv64x60_cpu_pdata *pdata = edac_dev->pvt_info;
367         u32 cause;
368
369         cause = in_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE) &
370             MV64x60_CPU_CAUSE_MASK;
371         if (!cause)
372                 return;
373
374         printk(KERN_ERR "Error on CPU interface\n");
375         printk(KERN_ERR "Cause register: 0x%08x\n", cause);
376         printk(KERN_ERR "Address Low: 0x%08x\n",
377                in_le32(pdata->cpu_vbase[0] + MV64x60_CPU_ERR_ADDR_LO));
378         printk(KERN_ERR "Address High: 0x%08x\n",
379                in_le32(pdata->cpu_vbase[0] + MV64x60_CPU_ERR_ADDR_HI));
380         printk(KERN_ERR "Data Low: 0x%08x\n",
381                in_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_DATA_LO));
382         printk(KERN_ERR "Data High: 0x%08x\n",
383                in_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_DATA_HI));
384         printk(KERN_ERR "Parity: 0x%08x\n",
385                in_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_PARITY));
386         out_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE, 0);
387
388         edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name);
389 }
390
391 static irqreturn_t mv64x60_cpu_isr(int irq, void *dev_id)
392 {
393         struct edac_device_ctl_info *edac_dev = dev_id;
394         struct mv64x60_cpu_pdata *pdata = edac_dev->pvt_info;
395         u32 cause;
396
397         cause = in_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE) &
398             MV64x60_CPU_CAUSE_MASK;
399         if (!cause)
400                 return IRQ_NONE;
401
402         mv64x60_cpu_check(edac_dev);
403
404         return IRQ_HANDLED;
405 }
406
407 static int __devinit mv64x60_cpu_err_probe(struct platform_device *pdev)
408 {
409         struct edac_device_ctl_info *edac_dev;
410         struct resource *r;
411         struct mv64x60_cpu_pdata *pdata;
412         int res = 0;
413
414         if (!devres_open_group(&pdev->dev, mv64x60_cpu_err_probe, GFP_KERNEL))
415                 return -ENOMEM;
416
417         edac_dev = edac_device_alloc_ctl_info(sizeof(*pdata),
418                                               "cpu", 1, NULL, 0, 0, NULL, 0,
419                                               edac_dev_idx);
420         if (!edac_dev) {
421                 devres_release_group(&pdev->dev, mv64x60_cpu_err_probe);
422                 return -ENOMEM;
423         }
424
425         pdata = edac_dev->pvt_info;
426         pdata->name = "mv64x60_cpu_err";
427         pdata->irq = NO_IRQ;
428         edac_dev->dev = &pdev->dev;
429         platform_set_drvdata(pdev, edac_dev);
430         edac_dev->dev_name = pdev->dev.bus_id;
431
432         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
433         if (!r) {
434                 printk(KERN_ERR "%s: Unable to get resource for "
435                        "CPU err regs\n", __func__);
436                 res = -ENOENT;
437                 goto err;
438         }
439
440         if (!devm_request_mem_region(&pdev->dev,
441                                      r->start,
442                                      r->end - r->start + 1,
443                                      pdata->name)) {
444                 printk(KERN_ERR "%s: Error while requesting mem region\n",
445                        __func__);
446                 res = -EBUSY;
447                 goto err;
448         }
449
450         pdata->cpu_vbase[0] = devm_ioremap(&pdev->dev,
451                                            r->start,
452                                            r->end - r->start + 1);
453         if (!pdata->cpu_vbase[0]) {
454                 printk(KERN_ERR "%s: Unable to setup CPU err regs\n", __func__);
455                 res = -ENOMEM;
456                 goto err;
457         }
458
459         r = platform_get_resource(pdev, IORESOURCE_MEM, 1);
460         if (!r) {
461                 printk(KERN_ERR "%s: Unable to get resource for "
462                        "CPU err regs\n", __func__);
463                 res = -ENOENT;
464                 goto err;
465         }
466
467         if (!devm_request_mem_region(&pdev->dev,
468                                      r->start,
469                                      r->end - r->start + 1,
470                                      pdata->name)) {
471                 printk(KERN_ERR "%s: Error while requesting mem region\n",
472                        __func__);
473                 res = -EBUSY;
474                 goto err;
475         }
476
477         pdata->cpu_vbase[1] = devm_ioremap(&pdev->dev,
478                                            r->start,
479                                            r->end - r->start + 1);
480         if (!pdata->cpu_vbase[1]) {
481                 printk(KERN_ERR "%s: Unable to setup CPU err regs\n", __func__);
482                 res = -ENOMEM;
483                 goto err;
484         }
485
486         /* setup CPU err registers */
487         out_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_CAUSE, 0);
488         out_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_MASK, 0);
489         out_le32(pdata->cpu_vbase[1] + MV64x60_CPU_ERR_MASK, 0x000000ff);
490
491         edac_dev->mod_name = EDAC_MOD_STR;
492         edac_dev->ctl_name = pdata->name;
493         if (edac_op_state == EDAC_OPSTATE_POLL)
494                 edac_dev->edac_check = mv64x60_cpu_check;
495
496         pdata->edac_idx = edac_dev_idx++;
497
498         if (edac_device_add_device(edac_dev) > 0) {
499                 debugf3("%s(): failed edac_device_add_device()\n", __func__);
500                 goto err;
501         }
502
503         if (edac_op_state == EDAC_OPSTATE_INT) {
504                 pdata->irq = platform_get_irq(pdev, 0);
505                 res = devm_request_irq(&pdev->dev,
506                                        pdata->irq,
507                                        mv64x60_cpu_isr,
508                                        IRQF_DISABLED,
509                                        "[EDAC] CPU err",
510                                        edac_dev);
511                 if (res < 0) {
512                         printk(KERN_ERR
513                                "%s: Unable to request irq %d for MV64x60 "
514                                "CPU ERR\n", __func__, pdata->irq);
515                         res = -ENODEV;
516                         goto err2;
517                 }
518
519                 printk(KERN_INFO EDAC_MOD_STR
520                        " acquired irq %d for CPU Err\n", pdata->irq);
521         }
522
523         devres_remove_group(&pdev->dev, mv64x60_cpu_err_probe);
524
525         /* get this far and it's successful */
526         debugf3("%s(): success\n", __func__);
527
528         return 0;
529
530 err2:
531         edac_device_del_device(&pdev->dev);
532 err:
533         devres_release_group(&pdev->dev, mv64x60_cpu_err_probe);
534         edac_device_free_ctl_info(edac_dev);
535         return res;
536 }
537
538 static int mv64x60_cpu_err_remove(struct platform_device *pdev)
539 {
540         struct edac_device_ctl_info *edac_dev = platform_get_drvdata(pdev);
541
542         debugf0("%s()\n", __func__);
543
544         edac_device_del_device(&pdev->dev);
545         edac_device_free_ctl_info(edac_dev);
546         return 0;
547 }
548
549 static struct platform_driver mv64x60_cpu_err_driver = {
550         .probe = mv64x60_cpu_err_probe,
551         .remove = mv64x60_cpu_err_remove,
552         .driver = {
553                    .name = "mv64x60_cpu_err",
554         }
555 };
556
557 /*********************** DRAM err device **********************************/
558
559 static void mv64x60_mc_check(struct mem_ctl_info *mci)
560 {
561         struct mv64x60_mc_pdata *pdata = mci->pvt_info;
562         u32 reg;
563         u32 err_addr;
564         u32 sdram_ecc;
565         u32 comp_ecc;
566         u32 syndrome;
567
568         reg = in_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR);
569         if (!reg)
570                 return;
571
572         err_addr = reg & ~0x3;
573         sdram_ecc = in_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_RCVD);
574         comp_ecc = in_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_CALC);
575         syndrome = sdram_ecc ^ comp_ecc;
576
577         /* first bit clear in ECC Err Reg, 1 bit error, correctable by HW */
578         if (!(reg & 0x1))
579                 edac_mc_handle_ce(mci, err_addr >> PAGE_SHIFT,
580                                   err_addr & PAGE_MASK, syndrome, 0, 0,
581                                   mci->ctl_name);
582         else    /* 2 bit error, UE */
583                 edac_mc_handle_ue(mci, err_addr >> PAGE_SHIFT,
584                                   err_addr & PAGE_MASK, 0, mci->ctl_name);
585
586         /* clear the error */
587         out_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR, 0);
588 }
589
590 static irqreturn_t mv64x60_mc_isr(int irq, void *dev_id)
591 {
592         struct mem_ctl_info *mci = dev_id;
593         struct mv64x60_mc_pdata *pdata = mci->pvt_info;
594         u32 reg;
595
596         reg = in_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR);
597         if (!reg)
598                 return IRQ_NONE;
599
600         /* writing 0's to the ECC err addr in check function clears irq */
601         mv64x60_mc_check(mci);
602
603         return IRQ_HANDLED;
604 }
605
606 static void get_total_mem(struct mv64x60_mc_pdata *pdata)
607 {
608         struct device_node *np = NULL;
609         const unsigned int *reg;
610
611         np = of_find_node_by_type(NULL, "memory");
612         if (!np)
613                 return;
614
615         reg = of_get_property(np, "reg", NULL);
616
617         pdata->total_mem = reg[1];
618 }
619
620 static void mv64x60_init_csrows(struct mem_ctl_info *mci,
621                                 struct mv64x60_mc_pdata *pdata)
622 {
623         struct csrow_info *csrow;
624         u32 devtype;
625         u32 ctl;
626
627         get_total_mem(pdata);
628
629         ctl = in_le32(pdata->mc_vbase + MV64X60_SDRAM_CONFIG);
630
631         csrow = &mci->csrows[0];
632         csrow->first_page = 0;
633         csrow->nr_pages = pdata->total_mem >> PAGE_SHIFT;
634         csrow->last_page = csrow->first_page + csrow->nr_pages - 1;
635         csrow->grain = 8;
636
637         csrow->mtype = (ctl & MV64X60_SDRAM_REGISTERED) ? MEM_RDDR : MEM_DDR;
638
639         devtype = (ctl >> 20) & 0x3;
640         switch (devtype) {
641         case 0x0:
642                 csrow->dtype = DEV_X32;
643                 break;
644         case 0x2:               /* could be X8 too, but no way to tell */
645                 csrow->dtype = DEV_X16;
646                 break;
647         case 0x3:
648                 csrow->dtype = DEV_X4;
649                 break;
650         default:
651                 csrow->dtype = DEV_UNKNOWN;
652                 break;
653         }
654
655         csrow->edac_mode = EDAC_SECDED;
656 }
657
658 static int __devinit mv64x60_mc_err_probe(struct platform_device *pdev)
659 {
660         struct mem_ctl_info *mci;
661         struct mv64x60_mc_pdata *pdata;
662         struct resource *r;
663         u32 ctl;
664         int res = 0;
665
666         if (!devres_open_group(&pdev->dev, mv64x60_mc_err_probe, GFP_KERNEL))
667                 return -ENOMEM;
668
669         mci = edac_mc_alloc(sizeof(struct mv64x60_mc_pdata), 1, 1, edac_mc_idx);
670         if (!mci) {
671                 printk(KERN_ERR "%s: No memory for CPU err\n", __func__);
672                 devres_release_group(&pdev->dev, mv64x60_mc_err_probe);
673                 return -ENOMEM;
674         }
675
676         pdata = mci->pvt_info;
677         mci->dev = &pdev->dev;
678         platform_set_drvdata(pdev, mci);
679         pdata->name = "mv64x60_mc_err";
680         pdata->irq = NO_IRQ;
681         mci->dev_name = pdev->dev.bus_id;
682         pdata->edac_idx = edac_mc_idx++;
683
684         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
685         if (!r) {
686                 printk(KERN_ERR "%s: Unable to get resource for "
687                        "MC err regs\n", __func__);
688                 res = -ENOENT;
689                 goto err;
690         }
691
692         if (!devm_request_mem_region(&pdev->dev,
693                                      r->start,
694                                      r->end - r->start + 1,
695                                      pdata->name)) {
696                 printk(KERN_ERR "%s: Error while requesting mem region\n",
697                        __func__);
698                 res = -EBUSY;
699                 goto err;
700         }
701
702         pdata->mc_vbase = devm_ioremap(&pdev->dev,
703                                        r->start,
704                                        r->end - r->start + 1);
705         if (!pdata->mc_vbase) {
706                 printk(KERN_ERR "%s: Unable to setup MC err regs\n", __func__);
707                 res = -ENOMEM;
708                 goto err;
709         }
710
711         ctl = in_le32(pdata->mc_vbase + MV64X60_SDRAM_CONFIG);
712         if (!(ctl & MV64X60_SDRAM_ECC)) {
713                 /* Non-ECC RAM? */
714                 printk(KERN_WARNING "%s: No ECC DIMMs discovered\n", __func__);
715                 res = -ENODEV;
716                 goto err2;
717         }
718
719         debugf3("%s(): init mci\n", __func__);
720         mci->mtype_cap = MEM_FLAG_RDDR | MEM_FLAG_DDR;
721         mci->edac_ctl_cap = EDAC_FLAG_NONE | EDAC_FLAG_SECDED;
722         mci->edac_cap = EDAC_FLAG_SECDED;
723         mci->mod_name = EDAC_MOD_STR;
724         mci->mod_ver = MV64x60_REVISION;
725         mci->ctl_name = mv64x60_ctl_name;
726
727         if (edac_op_state == EDAC_OPSTATE_POLL)
728                 mci->edac_check = mv64x60_mc_check;
729
730         mci->ctl_page_to_phys = NULL;
731
732         mci->scrub_mode = SCRUB_SW_SRC;
733
734         mv64x60_init_csrows(mci, pdata);
735
736         /* setup MC registers */
737         out_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ADDR, 0);
738         ctl = in_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_CNTL);
739         ctl = (ctl & 0xff00ffff) | 0x10000;
740         out_le32(pdata->mc_vbase + MV64X60_SDRAM_ERR_ECC_CNTL, ctl);
741
742         if (edac_mc_add_mc(mci)) {
743                 debugf3("%s(): failed edac_mc_add_mc()\n", __func__);
744                 goto err;
745         }
746
747         if (edac_op_state == EDAC_OPSTATE_INT) {
748                 /* acquire interrupt that reports errors */
749                 pdata->irq = platform_get_irq(pdev, 0);
750                 res = devm_request_irq(&pdev->dev,
751                                        pdata->irq,
752                                        mv64x60_mc_isr,
753                                        IRQF_DISABLED,
754                                        "[EDAC] MC err",
755                                        mci);
756                 if (res < 0) {
757                         printk(KERN_ERR "%s: Unable to request irq %d for "
758                                "MV64x60 DRAM ERR\n", __func__, pdata->irq);
759                         res = -ENODEV;
760                         goto err2;
761                 }
762
763                 printk(KERN_INFO EDAC_MOD_STR " acquired irq %d for MC Err\n",
764                        pdata->irq);
765         }
766
767         /* get this far and it's successful */
768         debugf3("%s(): success\n", __func__);
769
770         return 0;
771
772 err2:
773         edac_mc_del_mc(&pdev->dev);
774 err:
775         devres_release_group(&pdev->dev, mv64x60_mc_err_probe);
776         edac_mc_free(mci);
777         return res;
778 }
779
780 static int mv64x60_mc_err_remove(struct platform_device *pdev)
781 {
782         struct mem_ctl_info *mci = platform_get_drvdata(pdev);
783
784         debugf0("%s()\n", __func__);
785
786         edac_mc_del_mc(&pdev->dev);
787         edac_mc_free(mci);
788         return 0;
789 }
790
791 static struct platform_driver mv64x60_mc_err_driver = {
792         .probe = mv64x60_mc_err_probe,
793         .remove = mv64x60_mc_err_remove,
794         .driver = {
795                    .name = "mv64x60_mc_err",
796         }
797 };
798
799 static int __init mv64x60_edac_init(void)
800 {
801         int ret = 0;
802
803         printk(KERN_INFO "Marvell MV64x60 EDAC driver " MV64x60_REVISION "\n");
804         printk(KERN_INFO "\t(C) 2006-2007 MontaVista Software\n");
805         /* make sure error reporting method is sane */
806         switch (edac_op_state) {
807         case EDAC_OPSTATE_POLL:
808         case EDAC_OPSTATE_INT:
809                 break;
810         default:
811                 edac_op_state = EDAC_OPSTATE_INT;
812                 break;
813         }
814
815         ret = platform_driver_register(&mv64x60_mc_err_driver);
816         if (ret)
817                 printk(KERN_WARNING EDAC_MOD_STR "MC err failed to register\n");
818
819         ret = platform_driver_register(&mv64x60_cpu_err_driver);
820         if (ret)
821                 printk(KERN_WARNING EDAC_MOD_STR
822                         "CPU err failed to register\n");
823
824         ret = platform_driver_register(&mv64x60_sram_err_driver);
825         if (ret)
826                 printk(KERN_WARNING EDAC_MOD_STR
827                         "SRAM err failed to register\n");
828
829 #ifdef CONFIG_PCI
830         ret = platform_driver_register(&mv64x60_pci_err_driver);
831         if (ret)
832                 printk(KERN_WARNING EDAC_MOD_STR
833                         "PCI err failed to register\n");
834 #endif
835
836         return ret;
837 }
838 module_init(mv64x60_edac_init);
839
840 static void __exit mv64x60_edac_exit(void)
841 {
842 #ifdef CONFIG_PCI
843         platform_driver_unregister(&mv64x60_pci_err_driver);
844 #endif
845         platform_driver_unregister(&mv64x60_sram_err_driver);
846         platform_driver_unregister(&mv64x60_cpu_err_driver);
847         platform_driver_unregister(&mv64x60_mc_err_driver);
848 }
849 module_exit(mv64x60_edac_exit);
850
851 MODULE_LICENSE("GPL");
852 MODULE_AUTHOR("Montavista Software, Inc.");
853 module_param(edac_op_state, int, 0444);
854 MODULE_PARM_DESC(edac_op_state,
855                  "EDAC Error Reporting state: 0=Poll, 2=Interrupt");