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