Merge branch 'upstream' of git://git.linux-mips.org/pub/scm/ralf/upstream-linus

Pull MIPS updates from Ralf Baechle:
 "The MIPS bits for 3.8.  This also includes a bunch fixes that were
  sitting in the linux-mips.org git tree for a long time.  This pull
  request contains updates to several OCTEON drivers and the board
  support code for BCM47XX, BCM63XX, XLP, XLR, XLS, lantiq, Loongson1B,
  updates to the SSB bus support, MIPS kexec code and adds support for
  kdump.

  When pulling this, there are two expected merge conflicts in
  include/linux/bcma/bcma_driver_chipcommon.h which are trivial to
  resolve, just remove the conflict markers and keep both alternatives."

* 'upstream' of git://git.linux-mips.org/pub/scm/ralf/upstream-linus: (90 commits)
  MIPS: PMC-Sierra Yosemite: Remove support.
  VIDEO: Newport Fix console crashes
  MIPS: wrppmc: Fix build of PCI code.
  MIPS: IP22/IP28: Fix build of EISA code.
  MIPS: RB532: Fix build of prom code.
  MIPS: PowerTV: Fix build.
  MIPS: IP27: Correct fucked grammar in ops-bridge.c
  MIPS: Highmem: Fix build error if CONFIG_DEBUG_HIGHMEM is disabled
  MIPS: Fix potencial corruption
  MIPS: Fix for warning from FPU emulation code
  MIPS: Handle COP3 Unusable exception as COP1X for FP emulation
  MIPS: Fix poweroff failure when HOTPLUG_CPU configured.
  MIPS: MT: Fix build with CONFIG_UIDGID_STRICT_TYPE_CHECKS=y
  MIPS: Remove unused smvp.h
  MIPS/EDAC: Improve OCTEON EDAC support.
  MIPS: OCTEON: Add definitions for OCTEON memory contoller registers.
  MIPS: OCTEON: Add OCTEON family definitions to octeon-model.h
  ata: pata_octeon_cf: Use correct byte order for DMA in when built little-endian.
  MIPS/OCTEON/ata: Convert pata_octeon_cf.c to use device tree.
  MIPS: Remove usage of CEVT_R4K_LIB config option.
  ...

6 files changed, 685 insertions, 1 deletions

diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig
index bb82d6be793c..4c6c876d9dc3 100644
--- a/drivers/edac/Kconfig
+++ b/drivers/edac/Kconfig
@@ -7,7 +7,7 @@
 menuconfig EDAC
         bool "EDAC (Error Detection And Correction) reporting"
         depends on HAS_IOMEM
-        depends on X86 || PPC || TILE || ARM
+        depends on X86 || PPC || TILE || ARM || EDAC_SUPPORT
         help
           EDAC is designed to report errors in the core system.
           These are low-level errors that are reported in the CPU or
@@ -27,6 +27,9 @@ menuconfig EDAC
           There is also a mailing list for the EDAC project, which can
           be found via the sourceforge page.
 
+config EDAC_SUPPORT
+        bool
+
 if EDAC
 
 comment "Reporting subsystems"
@@ -316,4 +319,32 @@ config EDAC_HIGHBANK_L2
           Support for error detection and correction on the
           Calxeda Highbank memory controller.
 
+config EDAC_OCTEON_PC
+        tristate "Cavium Octeon Primary Caches"
+        depends on EDAC_MM_EDAC && CPU_CAVIUM_OCTEON
+        help
+          Support for error detection and correction on the primary caches of
+          the cnMIPS cores of Cavium Octeon family SOCs.
+
+config EDAC_OCTEON_L2C
+        tristate "Cavium Octeon Secondary Caches (L2C)"
+        depends on EDAC_MM_EDAC && CPU_CAVIUM_OCTEON
+        help
+          Support for error detection and correction on the
+          Cavium Octeon family of SOCs.
+
+config EDAC_OCTEON_LMC
+        tristate "Cavium Octeon DRAM Memory Controller (LMC)"
+        depends on EDAC_MM_EDAC && CPU_CAVIUM_OCTEON
+        help
+          Support for error detection and correction on the
+          Cavium Octeon family of SOCs.
+
+config EDAC_OCTEON_PCI
+        tristate "Cavium Octeon PCI Controller"
+        depends on EDAC_MM_EDAC && PCI && CPU_CAVIUM_OCTEON
+        help
+          Support for error detection and correction on the
+          Cavium Octeon family of SOCs.
+
 endif # EDAC
