drivers/edac/mpc85xx_edac.c

   1 /*
   2  * Freescale MPC85xx Memory Controller kernel module
   3  *
   4  * Parts Copyrighted (c) 2013 by Freescale Semiconductor, Inc.
   5  *
   6  * Author: Dave Jiang <[email protected]>
   7  *
   8  * 2006-2007 (c) MontaVista Software, Inc. This file is licensed under
   9  * the terms of the GNU General Public License version 2. This program
  10  * is licensed "as is" without any warranty of any kind, whether express
  11  * or implied.
  12  *
  13  */
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/ctype.h>
  18 #include <linux/io.h>
  19 #include <linux/mod_devicetable.h>
  20 #include <linux/edac.h>
  21 #include <linux/smp.h>
  22 #include <linux/gfp.h>
  23 #include <linux/fsl/edac.h>
  24
  25 #include <linux/of_platform.h>
  26 #include <linux/of_device.h>
  27 #include <linux/of_address.h>
  28 #include <linux/of_irq.h>
  29 #include "edac_module.h"
  30 #include "mpc85xx_edac.h"
  31 #include "fsl_ddr_edac.h"
  32
  33 static int edac_dev_idx;
  34 #ifdef CONFIG_PCI
  35 static int edac_pci_idx;
  36 #endif
  37
  38 /*
  39  * PCI Err defines
  40  */
  41 #ifdef CONFIG_PCI
  42 static u32 orig_pci_err_cap_dr;
  43 static u32 orig_pci_err_en;
  44 #endif
  45
  46 static u32 orig_l2_err_disable;
  47
  48 /**************************** PCI Err device ***************************/
  49 #ifdef CONFIG_PCI
  50
  51 static void mpc85xx_pci_check(struct edac_pci_ctl_info *pci)
  52 {
  53         struct mpc85xx_pci_pdata *pdata = pci->pvt_info;
  54         u32 err_detect;
  55
  56         err_detect = in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_DR);
  57
  58         /* master aborts can happen during PCI config cycles */
  59         if (!(err_detect & ~(PCI_EDE_MULTI_ERR | PCI_EDE_MST_ABRT))) {
  60                 out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_DR, err_detect);
  61                 return;
  62         }
  63
  64         pr_err("PCI error(s) detected\n");
  65         pr_err("PCI/X ERR_DR register: %#08x\n", err_detect);
  66
  67         pr_err("PCI/X ERR_ATTRIB register: %#08x\n",
  68                in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_ATTRIB));
  69         pr_err("PCI/X ERR_ADDR register: %#08x\n",
  70                in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_ADDR));
  71         pr_err("PCI/X ERR_EXT_ADDR register: %#08x\n",
  72                in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_EXT_ADDR));
  73         pr_err("PCI/X ERR_DL register: %#08x\n",
  74                in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_DL));
  75         pr_err("PCI/X ERR_DH register: %#08x\n",
  76                in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_DH));
  77
  78         /* clear error bits */
  79         out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_DR, err_detect);
  80
  81         if (err_detect & PCI_EDE_PERR_MASK)
  82                 edac_pci_handle_pe(pci, pci->ctl_name);
  83
  84         if ((err_detect & ~PCI_EDE_MULTI_ERR) & ~PCI_EDE_PERR_MASK)
  85                 edac_pci_handle_npe(pci, pci->ctl_name);
  86 }
  87
  88 static void mpc85xx_pcie_check(struct edac_pci_ctl_info *pci)
  89 {
  90         struct mpc85xx_pci_pdata *pdata = pci->pvt_info;
  91         u32 err_detect, err_cap_stat;
  92
  93         err_detect = in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_DR);
  94         err_cap_stat = in_be32(pdata->pci_vbase + MPC85XX_PCI_GAS_TIMR);
  95
  96         pr_err("PCIe error(s) detected\n");
  97         pr_err("PCIe ERR_DR register: 0x%08x\n", err_detect);
  98         pr_err("PCIe ERR_CAP_STAT register: 0x%08x\n", err_cap_stat);
  99         pr_err("PCIe ERR_CAP_R0 register: 0x%08x\n",
 100                         in_be32(pdata->pci_vbase + MPC85XX_PCIE_ERR_CAP_R0));
 101         pr_err("PCIe ERR_CAP_R1 register: 0x%08x\n",
 102                         in_be32(pdata->pci_vbase + MPC85XX_PCIE_ERR_CAP_R1));
 103         pr_err("PCIe ERR_CAP_R2 register: 0x%08x\n",
 104                         in_be32(pdata->pci_vbase + MPC85XX_PCIE_ERR_CAP_R2));
 105         pr_err("PCIe ERR_CAP_R3 register: 0x%08x\n",
 106                         in_be32(pdata->pci_vbase + MPC85XX_PCIE_ERR_CAP_R3));
 107
 108         /* clear error bits */
 109         out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_DR, err_detect);
 110
 111         /* reset error capture */
 112         out_be32(pdata->pci_vbase + MPC85XX_PCI_GAS_TIMR, err_cap_stat | 0x1);
 113 }
 114
 115 static int mpc85xx_pcie_find_capability(struct device_node *np)
 116 {
 117         struct pci_controller *hose;
 118
 119         if (!np)
 120                 return -EINVAL;
 121
 122         hose = pci_find_hose_for_OF_device(np);
 123
 124         return early_find_capability(hose, 0, 0, PCI_CAP_ID_EXP);
 125 }
 126
 127 static irqreturn_t mpc85xx_pci_isr(int irq, void *dev_id)
 128 {
 129         struct edac_pci_ctl_info *pci = dev_id;
 130         struct mpc85xx_pci_pdata *pdata = pci->pvt_info;
 131         u32 err_detect;
 132
 133         err_detect = in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_DR);
 134
 135         if (!err_detect)
 136                 return IRQ_NONE;
 137
 138         if (pdata->is_pcie)
 139                 mpc85xx_pcie_check(pci);
 140         else
 141                 mpc85xx_pci_check(pci);
 142
 143         return IRQ_HANDLED;
 144 }
 145
 146 static int mpc85xx_pci_err_probe(struct platform_device *op)
 147 {
 148         struct edac_pci_ctl_info *pci;
 149         struct mpc85xx_pci_pdata *pdata;
 150         struct mpc85xx_edac_pci_plat_data *plat_data;
 151         struct device_node *of_node;
 152         struct resource r;
 153         int res = 0;
 154
 155         if (!devres_open_group(&op->dev, mpc85xx_pci_err_probe, GFP_KERNEL))
 156                 return -ENOMEM;
 157
 158         pci = edac_pci_alloc_ctl_info(sizeof(*pdata), "mpc85xx_pci_err");
 159         if (!pci)
 160                 return -ENOMEM;
 161
 162         /* make sure error reporting method is sane */
 163         switch (edac_op_state) {
 164         case EDAC_OPSTATE_POLL:
 165         case EDAC_OPSTATE_INT:
 166                 break;
 167         default:
 168                 edac_op_state = EDAC_OPSTATE_INT;
 169                 break;
 170         }
 171
 172         pdata = pci->pvt_info;
 173         pdata->name = "mpc85xx_pci_err";
 174
 175         plat_data = op->dev.platform_data;
 176         if (!plat_data) {
 177                 dev_err(&op->dev, "no platform data");
 178                 res = -ENXIO;
 179                 goto err;
 180         }
 181         of_node = plat_data->of_node;
 182
 183         if (mpc85xx_pcie_find_capability(of_node) > 0)
 184                 pdata->is_pcie = true;
 185
 186         dev_set_drvdata(&op->dev, pci);
 187         pci->dev = &op->dev;
 188         pci->mod_name = EDAC_MOD_STR;
 189         pci->ctl_name = pdata->name;
 190         pci->dev_name = dev_name(&op->dev);
 191
 192         if (edac_op_state == EDAC_OPSTATE_POLL) {
 193                 if (pdata->is_pcie)
 194                         pci->edac_check = mpc85xx_pcie_check;
 195                 else
 196                         pci->edac_check = mpc85xx_pci_check;
 197         }
 198
 199         pdata->edac_idx = edac_pci_idx++;
 200
 201         res = of_address_to_resource(of_node, 0, &r);
 202         if (res) {
 203                 pr_err("%s: Unable to get resource for PCI err regs\n", __func__);
 204                 goto err;
 205         }
 206
 207         /* we only need the error registers */
 208         r.start += 0xe00;
 209
 210         if (!devm_request_mem_region(&op->dev, r.start, resource_size(&r),
 211                                         pdata->name)) {
 212                 pr_err("%s: Error while requesting mem region\n", __func__);
 213                 res = -EBUSY;
 214                 goto err;
 215         }
 216
 217         pdata->pci_vbase = devm_ioremap(&op->dev, r.start, resource_size(&r));
 218         if (!pdata->pci_vbase) {
 219                 pr_err("%s: Unable to setup PCI err regs\n", __func__);
 220                 res = -ENOMEM;
 221                 goto err;
 222         }
 223
 224         if (pdata->is_pcie) {
 225                 orig_pci_err_cap_dr =
 226                     in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_ADDR);
 227                 out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_ADDR, ~0);
 228                 orig_pci_err_en =
 229                     in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_EN);
 230                 out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_EN, 0);
 231         } else {
 232                 orig_pci_err_cap_dr =
 233                     in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_CAP_DR);
 234
 235                 /* PCI master abort is expected during config cycles */
 236                 out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_CAP_DR, 0x40);
 237
 238                 orig_pci_err_en =
 239                     in_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_EN);
 240
 241                 /* disable master abort reporting */
 242                 out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_EN, ~0x40);
 243         }
 244
 245         /* clear error bits */
 246         out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_DR, ~0);
 247
 248         /* reset error capture */
 249         out_be32(pdata->pci_vbase + MPC85XX_PCI_GAS_TIMR, 0x1);
 250
 251         if (edac_pci_add_device(pci, pdata->edac_idx) > 0) {
 252                 edac_dbg(3, "failed edac_pci_add_device()\n");
 253                 goto err;
 254         }
 255
 256         if (edac_op_state == EDAC_OPSTATE_INT) {
 257                 pdata->irq = irq_of_parse_and_map(of_node, 0);
 258                 res = devm_request_irq(&op->dev, pdata->irq,
 259                                        mpc85xx_pci_isr,
 260                                        IRQF_SHARED,
 261                                        "[EDAC] PCI err", pci);
 262                 if (res < 0) {
 263                         pr_err("%s: Unable to request irq %d for MPC85xx PCI err\n",
 264                                 __func__, pdata->irq);
 265                         irq_dispose_mapping(pdata->irq);
 266                         res = -ENODEV;
 267                         goto err2;
 268                 }
 269
 270                 pr_info(EDAC_MOD_STR " acquired irq %d for PCI Err\n",
 271                        pdata->irq);
 272         }
 273
 274         if (pdata->is_pcie) {
 275                 /*
 276                  * Enable all PCIe error interrupt & error detect except invalid
 277                  * PEX_CONFIG_ADDR/PEX_CONFIG_DATA access interrupt generation
 278                  * enable bit and invalid PEX_CONFIG_ADDR/PEX_CONFIG_DATA access
 279                  * detection enable bit. Because PCIe bus code to initialize and
 280                  * configure these PCIe devices on booting will use some invalid
 281                  * PEX_CONFIG_ADDR/PEX_CONFIG_DATA, edac driver prints the much
 282                  * notice information. So disable this detect to fix ugly print.
 283                  */
 284                 out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_EN, ~0
 285                          & ~PEX_ERR_ICCAIE_EN_BIT);
 286                 out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_ADDR, 0
 287                          | PEX_ERR_ICCAD_DISR_BIT);
 288         }
 289
 290         devres_remove_group(&op->dev, mpc85xx_pci_err_probe);
 291         edac_dbg(3, "success\n");
 292         pr_info(EDAC_MOD_STR " PCI err registered\n");
 293
 294         return 0;
 295
 296 err2:
 297         edac_pci_del_device(&op->dev);
 298 err:
 299         edac_pci_free_ctl_info(pci);
 300         devres_release_group(&op->dev, mpc85xx_pci_err_probe);
 301         return res;
 302 }
 303
 304 static int mpc85xx_pci_err_remove(struct platform_device *op)
 305 {
 306         struct edac_pci_ctl_info *pci = dev_get_drvdata(&op->dev);
 307         struct mpc85xx_pci_pdata *pdata = pci->pvt_info;
 308
 309         edac_dbg(0, "\n");
 310
 311         out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_ADDR, orig_pci_err_cap_dr);
 312         out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_EN, orig_pci_err_en);
 313
 314         edac_pci_del_device(&op->dev);
 315         edac_pci_free_ctl_info(pci);
 316
 317         return 0;
 318 }
 319
 320 static const struct platform_device_id mpc85xx_pci_err_match[] = {
 321         {
 322                 .name = "mpc85xx-pci-edac"
 323         },
 324         {}
 325 };
 326
 327 static struct platform_driver mpc85xx_pci_err_driver = {
 328         .probe = mpc85xx_pci_err_probe,
 329         .remove = mpc85xx_pci_err_remove,
 330         .id_table = mpc85xx_pci_err_match,
 331         .driver = {
 332                 .name = "mpc85xx_pci_err",
 333                 .suppress_bind_attrs = true,
 334         },
 335 };
 336 #endif                          /* CONFIG_PCI */
 337
 338 /**************************** L2 Err device ***************************/
 339
 340 /************************ L2 SYSFS parts ***********************************/
 341
 342 static ssize_t mpc85xx_l2_inject_data_hi_show(struct edac_device_ctl_info
 343                                               *edac_dev, char *data)
 344 {
 345         struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info;
 346         return sprintf(data, "0x%08x",
 347                        in_be32(pdata->l2_vbase + MPC85XX_L2_ERRINJHI));
 348 }
 349
 350 static ssize_t mpc85xx_l2_inject_data_lo_show(struct edac_device_ctl_info
 351                                               *edac_dev, char *data)
 352 {
 353         struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info;
 354         return sprintf(data, "0x%08x",
 355                        in_be32(pdata->l2_vbase + MPC85XX_L2_ERRINJLO));
 356 }
 357
 358 static ssize_t mpc85xx_l2_inject_ctrl_show(struct edac_device_ctl_info
 359                                            *edac_dev, char *data)
 360 {
 361         struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info;
 362         return sprintf(data, "0x%08x",
 363                        in_be32(pdata->l2_vbase + MPC85XX_L2_ERRINJCTL));
 364 }
 365
 366 static ssize_t mpc85xx_l2_inject_data_hi_store(struct edac_device_ctl_info
 367                                                *edac_dev, const char *data,
 368                                                size_t count)
 369 {
 370         struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info;
 371         if (isdigit(*data)) {
 372                 out_be32(pdata->l2_vbase + MPC85XX_L2_ERRINJHI,
 373                          simple_strtoul(data, NULL, 0));
 374                 return count;
 375         }
 376         return 0;
 377 }
 378
 379 static ssize_t mpc85xx_l2_inject_data_lo_store(struct edac_device_ctl_info
 380                                                *edac_dev, const char *data,
 381                                                size_t count)
 382 {
 383         struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info;
 384         if (isdigit(*data)) {
 385                 out_be32(pdata->l2_vbase + MPC85XX_L2_ERRINJLO,
 386                          simple_strtoul(data, NULL, 0));
 387                 return count;
 388         }
 389         return 0;
 390 }
 391
 392 static ssize_t mpc85xx_l2_inject_ctrl_store(struct edac_device_ctl_info
 393                                             *edac_dev, const char *data,
 394                                             size_t count)
 395 {
 396         struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info;
 397         if (isdigit(*data)) {
 398                 out_be32(pdata->l2_vbase + MPC85XX_L2_ERRINJCTL,
 399                          simple_strtoul(data, NULL, 0));
 400                 return count;
 401         }
 402         return 0;
 403 }
 404
 405 static struct edac_dev_sysfs_attribute mpc85xx_l2_sysfs_attributes[] = {
 406         {
 407          .attr = {
 408                   .name = "inject_data_hi",
 409                   .mode = (S_IRUGO | S_IWUSR)
 410                   },
 411          .show = mpc85xx_l2_inject_data_hi_show,
 412          .store = mpc85xx_l2_inject_data_hi_store},
 413         {
 414          .attr = {
 415                   .name = "inject_data_lo",
 416                   .mode = (S_IRUGO | S_IWUSR)
 417                   },
 418          .show = mpc85xx_l2_inject_data_lo_show,
 419          .store = mpc85xx_l2_inject_data_lo_store},
 420         {
 421          .attr = {
 422                   .name = "inject_ctrl",
 423                   .mode = (S_IRUGO | S_IWUSR)
 424                   },
 425          .show = mpc85xx_l2_inject_ctrl_show,
 426          .store = mpc85xx_l2_inject_ctrl_store},
 427
 428         /* End of list */
 429         {
 430          .attr = {.name = NULL}
 431          }
 432 };
 433
 434 static void mpc85xx_set_l2_sysfs_attributes(struct edac_device_ctl_info
 435                                             *edac_dev)
 436 {
 437         edac_dev->sysfs_attributes = mpc85xx_l2_sysfs_attributes;
 438 }
 439
 440 /***************************** L2 ops ***********************************/
 441
 442 static void mpc85xx_l2_check(struct edac_device_ctl_info *edac_dev)
 443 {
 444         struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info;
 445         u32 err_detect;
 446
 447         err_detect = in_be32(pdata->l2_vbase + MPC85XX_L2_ERRDET);
 448
 449         if (!(err_detect & L2_EDE_MASK))
 450                 return;
 451
 452         pr_err("ECC Error in CPU L2 cache\n");
 453         pr_err("L2 Error Detect Register: 0x%08x\n", err_detect);
 454         pr_err("L2 Error Capture Data High Register: 0x%08x\n",
 455                in_be32(pdata->l2_vbase + MPC85XX_L2_CAPTDATAHI));
 456         pr_err("L2 Error Capture Data Lo Register: 0x%08x\n",
 457                in_be32(pdata->l2_vbase + MPC85XX_L2_CAPTDATALO));
 458         pr_err("L2 Error Syndrome Register: 0x%08x\n",
 459                in_be32(pdata->l2_vbase + MPC85XX_L2_CAPTECC));
 460         pr_err("L2 Error Attributes Capture Register: 0x%08x\n",
 461                in_be32(pdata->l2_vbase + MPC85XX_L2_ERRATTR));
 462         pr_err("L2 Error Address Capture Register: 0x%08x\n",
 463                in_be32(pdata->l2_vbase + MPC85XX_L2_ERRADDR));
 464
 465         /* clear error detect register */
 466         out_be32(pdata->l2_vbase + MPC85XX_L2_ERRDET, err_detect);
 467
 468         if (err_detect & L2_EDE_CE_MASK)
 469                 edac_device_handle_ce(edac_dev, 0, 0, edac_dev->ctl_name);
 470
 471         if (err_detect & L2_EDE_UE_MASK)
 472                 edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name);
 473 }
 474
 475 static irqreturn_t mpc85xx_l2_isr(int irq, void *dev_id)
 476 {
 477         struct edac_device_ctl_info *edac_dev = dev_id;
 478         struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info;
 479         u32 err_detect;
 480
 481         err_detect = in_be32(pdata->l2_vbase + MPC85XX_L2_ERRDET);
 482
 483         if (!(err_detect & L2_EDE_MASK))
 484                 return IRQ_NONE;
 485
 486         mpc85xx_l2_check(edac_dev);
 487
 488         return IRQ_HANDLED;
 489 }
 490
 491 static int mpc85xx_l2_err_probe(struct platform_device *op)
 492 {
 493         struct edac_device_ctl_info *edac_dev;
 494         struct mpc85xx_l2_pdata *pdata;
 495         struct resource r;
 496         int res;
 497
 498         if (!devres_open_group(&op->dev, mpc85xx_l2_err_probe, GFP_KERNEL))
 499                 return -ENOMEM;
 500
 501         edac_dev = edac_device_alloc_ctl_info(sizeof(*pdata),
 502                                               "cpu", 1, "L", 1, 2, NULL, 0,
 503                                               edac_dev_idx);
 504         if (!edac_dev) {
 505                 devres_release_group(&op->dev, mpc85xx_l2_err_probe);
 506                 return -ENOMEM;
 507         }
 508
 509         pdata = edac_dev->pvt_info;
 510         pdata->name = "mpc85xx_l2_err";
 511         edac_dev->dev = &op->dev;
 512         dev_set_drvdata(edac_dev->dev, edac_dev);
 513         edac_dev->ctl_name = pdata->name;
 514         edac_dev->dev_name = pdata->name;
 515
 516         res = of_address_to_resource(op->dev.of_node, 0, &r);
 517         if (res) {
 518                 pr_err("%s: Unable to get resource for L2 err regs\n", __func__);
 519                 goto err;
 520         }
 521
 522         /* we only need the error registers */
 523         r.start += 0xe00;
 524
 525         if (!devm_request_mem_region(&op->dev, r.start, resource_size(&r),
 526                                      pdata->name)) {
 527                 pr_err("%s: Error while requesting mem region\n", __func__);
 528                 res = -EBUSY;
 529                 goto err;
 530         }
 531
 532         pdata->l2_vbase = devm_ioremap(&op->dev, r.start, resource_size(&r));
 533         if (!pdata->l2_vbase) {
 534                 pr_err("%s: Unable to setup L2 err regs\n", __func__);
 535                 res = -ENOMEM;
 536                 goto err;
 537         }
 538
 539         out_be32(pdata->l2_vbase + MPC85XX_L2_ERRDET, ~0);
 540
 541         orig_l2_err_disable = in_be32(pdata->l2_vbase + MPC85XX_L2_ERRDIS);
 542
 543         /* clear the err_dis */
 544         out_be32(pdata->l2_vbase + MPC85XX_L2_ERRDIS, 0);
 545
 546         edac_dev->mod_name = EDAC_MOD_STR;
 547
 548         if (edac_op_state == EDAC_OPSTATE_POLL)
 549                 edac_dev->edac_check = mpc85xx_l2_check;
 550
 551         mpc85xx_set_l2_sysfs_attributes(edac_dev);
 552
 553         pdata->edac_idx = edac_dev_idx++;
 554
 555         if (edac_device_add_device(edac_dev) > 0) {
 556                 edac_dbg(3, "failed edac_device_add_device()\n");
 557                 goto err;
 558         }
 559
 560         if (edac_op_state == EDAC_OPSTATE_INT) {
 561                 pdata->irq = irq_of_parse_and_map(op->dev.of_node, 0);
 562                 res = devm_request_irq(&op->dev, pdata->irq,
 563                                        mpc85xx_l2_isr, IRQF_SHARED,
 564                                        "[EDAC] L2 err", edac_dev);
 565                 if (res < 0) {
 566                         pr_err("%s: Unable to request irq %d for MPC85xx L2 err\n",
 567                                 __func__, pdata->irq);
 568                         irq_dispose_mapping(pdata->irq);
 569                         res = -ENODEV;
 570                         goto err2;
 571                 }
 572
 573                 pr_info(EDAC_MOD_STR " acquired irq %d for L2 Err\n", pdata->irq);
 574
 575                 edac_dev->op_state = OP_RUNNING_INTERRUPT;
 576
 577                 out_be32(pdata->l2_vbase + MPC85XX_L2_ERRINTEN, L2_EIE_MASK);
 578         }
 579
 580         devres_remove_group(&op->dev, mpc85xx_l2_err_probe);
 581
 582         edac_dbg(3, "success\n");
 583         pr_info(EDAC_MOD_STR " L2 err registered\n");
 584
 585         return 0;
 586
 587 err2:
 588         edac_device_del_device(&op->dev);
 589 err:
 590         devres_release_group(&op->dev, mpc85xx_l2_err_probe);
 591         edac_device_free_ctl_info(edac_dev);
 592         return res;
 593 }
 594
 595 static int mpc85xx_l2_err_remove(struct platform_device *op)
 596 {
 597         struct edac_device_ctl_info *edac_dev = dev_get_drvdata(&op->dev);
 598         struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info;
 599
 600         edac_dbg(0, "\n");
 601
 602         if (edac_op_state == EDAC_OPSTATE_INT) {
 603                 out_be32(pdata->l2_vbase + MPC85XX_L2_ERRINTEN, 0);
 604                 irq_dispose_mapping(pdata->irq);
 605         }
 606
 607         out_be32(pdata->l2_vbase + MPC85XX_L2_ERRDIS, orig_l2_err_disable);
 608         edac_device_del_device(&op->dev);
 609         edac_device_free_ctl_info(edac_dev);
 610         return 0;
 611 }
 612
 613 static const struct of_device_id mpc85xx_l2_err_of_match[] = {
 614         { .compatible = "fsl,mpc8536-l2-cache-controller", },
 615         { .compatible = "fsl,mpc8540-l2-cache-controller", },
 616         { .compatible = "fsl,mpc8541-l2-cache-controller", },
 617         { .compatible = "fsl,mpc8544-l2-cache-controller", },
 618         { .compatible = "fsl,mpc8548-l2-cache-controller", },
 619         { .compatible = "fsl,mpc8555-l2-cache-controller", },
 620         { .compatible = "fsl,mpc8560-l2-cache-controller", },
 621         { .compatible = "fsl,mpc8568-l2-cache-controller", },
 622         { .compatible = "fsl,mpc8569-l2-cache-controller", },
 623         { .compatible = "fsl,mpc8572-l2-cache-controller", },
 624         { .compatible = "fsl,p1020-l2-cache-controller", },
 625         { .compatible = "fsl,p1021-l2-cache-controller", },
 626         { .compatible = "fsl,p2020-l2-cache-controller", },
 627         { .compatible = "fsl,t2080-l2-cache-controller", },
 628         {},
 629 };
 630 MODULE_DEVICE_TABLE(of, mpc85xx_l2_err_of_match);
 631
 632 static struct platform_driver mpc85xx_l2_err_driver = {
 633         .probe = mpc85xx_l2_err_probe,
 634         .remove = mpc85xx_l2_err_remove,
 635         .driver = {
 636                 .name = "mpc85xx_l2_err",
 637                 .of_match_table = mpc85xx_l2_err_of_match,
 638         },
 639 };
 640
 641 static const struct of_device_id mpc85xx_mc_err_of_match[] = {
 642         { .compatible = "fsl,mpc8536-memory-controller", },
 643         { .compatible = "fsl,mpc8540-memory-controller", },
 644         { .compatible = "fsl,mpc8541-memory-controller", },
 645         { .compatible = "fsl,mpc8544-memory-controller", },
 646         { .compatible = "fsl,mpc8548-memory-controller", },
 647         { .compatible = "fsl,mpc8555-memory-controller", },
 648         { .compatible = "fsl,mpc8560-memory-controller", },
 649         { .compatible = "fsl,mpc8568-memory-controller", },
 650         { .compatible = "fsl,mpc8569-memory-controller", },
 651         { .compatible = "fsl,mpc8572-memory-controller", },
 652         { .compatible = "fsl,mpc8349-memory-controller", },
 653         { .compatible = "fsl,p1020-memory-controller", },
 654         { .compatible = "fsl,p1021-memory-controller", },
 655         { .compatible = "fsl,p2020-memory-controller", },
 656         { .compatible = "fsl,qoriq-memory-controller", },
 657         {},
 658 };
 659 MODULE_DEVICE_TABLE(of, mpc85xx_mc_err_of_match);
 660
 661 static struct platform_driver mpc85xx_mc_err_driver = {
 662         .probe = fsl_mc_err_probe,
 663         .remove = fsl_mc_err_remove,
 664         .driver = {
 665                 .name = "mpc85xx_mc_err",
 666                 .of_match_table = mpc85xx_mc_err_of_match,
 667         },
 668 };
 669
 670 static struct platform_driver * const drivers[] = {
 671         &mpc85xx_mc_err_driver,
 672         &mpc85xx_l2_err_driver,
 673 #ifdef CONFIG_PCI
 674         &mpc85xx_pci_err_driver,
 675 #endif
 676 };
 677
 678 static int __init mpc85xx_mc_init(void)
 679 {
 680         int res = 0;
 681         u32 __maybe_unused pvr = 0;
 682
 683         pr_info("Freescale(R) MPC85xx EDAC driver, (C) 2006 Montavista Software\n");
 684
 685         /* make sure error reporting method is sane */
 686         switch (edac_op_state) {
 687         case EDAC_OPSTATE_POLL:
 688         case EDAC_OPSTATE_INT:
 689                 break;
 690         default:
 691                 edac_op_state = EDAC_OPSTATE_INT;
 692                 break;
 693         }
 694
 695         res = platform_register_drivers(drivers, ARRAY_SIZE(drivers));
 696         if (res)
 697                 pr_warn(EDAC_MOD_STR "drivers fail to register\n");
 698
 699         return 0;
 700 }
 701
 702 module_init(mpc85xx_mc_init);
 703
 704 static void __exit mpc85xx_mc_exit(void)
 705 {
 706         platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
 707 }
 708
 709 module_exit(mpc85xx_mc_exit);
 710
 711 MODULE_LICENSE("GPL");
 712 MODULE_AUTHOR("Montavista Software, Inc.");
 713 module_param(edac_op_state, int, 0444);
 714 MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll, 2=Interrupt");