diff --git a/drivers/edac/Makefile b/drivers/edac/Makefile
index 7e5129a733f8..5608a9ba61b7 100644
--- a/drivers/edac/Makefile
+++ b/drivers/edac/Makefile
@@ -58,3 +58,8 @@ obj-$(CONFIG_EDAC_TILE)			+= tile_edac.o
 
 obj-$(CONFIG_EDAC_HIGHBANK_MC)  += highbank_mc_edac.o
 obj-$(CONFIG_EDAC_HIGHBANK_L2)  += highbank_l2_edac.o
+
+obj-$(CONFIG_EDAC_OCTEON_PC)            += octeon_edac-pc.o
+obj-$(CONFIG_EDAC_OCTEON_L2C)           += octeon_edac-l2c.o
+obj-$(CONFIG_EDAC_OCTEON_LMC)           += octeon_edac-lmc.o
+obj-$(CONFIG_EDAC_OCTEON_PCI)           += octeon_edac-pci.o
diff --git a/drivers/edac/octeon_edac-l2c.c b/drivers/edac/octeon_edac-l2c.c
new file mode 100644
index 000000000000..40fde6a51ed6
--- /dev/null
+++ b/drivers/edac/octeon_edac-l2c.c
@@ -0,0 +1,208 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2012 Cavium, Inc.
+ *
+ * Copyright (C) 2009 Wind River Systems,
+ *   written by Ralf Baechle <ralf@linux-mips.org>
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+#include <linux/edac.h>
+
+#include <asm/octeon/cvmx.h>
+
+#include "edac_core.h"
+#include "edac_module.h"
+
+#define EDAC_MOD_STR "octeon-l2c"
+
+static void octeon_l2c_poll_oct1(struct edac_device_ctl_info *l2c)
+{
+        union cvmx_l2t_err l2t_err, l2t_err_reset;
+        union cvmx_l2d_err l2d_err, l2d_err_reset;
+
+        l2t_err_reset.u64 = 0;
+        l2t_err.u64 = cvmx_read_csr(CVMX_L2T_ERR);
+        if (l2t_err.s.sec_err) {
+                edac_device_handle_ce(l2c, 0, 0,
+                                      "Tag Single bit error (corrected)");
+                l2t_err_reset.s.sec_err = 1;
+        }
+        if (l2t_err.s.ded_err) {
+                edac_device_handle_ue(l2c, 0, 0,
+                                      "Tag Double bit error (detected)");
+                l2t_err_reset.s.ded_err = 1;
+        }
+        if (l2t_err_reset.u64)
+                cvmx_write_csr(CVMX_L2T_ERR, l2t_err_reset.u64);
+
+        l2d_err_reset.u64 = 0;
+        l2d_err.u64 = cvmx_read_csr(CVMX_L2D_ERR);
+        if (l2d_err.s.sec_err) {
+                edac_device_handle_ce(l2c, 0, 1,
+                                      "Data Single bit error (corrected)");
+                l2d_err_reset.s.sec_err = 1;
+        }
+        if (l2d_err.s.ded_err) {
+                edac_device_handle_ue(l2c, 0, 1,
+                                      "Data Double bit error (detected)");
+                l2d_err_reset.s.ded_err = 1;
+        }
+        if (l2d_err_reset.u64)
+                cvmx_write_csr(CVMX_L2D_ERR, l2d_err_reset.u64);
+
+}
+
+static void _octeon_l2c_poll_oct2(struct edac_device_ctl_info *l2c, int tad)
+{
+        union cvmx_l2c_err_tdtx err_tdtx, err_tdtx_reset;
+        union cvmx_l2c_err_ttgx err_ttgx, err_ttgx_reset;
+        char buf1[64];
+        char buf2[80];
+
+        err_tdtx_reset.u64 = 0;
+        err_tdtx.u64 = cvmx_read_csr(CVMX_L2C_ERR_TDTX(tad));
+        if (err_tdtx.s.dbe || err_tdtx.s.sbe ||
+            err_tdtx.s.vdbe || err_tdtx.s.vsbe)
+                snprintf(buf1, sizeof(buf1),
+                         "type:%d, syn:0x%x, way:%d",
+                         err_tdtx.s.type, err_tdtx.s.syn, err_tdtx.s.wayidx);
+
+        if (err_tdtx.s.dbe) {
+                snprintf(buf2, sizeof(buf2),
+                         "L2D Double bit error (detected):%s", buf1);
+                err_tdtx_reset.s.dbe = 1;
+                edac_device_handle_ue(l2c, tad, 1, buf2);
+        }
+        if (err_tdtx.s.sbe) {
+                snprintf(buf2, sizeof(buf2),
+                         "L2D Single bit error (corrected):%s", buf1);
+                err_tdtx_reset.s.sbe = 1;
+                edac_device_handle_ce(l2c, tad, 1, buf2);
+        }
+        if (err_tdtx.s.vdbe) {
+                snprintf(buf2, sizeof(buf2),
+                         "VBF Double bit error (detected):%s", buf1);
+                err_tdtx_reset.s.vdbe = 1;
+                edac_device_handle_ue(l2c, tad, 1, buf2);
+        }
+        if (err_tdtx.s.vsbe) {
+                snprintf(buf2, sizeof(buf2),
+                         "VBF Single bit error (corrected):%s", buf1);
+                err_tdtx_reset.s.vsbe = 1;
+                edac_device_handle_ce(l2c, tad, 1, buf2);
+        }
+        if (err_tdtx_reset.u64)
+                cvmx_write_csr(CVMX_L2C_ERR_TDTX(tad), err_tdtx_reset.u64);
+
+        err_ttgx_reset.u64 = 0;
+        err_ttgx.u64 = cvmx_read_csr(CVMX_L2C_ERR_TTGX(tad));
+
+        if (err_ttgx.s.dbe || err_ttgx.s.sbe)
+                snprintf(buf1, sizeof(buf1),
+                         "type:%d, syn:0x%x, way:%d",
+                         err_ttgx.s.type, err_ttgx.s.syn, err_ttgx.s.wayidx);
+
+        if (err_ttgx.s.dbe) {
+                snprintf(buf2, sizeof(buf2),
+                         "Tag Double bit error (detected):%s", buf1);
+                err_ttgx_reset.s.dbe = 1;
+                edac_device_handle_ue(l2c, tad, 0, buf2);
+        }
+        if (err_ttgx.s.sbe) {
+                snprintf(buf2, sizeof(buf2),
+                         "Tag Single bit error (corrected):%s", buf1);
+                err_ttgx_reset.s.sbe = 1;
+                edac_device_handle_ce(l2c, tad, 0, buf2);
+        }
+        if (err_ttgx_reset.u64)
+                cvmx_write_csr(CVMX_L2C_ERR_TTGX(tad), err_ttgx_reset.u64);
+}
+
+static void octeon_l2c_poll_oct2(struct edac_device_ctl_info *l2c)
+{
+        int i;
+        for (i = 0; i < l2c->nr_instances; i++)
+                _octeon_l2c_poll_oct2(l2c, i);
+}
+
+static int __devinit octeon_l2c_probe(struct platform_device *pdev)
+{
+        struct edac_device_ctl_info *l2c;
+
+        int num_tads = OCTEON_IS_MODEL(OCTEON_CN68XX) ? 4 : 1;
+
+        /* 'Tags' are block 0, 'Data' is block 1*/
+        l2c = edac_device_alloc_ctl_info(0, "l2c", num_tads, "l2c", 2, 0,
+                                         NULL, 0, edac_device_alloc_index());
+        if (!l2c)
+                return -ENOMEM;
+
+        l2c->dev = &pdev->dev;
+        platform_set_drvdata(pdev, l2c);
+        l2c->dev_name = dev_name(&pdev->dev);
+
+        l2c->mod_name = "octeon-l2c";
+        l2c->ctl_name = "octeon_l2c_err";
+
+
+        if (OCTEON_IS_MODEL(OCTEON_FAM_1_PLUS)) {
+                union cvmx_l2t_err l2t_err;
+                union cvmx_l2d_err l2d_err;
+
+                l2t_err.u64 = cvmx_read_csr(CVMX_L2T_ERR);
+                l2t_err.s.sec_intena = 0;       /* We poll */
+                l2t_err.s.ded_intena = 0;
+                cvmx_write_csr(CVMX_L2T_ERR, l2t_err.u64);
+
+                l2d_err.u64 = cvmx_read_csr(CVMX_L2D_ERR);
+                l2d_err.s.sec_intena = 0;       /* We poll */
+                l2d_err.s.ded_intena = 0;
+                cvmx_write_csr(CVMX_L2T_ERR, l2d_err.u64);
+
+                l2c->edac_check = octeon_l2c_poll_oct1;
+        } else {
+                /* OCTEON II */
+                l2c->edac_check = octeon_l2c_poll_oct2;
+        }
+
+        if (edac_device_add_device(l2c) > 0) {
+                pr_err("%s: edac_device_add_device() failed\n", __func__);
+                goto err;
+        }
+
+
+        return 0;
+
+err:
+        edac_device_free_ctl_info(l2c);
+
+        return -ENXIO;
+}
+
+static int octeon_l2c_remove(struct platform_device *pdev)
+{
+        struct edac_device_ctl_info *l2c = platform_get_drvdata(pdev);
+
+        edac_device_del_device(&pdev->dev);
+        edac_device_free_ctl_info(l2c);
+
+        return 0;
+}
+
+static struct platform_driver octeon_l2c_driver = {
+        .probe = octeon_l2c_probe,
+        .remove = octeon_l2c_remove,
+        .driver = {
+                   .name = "octeon_l2c_edac",
+        }
+};
+module_platform_driver(octeon_l2c_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Ralf Baechle <ralf@linux-mips.org>");
diff --git a/drivers/edac/octeon_edac-lmc.c b/drivers/edac/octeon_edac-lmc.c
new file mode 100644
index 000000000000..33bca766e37d
--- /dev/null
+++ b/drivers/edac/octeon_edac-lmc.c
@@ -0,0 +1,186 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2009 Wind River Systems,
+ *   written by Ralf Baechle <ralf@linux-mips.org>
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+#include <linux/edac.h>
+
+#include <asm/octeon/octeon.h>
+#include <asm/octeon/cvmx-lmcx-defs.h>
+
+#include "edac_core.h"
+#include "edac_module.h"
+
+#define OCTEON_MAX_MC 4
+
+static void octeon_lmc_edac_poll(struct mem_ctl_info *mci)
+{
+        union cvmx_lmcx_mem_cfg0 cfg0;
+        bool do_clear = false;
+        char msg[64];
+
+        cfg0.u64 = cvmx_read_csr(CVMX_LMCX_MEM_CFG0(mci->mc_idx));
+        if (cfg0.s.sec_err || cfg0.s.ded_err) {
+                union cvmx_lmcx_fadr fadr;
+                fadr.u64 = cvmx_read_csr(CVMX_LMCX_FADR(mci->mc_idx));
+                snprintf(msg, sizeof(msg),
+                         "DIMM %d rank %d bank %d row %d col %d",
+                         fadr.cn30xx.fdimm, fadr.cn30xx.fbunk,
+                         fadr.cn30xx.fbank, fadr.cn30xx.frow, fadr.cn30xx.fcol);
+        }
+
+        if (cfg0.s.sec_err) {
+                edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, 1, 0, 0, 0,
+                                     -1, -1, -1, msg, "");
+                cfg0.s.sec_err = -1;    /* Done, re-arm */
+                do_clear = true;
+        }
+
+        if (cfg0.s.ded_err) {
+                edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci, 1, 0, 0, 0,
+                                     -1, -1, -1, msg, "");
+                cfg0.s.ded_err = -1;    /* Done, re-arm */
+                do_clear = true;
+        }
+        if (do_clear)
+                cvmx_write_csr(CVMX_LMCX_MEM_CFG0(mci->mc_idx), cfg0.u64);
+}
+
+static void octeon_lmc_edac_poll_o2(struct mem_ctl_info *mci)
+{
+        union cvmx_lmcx_int int_reg;
+        bool do_clear = false;
+        char msg[64];
+
+        int_reg.u64 = cvmx_read_csr(CVMX_LMCX_INT(mci->mc_idx));
+        if (int_reg.s.sec_err || int_reg.s.ded_err) {
+                union cvmx_lmcx_fadr fadr;
+                fadr.u64 = cvmx_read_csr(CVMX_LMCX_FADR(mci->mc_idx));
+                snprintf(msg, sizeof(msg),
+                         "DIMM %d rank %d bank %d row %d col %d",
+                         fadr.cn61xx.fdimm, fadr.cn61xx.fbunk,
+                         fadr.cn61xx.fbank, fadr.cn61xx.frow, fadr.cn61xx.fcol);
+        }
+
+        if (int_reg.s.sec_err) {
+                edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, 1, 0, 0, 0,
+                                     -1, -1, -1, msg, "");
+                int_reg.s.sec_err = -1; /* Done, re-arm */
+                do_clear = true;
+        }
+
+        if (int_reg.s.ded_err) {
+                edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci, 1, 0, 0, 0,
+                                     -1, -1, -1, msg, "");
+                int_reg.s.ded_err = -1; /* Done, re-arm */
+                do_clear = true;
+        }
+        if (do_clear)
+                cvmx_write_csr(CVMX_LMCX_INT(mci->mc_idx), int_reg.u64);
+}
+
+static int __devinit octeon_lmc_edac_probe(struct platform_device *pdev)
+{
+        struct mem_ctl_info *mci;
+        struct edac_mc_layer layers[1];
+        int mc = pdev->id;
+
+        layers[0].type = EDAC_MC_LAYER_CHANNEL;
+        layers[0].size = 1;
+        layers[0].is_virt_csrow = false;
+
+        if (OCTEON_IS_MODEL(OCTEON_FAM_1_PLUS)) {
+                union cvmx_lmcx_mem_cfg0 cfg0;
+
+                cfg0.u64 = cvmx_read_csr(CVMX_LMCX_MEM_CFG0(0));
+                if (!cfg0.s.ecc_ena) {
+                        dev_info(&pdev->dev, "Disabled (ECC not enabled)\n");
+                        return 0;
+                }
+
+                mci = edac_mc_alloc(mc, ARRAY_SIZE(layers), layers, 0);
+                if (!mci)
+                        return -ENXIO;
+
+                mci->pdev = &pdev->dev;
+                mci->dev_name = dev_name(&pdev->dev);
+
+                mci->mod_name = "octeon-lmc";
+                mci->ctl_name = "octeon-lmc-err";
+                mci->edac_check = octeon_lmc_edac_poll;
+
+                if (edac_mc_add_mc(mci)) {
+                        dev_err(&pdev->dev, "edac_mc_add_mc() failed\n");
+                        edac_mc_free(mci);
+                        return -ENXIO;
+                }
+
+                cfg0.u64 = cvmx_read_csr(CVMX_LMCX_MEM_CFG0(mc));
+                cfg0.s.intr_ded_ena = 0;        /* We poll */
+                cfg0.s.intr_sec_ena = 0;
+                cvmx_write_csr(CVMX_LMCX_MEM_CFG0(mc), cfg0.u64);
+        } else {
+                /* OCTEON II */
+                union cvmx_lmcx_int_en en;
+                union cvmx_lmcx_config config;
+
+                config.u64 = cvmx_read_csr(CVMX_LMCX_CONFIG(0));
+                if (!config.s.ecc_ena) {
+                        dev_info(&pdev->dev, "Disabled (ECC not enabled)\n");
+                        return 0;
+                }
+
+                mci = edac_mc_alloc(mc, ARRAY_SIZE(layers), layers, 0);
+                if (!mci)
+                        return -ENXIO;
+
+                mci->pdev = &pdev->dev;
+                mci->dev_name = dev_name(&pdev->dev);
+
+                mci->mod_name = "octeon-lmc";
+                mci->ctl_name = "co_lmc_err";
+                mci->edac_check = octeon_lmc_edac_poll_o2;
+
+                if (edac_mc_add_mc(mci)) {
+                        dev_err(&pdev->dev, "edac_mc_add_mc() failed\n");
+                        edac_mc_free(mci);
+                        return -ENXIO;
+                }
+
+                en.u64 = cvmx_read_csr(CVMX_LMCX_MEM_CFG0(mc));
+                en.s.intr_ded_ena = 0;  /* We poll */
+                en.s.intr_sec_ena = 0;
+                cvmx_write_csr(CVMX_LMCX_MEM_CFG0(mc), en.u64);
+        }
+        platform_set_drvdata(pdev, mci);
+
+        return 0;
+}
+
+static int octeon_lmc_edac_remove(struct platform_device *pdev)
+{
+        struct mem_ctl_info *mci = platform_get_drvdata(pdev);
+
+        edac_mc_del_mc(&pdev->dev);
+        edac_mc_free(mci);
+        return 0;
+}
+
+static struct platform_driver octeon_lmc_edac_driver = {
+        .probe = octeon_lmc_edac_probe,
+        .remove = octeon_lmc_edac_remove,
+        .driver = {
+                   .name = "octeon_lmc_edac",
+        }
+};
+module_platform_driver(octeon_lmc_edac_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Ralf Baechle <ralf@linux-mips.org>");
diff --git a/drivers/edac/octeon_edac-pc.c b/drivers/edac/octeon_edac-pc.c
new file mode 100644
index 000000000000..14a5e57f2b32
--- /dev/null
+++ b/drivers/edac/octeon_edac-pc.c
@@ -0,0 +1,143 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2012 Cavium, Inc.
+ *
+ * Copyright (C) 2009 Wind River Systems,
+ *   written by Ralf Baechle <ralf@linux-mips.org>
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/edac.h>
+
+#include "edac_core.h"
+#include "edac_module.h"
+
+#include <asm/octeon/cvmx.h>
+#include <asm/mipsregs.h>
+
+extern int register_co_cache_error_notifier(struct notifier_block *nb);
+extern int unregister_co_cache_error_notifier(struct notifier_block *nb);
+
+extern unsigned long long cache_err_dcache[NR_CPUS];
+
+struct co_cache_error {
+        struct notifier_block notifier;
+        struct edac_device_ctl_info *ed;
+};
+
+/**
+ * EDAC CPU cache error callback
+ *
+ * @event: non-zero if unrecoverable.
+ */
+static int  co_cache_error_event(struct notifier_block *this,
+        unsigned long event, void *ptr)
+{
+        struct co_cache_error *p = container_of(this, struct co_cache_error,
+                                                notifier);
+
+        unsigned int core = cvmx_get_core_num();
+        unsigned int cpu = smp_processor_id();
+        u64 icache_err = read_octeon_c0_icacheerr();
+        u64 dcache_err;
+
+        if (event) {
+                dcache_err = cache_err_dcache[core];
+                cache_err_dcache[core] = 0;
+        } else {
+                dcache_err = read_octeon_c0_dcacheerr();
+        }
+
+        if (icache_err & 1) {
+                edac_device_printk(p->ed, KERN_ERR,
+                                   "CacheErr (Icache):%llx, core %d/cpu %d, cp0_errorepc == %lx\n",
+                                   (unsigned long long)icache_err, core, cpu,
+                                   read_c0_errorepc());
+                write_octeon_c0_icacheerr(0);
+                edac_device_handle_ce(p->ed, cpu, 1, "icache");
+        }
+        if (dcache_err & 1) {
+                edac_device_printk(p->ed, KERN_ERR,
+                                   "CacheErr (Dcache):%llx, core %d/cpu %d, cp0_errorepc == %lx\n",
+                                   (unsigned long long)dcache_err, core, cpu,
+                                   read_c0_errorepc());
+                if (event)
+                        edac_device_handle_ue(p->ed, cpu, 0, "dcache");
+                else
+                        edac_device_handle_ce(p->ed, cpu, 0, "dcache");
+
+                /* Clear the error indication */
+                if (OCTEON_IS_MODEL(OCTEON_FAM_2))
+                        write_octeon_c0_dcacheerr(1);
+                else
+                        write_octeon_c0_dcacheerr(0);
+        }
+
+        return NOTIFY_STOP;
+}
+
+static int __devinit co_cache_error_probe(struct platform_device *pdev)
+{
+        struct co_cache_error *p = devm_kzalloc(&pdev->dev, sizeof(*p),
+                                                GFP_KERNEL);
+        if (!p)
+                return -ENOMEM;
+
+        p->notifier.notifier_call = co_cache_error_event;
+        platform_set_drvdata(pdev, p);
+
+        p->ed = edac_device_alloc_ctl_info(0, "cpu", num_possible_cpus(),
+                                           "cache", 2, 0, NULL, 0,
+                                           edac_device_alloc_index());
+        if (!p->ed)
+                goto err;
+
+        p->ed->dev = &pdev->dev;
+
+        p->ed->dev_name = dev_name(&pdev->dev);
+
+        p->ed->mod_name = "octeon-cpu";
+        p->ed->ctl_name = "cache";
+
+        if (edac_device_add_device(p->ed)) {
+                pr_err("%s: edac_device_add_device() failed\n", __func__);
+                goto err1;
+        }
+
+        register_co_cache_error_notifier(&p->notifier);
+
+        return 0;
+
+err1:
+        edac_device_free_ctl_info(p->ed);
+err:
+        return -ENXIO;
+}
+
+static int co_cache_error_remove(struct platform_device *pdev)
+{
+        struct co_cache_error *p = platform_get_drvdata(pdev);
+
+        unregister_co_cache_error_notifier(&p->notifier);
+        edac_device_del_device(&pdev->dev);
+        edac_device_free_ctl_info(p->ed);
+        return 0;
+}
+
+static struct platform_driver co_cache_error_driver = {
+        .probe = co_cache_error_probe,
+        .remove = co_cache_error_remove,
+        .driver = {
+                   .name = "octeon_pc_edac",
+        }
+};
+module_platform_driver(co_cache_error_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Ralf Baechle <ralf@linux-mips.org>");
diff --git a/drivers/edac/octeon_edac-pci.c b/drivers/edac/octeon_edac-pci.c
new file mode 100644
index 000000000000..758c1ef5fc9e
--- /dev/null
+++ b/drivers/edac/octeon_edac-pci.c
@@ -0,0 +1,111 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2012 Cavium, Inc.
+ * Copyright (C) 2009 Wind River Systems,
+ *   written by Ralf Baechle <ralf@linux-mips.org>
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+#include <linux/edac.h>
+
+#include <asm/octeon/cvmx.h>
+#include <asm/octeon/cvmx-npi-defs.h>
+#include <asm/octeon/cvmx-pci-defs.h>
+#include <asm/octeon/octeon.h>
+
+#include "edac_core.h"
+#include "edac_module.h"
+
+static void octeon_pci_poll(struct edac_pci_ctl_info *pci)
+{
+        union cvmx_pci_cfg01 cfg01;
+
+        cfg01.u32 = octeon_npi_read32(CVMX_NPI_PCI_CFG01);
+        if (cfg01.s.dpe) {              /* Detected parity error */
+                edac_pci_handle_pe(pci, pci->ctl_name);
+                cfg01.s.dpe = 1;                /* Reset  */
+                octeon_npi_write32(CVMX_NPI_PCI_CFG01, cfg01.u32);
+        }
+        if (cfg01.s.sse) {
+                edac_pci_handle_npe(pci, "Signaled System Error");
+                cfg01.s.sse = 1;                /* Reset */
+                octeon_npi_write32(CVMX_NPI_PCI_CFG01, cfg01.u32);
+        }
+        if (cfg01.s.rma) {
+                edac_pci_handle_npe(pci, "Received Master Abort");
+                cfg01.s.rma = 1;                /* Reset */
+                octeon_npi_write32(CVMX_NPI_PCI_CFG01, cfg01.u32);
+        }
+        if (cfg01.s.rta) {
+                edac_pci_handle_npe(pci, "Received Target Abort");
+                cfg01.s.rta = 1;                /* Reset */
+                octeon_npi_write32(CVMX_NPI_PCI_CFG01, cfg01.u32);
+        }
+        if (cfg01.s.sta) {
+                edac_pci_handle_npe(pci, "Signaled Target Abort");
+                cfg01.s.sta = 1;                /* Reset */
+                octeon_npi_write32(CVMX_NPI_PCI_CFG01, cfg01.u32);
+        }
+        if (cfg01.s.mdpe) {
+                edac_pci_handle_npe(pci, "Master Data Parity Error");
+                cfg01.s.mdpe = 1;               /* Reset */
+                octeon_npi_write32(CVMX_NPI_PCI_CFG01, cfg01.u32);
+        }
+}
+
+static int __devinit octeon_pci_probe(struct platform_device *pdev)
+{
+        struct edac_pci_ctl_info *pci;
+        int res = 0;
+
+        pci = edac_pci_alloc_ctl_info(0, "octeon_pci_err");
+        if (!pci)
+                return -ENOMEM;
+
+        pci->dev = &pdev->dev;
+        platform_set_drvdata(pdev, pci);
+        pci->dev_name = dev_name(&pdev->dev);
+
+        pci->mod_name = "octeon-pci";
+        pci->ctl_name = "octeon_pci_err";
+        pci->edac_check = octeon_pci_poll;
+
+        if (edac_pci_add_device(pci, 0) > 0) {
+                pr_err("%s: edac_pci_add_device() failed\n", __func__);
+                goto err;
+        }
+
+        return 0;
+
+err:
+        edac_pci_free_ctl_info(pci);
+
+        return res;
+}
+
+static int octeon_pci_remove(struct platform_device *pdev)
+{
+        struct edac_pci_ctl_info *pci = platform_get_drvdata(pdev);
+
+        edac_pci_del_device(&pdev->dev);
+        edac_pci_free_ctl_info(pci);
+
+        return 0;
+}
+
+static struct platform_driver octeon_pci_driver = {
+        .probe = octeon_pci_probe,
+        .remove = octeon_pci_remove,
+        .driver = {
+                   .name = "octeon_pci_edac",
+        }
+};
+module_platform_driver(octeon_pci_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Ralf Baechle <ralf@linux-mips.org>");