1 files changed, 462 insertions, 582 deletions

diff --git a/arch/powerpc/platforms/pseries/eeh.c b/arch/powerpc/platforms/pseries/eeh.c
index c0b40af4ce4..8011088392d 100644
--- a/arch/powerpc/platforms/pseries/eeh.c
+++ b/arch/powerpc/platforms/pseries/eeh.c
@@ -1,8 +1,8 @@
 /*
- * eeh.c
  * Copyright IBM Corporation 2001, 2005, 2006
  * Copyright Dave Engebretsen & Todd Inglett 2001
  * Copyright Linas Vepstas 2005, 2006
+ * Copyright 2001-2012 IBM Corporation.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,7 +22,7 @@
  */
 
 #include <linux/delay.h>
-#include <linux/sched.h>        /* for init_mm */
+#include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/pci.h>
@@ -86,16 +86,8 @@
 /* Time to wait for a PCI slot to report status, in milliseconds */
 #define PCI_BUS_RESET_WAIT_MSEC (60*1000)
 
-/* RTAS tokens */
-static int ibm_set_eeh_option;
-static int ibm_set_slot_reset;
-static int ibm_read_slot_reset_state;
-static int ibm_read_slot_reset_state2;
-static int ibm_slot_error_detail;
-static int ibm_get_config_addr_info;
-static int ibm_get_config_addr_info2;
-static int ibm_configure_bridge;
-static int ibm_configure_pe;
+/* Platform dependent EEH operations */
+struct eeh_ops *eeh_ops = NULL;
 
 int eeh_subsystem_enabled;
 EXPORT_SYMBOL(eeh_subsystem_enabled);
@@ -103,14 +95,6 @@ EXPORT_SYMBOL(eeh_subsystem_enabled);
 /* Lock to avoid races due to multiple reports of an error */
 static DEFINE_RAW_SPINLOCK(confirm_error_lock);
 
-/* Buffer for reporting slot-error-detail rtas calls. Its here
- * in BSS, and not dynamically alloced, so that it ends up in
- * RMO where RTAS can access it.
- */
-static unsigned char slot_errbuf[RTAS_ERROR_LOG_MAX];
-static DEFINE_SPINLOCK(slot_errbuf_lock);
-static int eeh_error_buf_size;
-
 /* Buffer for reporting pci register dumps. Its here in BSS, and
  * not dynamically alloced, so that it ends up in RMO where RTAS
  * can access it.
@@ -118,74 +102,50 @@ static int eeh_error_buf_size;
 #define EEH_PCI_REGS_LOG_LEN 4096
 static unsigned char pci_regs_buf[EEH_PCI_REGS_LOG_LEN];
 
-/* System monitoring statistics */
-static unsigned long no_device;
-static unsigned long no_dn;
-static unsigned long no_cfg_addr;
-static unsigned long ignored_check;
-static unsigned long total_mmio_ffs;
-static unsigned long false_positives;
-static unsigned long slot_resets;
-
-#define IS_BRIDGE(class_code) (((class_code)<<16) == PCI_BASE_CLASS_BRIDGE)
-
-/* --------------------------------------------------------------- */
-/* Below lies the EEH event infrastructure */
+/*
+ * The struct is used to maintain the EEH global statistic
+ * information. Besides, the EEH global statistics will be
+ * exported to user space through procfs
+ */
+struct eeh_stats {
+        u64 no_device;          /* PCI device not found         */
+        u64 no_dn;              /* OF node not found            */
+        u64 no_cfg_addr;        /* Config address not found     */
+        u64 ignored_check;      /* EEH check skipped            */
+        u64 total_mmio_ffs;     /* Total EEH checks             */
+        u64 false_positives;    /* Unnecessary EEH checks       */
+        u64 slot_resets;        /* PE reset                     */
+};
 
-static void rtas_slot_error_detail(struct pci_dn *pdn, int severity,
-                                   char *driver_log, size_t loglen)
-{
-        int config_addr;
-        unsigned long flags;
-        int rc;
+static struct eeh_stats eeh_stats;
 
-        /* Log the error with the rtas logger */
-        spin_lock_irqsave(&slot_errbuf_lock, flags);
-        memset(slot_errbuf, 0, eeh_error_buf_size);
-
-        /* Use PE configuration address, if present */
-        config_addr = pdn->eeh_config_addr;
-        if (pdn->eeh_pe_config_addr)
-                config_addr = pdn->eeh_pe_config_addr;
-
-        rc = rtas_call(ibm_slot_error_detail,
-                       8, 1, NULL, config_addr,
-                       BUID_HI(pdn->phb->buid),
-                       BUID_LO(pdn->phb->buid),
-                       virt_to_phys(driver_log), loglen,
-                       virt_to_phys(slot_errbuf),
-                       eeh_error_buf_size,
-                       severity);
-
-        if (rc == 0)
-                log_error(slot_errbuf, ERR_TYPE_RTAS_LOG, 0);
-        spin_unlock_irqrestore(&slot_errbuf_lock, flags);
-}
+#define IS_BRIDGE(class_code) (((class_code)<<16) == PCI_BASE_CLASS_BRIDGE)
 
 /**
- * gather_pci_data - copy assorted PCI config space registers to buff
- * @pdn: device to report data for
+ * eeh_gather_pci_data - Copy assorted PCI config space registers to buff
+ * @edev: device to report data for
  * @buf: point to buffer in which to log
  * @len: amount of room in buffer
  *
  * This routine captures assorted PCI configuration space data,
  * and puts them into a buffer for RTAS error logging.
  */
-static size_t gather_pci_data(struct pci_dn *pdn, char * buf, size_t len)
+static size_t eeh_gather_pci_data(struct eeh_dev *edev, char * buf, size_t len)
 {
-        struct pci_dev *dev = pdn->pcidev;
+        struct device_node *dn = eeh_dev_to_of_node(edev);
+        struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
         u32 cfg;
         int cap, i;
         int n = 0;
 
-        n += scnprintf(buf+n, len-n, "%s\n", pdn->node->full_name);
-        printk(KERN_WARNING "EEH: of node=%s\n", pdn->node->full_name);
+        n += scnprintf(buf+n, len-n, "%s\n", dn->full_name);
+        printk(KERN_WARNING "EEH: of node=%s\n", dn->full_name);
 
-        rtas_read_config(pdn, PCI_VENDOR_ID, 4, &cfg);
+        eeh_ops->read_config(dn, PCI_VENDOR_ID, 4, &cfg);
         n += scnprintf(buf+n, len-n, "dev/vend:%08x\n", cfg);
         printk(KERN_WARNING "EEH: PCI device/vendor: %08x\n", cfg);
 
-        rtas_read_config(pdn, PCI_COMMAND, 4, &cfg);
+        eeh_ops->read_config(dn, PCI_COMMAND, 4, &cfg);
         n += scnprintf(buf+n, len-n, "cmd/stat:%x\n", cfg);
         printk(KERN_WARNING "EEH: PCI cmd/status register: %08x\n", cfg);
 
@@ -196,11 +156,11 @@ static size_t gather_pci_data(struct pci_dn *pdn, char * buf, size_t len)
 
         /* Gather bridge-specific registers */
         if (dev->class >> 16 == PCI_BASE_CLASS_BRIDGE) {
-                rtas_read_config(pdn, PCI_SEC_STATUS, 2, &cfg);
+                eeh_ops->read_config(dn, PCI_SEC_STATUS, 2, &cfg);
                 n += scnprintf(buf+n, len-n, "sec stat:%x\n", cfg);
                 printk(KERN_WARNING "EEH: Bridge secondary status: %04x\n", cfg);
 
-                rtas_read_config(pdn, PCI_BRIDGE_CONTROL, 2, &cfg);
+                eeh_ops->read_config(dn, PCI_BRIDGE_CONTROL, 2, &cfg);
                 n += scnprintf(buf+n, len-n, "brdg ctl:%x\n", cfg);
                 printk(KERN_WARNING "EEH: Bridge control: %04x\n", cfg);
         }
@@ -208,11 +168,11 @@ static size_t gather_pci_data(struct pci_dn *pdn, char * buf, size_t len)
         /* Dump out the PCI-X command and status regs */
         cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
         if (cap) {
-                rtas_read_config(pdn, cap, 4, &cfg);
+                eeh_ops->read_config(dn, cap, 4, &cfg);
                 n += scnprintf(buf+n, len-n, "pcix-cmd:%x\n", cfg);
                 printk(KERN_WARNING "EEH: PCI-X cmd: %08x\n", cfg);
 
-                rtas_read_config(pdn, cap+4, 4, &cfg);
+                eeh_ops->read_config(dn, cap+4, 4, &cfg);
                 n += scnprintf(buf+n, len-n, "pcix-stat:%x\n", cfg);
                 printk(KERN_WARNING "EEH: PCI-X status: %08x\n", cfg);
         }
@@ -225,7 +185,7 @@ static size_t gather_pci_data(struct pci_dn *pdn, char * buf, size_t len)
                        "EEH: PCI-E capabilities and status follow:\n");
 
                 for (i=0; i<=8; i++) {
-                        rtas_read_config(pdn, cap+4*i, 4, &cfg);
+                        eeh_ops->read_config(dn, cap+4*i, 4, &cfg);
                         n += scnprintf(buf+n, len-n, "%02x:%x\n", 4*i, cfg);
                         printk(KERN_WARNING "EEH: PCI-E %02x: %08x\n", i, cfg);
                 }
@@ -237,7 +197,7 @@ static size_t gather_pci_data(struct pci_dn *pdn, char * buf, size_t len)
                                "EEH: PCI-E AER capability register set follows:\n");
 
                         for (i=0; i<14; i++) {
-                                rtas_read_config(pdn, cap+4*i, 4, &cfg);
+                                eeh_ops->read_config(dn, cap+4*i, 4, &cfg);
                                 n += scnprintf(buf+n, len-n, "%02x:%x\n", 4*i, cfg);
                                 printk(KERN_WARNING "EEH: PCI-E AER %02x: %08x\n", i, cfg);
                         }
@@ -246,111 +206,46 @@ static size_t gather_pci_data(struct pci_dn *pdn, char * buf, size_t len)
 
         /* Gather status on devices under the bridge */
         if (dev->class >> 16 == PCI_BASE_CLASS_BRIDGE) {
-                struct device_node *dn;
+                struct device_node *child;
 
-                for_each_child_of_node(pdn->node, dn) {
-                        pdn = PCI_DN(dn);
-                        if (pdn)
-                                n += gather_pci_data(pdn, buf+n, len-n);
+                for_each_child_of_node(dn, child) {
+                        if (of_node_to_eeh_dev(child))
+                                n += eeh_gather_pci_data(of_node_to_eeh_dev(child), buf+n, len-n);
                 }
         }
 
         return n;
 }
 
-void eeh_slot_error_detail(struct pci_dn *pdn, int severity)
-{
-        size_t loglen = 0;
-        pci_regs_buf[0] = 0;
-
-        rtas_pci_enable(pdn, EEH_THAW_MMIO);
-        rtas_configure_bridge(pdn);
-        eeh_restore_bars(pdn);
-        loglen = gather_pci_data(pdn, pci_regs_buf, EEH_PCI_REGS_LOG_LEN);
-
-        rtas_slot_error_detail(pdn, severity, pci_regs_buf, loglen);
-}
-
 /**
- * read_slot_reset_state - Read the reset state of a device node's slot
- * @dn: device node to read
- * @rets: array to return results in
- */
-static int read_slot_reset_state(struct pci_dn *pdn, int rets[])
-{
-        int token, outputs;
-        int config_addr;
-
-        if (ibm_read_slot_reset_state2 != RTAS_UNKNOWN_SERVICE) {
-                token = ibm_read_slot_reset_state2;
-                outputs = 4;
-        } else {
-                token = ibm_read_slot_reset_state;
-                rets[2] = 0; /* fake PE Unavailable info */
-                outputs = 3;
-        }
-
-        /* Use PE configuration address, if present */
-        config_addr = pdn->eeh_config_addr;
-        if (pdn->eeh_pe_config_addr)
-                config_addr = pdn->eeh_pe_config_addr;
-
-        return rtas_call(token, 3, outputs, rets, config_addr,
-                         BUID_HI(pdn->phb->buid), BUID_LO(pdn->phb->buid));
-}
-
-/**
- * eeh_wait_for_slot_status - returns error status of slot
- * @pdn pci device node
- * @max_wait_msecs maximum number to millisecs to wait
- *
- * Return negative value if a permanent error, else return
- * Partition Endpoint (PE) status value.
+ * eeh_slot_error_detail - Generate combined log including driver log and error log
+ * @edev: device to report error log for
+ * @severity: temporary or permanent error log
  *
- * If @max_wait_msecs is positive, then this routine will
- * sleep until a valid status can be obtained, or until
- * the max allowed wait time is exceeded, in which case
- * a -2 is returned.
+ * This routine should be called to generate the combined log, which
+ * is comprised of driver log and error log. The driver log is figured
+ * out from the config space of the corresponding PCI device, while
+ * the error log is fetched through platform dependent function call.
  */
-int
-eeh_wait_for_slot_status(struct pci_dn *pdn, int max_wait_msecs)
+void eeh_slot_error_detail(struct eeh_dev *edev, int severity)
 {
-        int rc;
-        int rets[3];
-        int mwait;
-
-        while (1) {
-                rc = read_slot_reset_state(pdn, rets);
-                if (rc) return rc;
-                if (rets[1] == 0) return -1;  /* EEH is not supported */
-
-                if (rets[0] != 5) return rets[0]; /* return actual status */
-
-                if (rets[2] == 0) return -1; /* permanently unavailable */
+        size_t loglen = 0;
+        pci_regs_buf[0] = 0;
 
-                if (max_wait_msecs <= 0) break;
+        eeh_pci_enable(edev, EEH_OPT_THAW_MMIO);
+        eeh_ops->configure_bridge(eeh_dev_to_of_node(edev));
+        eeh_restore_bars(edev);
+        loglen = eeh_gather_pci_data(edev, pci_regs_buf, EEH_PCI_REGS_LOG_LEN);
 
-                mwait = rets[2];
-                if (mwait <= 0) {
-                        printk (KERN_WARNING
-                                "EEH: Firmware returned bad wait value=%d\n", mwait);
-                        mwait = 1000;
-                } else if (mwait > 300*1000) {
-                        printk (KERN_WARNING
-                                "EEH: Firmware is taking too long, time=%d\n", mwait);
-                        mwait = 300*1000;
-                }
-                max_wait_msecs -= mwait;
-                msleep (mwait);
-        }
-
-        printk(KERN_WARNING "EEH: Timed out waiting for slot status\n");
-        return -2;
+        eeh_ops->get_log(eeh_dev_to_of_node(edev), severity, pci_regs_buf, loglen);
 }
 
 /**
- * eeh_token_to_phys - convert EEH address token to phys address
- * @token i/o token, should be address in the form 0xA....
+ * eeh_token_to_phys - Convert EEH address token to phys address
+ * @token: I/O token, should be address in the form 0xA....
+ *
+ * This routine should be called to convert virtual I/O address
+ * to physical one.
  */
 static inline unsigned long eeh_token_to_phys(unsigned long token)
 {
@@ -365,36 +260,43 @@ static inline unsigned long eeh_token_to_phys(unsigned long token)
         return pa | (token & (PAGE_SIZE-1));
 }
 
-/** 
- * Return the "partitionable endpoint" (pe) under which this device lies
+/**
+ * eeh_find_device_pe - Retrieve the PE for the given device
+ * @dn: device node
+ *
+ * Return the PE under which this device lies
  */
-struct device_node * find_device_pe(struct device_node *dn)
+struct device_node *eeh_find_device_pe(struct device_node *dn)
 {
-        while ((dn->parent) && PCI_DN(dn->parent) &&
-              (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
+        while (dn->parent && of_node_to_eeh_dev(dn->parent) &&
+               (of_node_to_eeh_dev(dn->parent)->mode & EEH_MODE_SUPPORTED)) {
                 dn = dn->parent;
         }
         return dn;
 }
 
-/** Mark all devices that are children of this device as failed.
- *  Mark the device driver too, so that it can see the failure
- *  immediately; this is critical, since some drivers poll
- *  status registers in interrupts ... If a driver is polling,
- *  and the slot is frozen, then the driver can deadlock in
- *  an interrupt context, which is bad.
+/**
+ * __eeh_mark_slot - Mark all child devices as failed
+ * @parent: parent device
+ * @mode_flag: failure flag
+ *
+ * Mark all devices that are children of this device as failed.
+ * Mark the device driver too, so that it can see the failure
+ * immediately; this is critical, since some drivers poll
+ * status registers in interrupts ... If a driver is polling,
+ * and the slot is frozen, then the driver can deadlock in
+ * an interrupt context, which is bad.
  */
-
 static void __eeh_mark_slot(struct device_node *parent, int mode_flag)
 {
         struct device_node *dn;
 
         for_each_child_of_node(parent, dn) {
-                if (PCI_DN(dn)) {
+                if (of_node_to_eeh_dev(dn)) {
                         /* Mark the pci device driver too */
-                        struct pci_dev *dev = PCI_DN(dn)->pcidev;
+                        struct pci_dev *dev = of_node_to_eeh_dev(dn)->pdev;
 
-                        PCI_DN(dn)->eeh_mode |= mode_flag;
+                        of_node_to_eeh_dev(dn)->mode |= mode_flag;
 
                         if (dev && dev->driver)
                                 dev->error_state = pci_channel_io_frozen;
@@ -404,92 +306,81 @@ static void __eeh_mark_slot(struct device_node *parent, int mode_flag)
         }
 }
 
-void eeh_mark_slot (struct device_node *dn, int mode_flag)
+/**
+ * eeh_mark_slot - Mark the indicated device and its children as failed
+ * @dn: parent device
+ * @mode_flag: failure flag
+ *
+ * Mark the indicated device and its child devices as failed.
+ * The device drivers are marked as failed as well.
+ */
+void eeh_mark_slot(struct device_node *dn, int mode_flag)
 {
         struct pci_dev *dev;
-        dn = find_device_pe (dn);
+        dn = eeh_find_device_pe(dn);
 
         /* Back up one, since config addrs might be shared */
-        if (!pcibios_find_pci_bus(dn) && PCI_DN(dn->parent))
+        if (!pcibios_find_pci_bus(dn) && of_node_to_eeh_dev(dn->parent))
                 dn = dn->parent;
 
-        PCI_DN(dn)->eeh_mode |= mode_flag;
+        of_node_to_eeh_dev(dn)->mode |= mode_flag;
 
         /* Mark the pci device too */
-        dev = PCI_DN(dn)->pcidev;
+        dev = of_node_to_eeh_dev(dn)->pdev;
         if (dev)
                 dev->error_state = pci_channel_io_frozen;
 
         __eeh_mark_slot(dn, mode_flag);
 }
 
+/**
+ * __eeh_clear_slot - Clear failure flag for the child devices
+ * @parent: parent device
+ * @mode_flag: flag to be cleared
+ *
+ * Clear failure flag for the child devices.
+ */
 static void __eeh_clear_slot(struct device_node *parent, int mode_flag)
 {
         struct device_node *dn;
 
         for_each_child_of_node(parent, dn) {
-                if (PCI_DN(dn)) {
-                        PCI_DN(dn)->eeh_mode &= ~mode_flag;
-                        PCI_DN(dn)->eeh_check_count = 0;
+                if (of_node_to_eeh_dev(dn)) {
+                        of_node_to_eeh_dev(dn)->mode &= ~mode_flag;
+                        of_node_to_eeh_dev(dn)->check_count = 0;
                         __eeh_clear_slot(dn, mode_flag);
                 }
         }
 }
 
-void eeh_clear_slot (struct device_node *dn, int mode_flag)
+/**
+ * eeh_clear_slot - Clear failure flag for the indicated device and its children
+ * @dn: parent device
+ * @mode_flag: flag to be cleared
+ *
+ * Clear failure flag for the indicated device and its children.
+ */
+void eeh_clear_slot(struct device_node *dn, int mode_flag)
 {
         unsigned long flags;
         raw_spin_lock_irqsave(&confirm_error_lock, flags);
         
-        dn = find_device_pe (dn);
+        dn = eeh_find_device_pe(dn);
         
         /* Back up one, since config addrs might be shared */
-        if (!pcibios_find_pci_bus(dn) && PCI_DN(dn->parent))
+        if (!pcibios_find_pci_bus(dn) && of_node_to_eeh_dev(dn->parent))
                 dn = dn->parent;
 
-        PCI_DN(dn)->eeh_mode &= ~mode_flag;
-        PCI_DN(dn)->eeh_check_count = 0;
+        of_node_to_eeh_dev(dn)->mode &= ~mode_flag;
+        of_node_to_eeh_dev(dn)->check_count = 0;
         __eeh_clear_slot(dn, mode_flag);
         raw_spin_unlock_irqrestore(&confirm_error_lock, flags);
 }
 
-void __eeh_set_pe_freset(struct device_node *parent, unsigned int *freset)
-{
-        struct device_node *dn;
-
-        for_each_child_of_node(parent, dn) {
-                if (PCI_DN(dn)) {
-
-                        struct pci_dev *dev = PCI_DN(dn)->pcidev;
-
-                        if (dev && dev->driver)
-                                *freset |= dev->needs_freset;
-
-                        __eeh_set_pe_freset(dn, freset);
-                }
-        }
-}
-
-void eeh_set_pe_freset(struct device_node *dn, unsigned int *freset)
-{
-        struct pci_dev *dev;
-        dn = find_device_pe(dn);
-
-        /* Back up one, since config addrs might be shared */
-        if (!pcibios_find_pci_bus(dn) && PCI_DN(dn->parent))
-                dn = dn->parent;
-
-        dev = PCI_DN(dn)->pcidev;
-        if (dev)
-                *freset |= dev->needs_freset;
-
-        __eeh_set_pe_freset(dn, freset);
-}
-
 /**
- * eeh_dn_check_failure - check if all 1's data is due to EEH slot freeze
- * @dn device node
- * @dev pci device, if known
+ * eeh_dn_check_failure - Check if all 1's data is due to EEH slot freeze
+ * @dn: device node
+ * @dev: pci device, if known
  *
  * Check for an EEH failure for the given device node.  Call this
  * routine if the result of a read was all 0xff's and you want to
@@ -504,35 +395,34 @@ void eeh_set_pe_freset(struct device_node *dn, unsigned int *freset)
 int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev)
 {
         int ret;
-        int rets[3];
         unsigned long flags;
-        struct pci_dn *pdn;
+        struct eeh_dev *edev;
         int rc = 0;
         const char *location;
 
-        total_mmio_ffs++;
+        eeh_stats.total_mmio_ffs++;
 
         if (!eeh_subsystem_enabled)
                 return 0;
 
         if (!dn) {
-                no_dn++;
+                eeh_stats.no_dn++;
                 return 0;
         }
-        dn = find_device_pe(dn);
-        pdn = PCI_DN(dn);
+        dn = eeh_find_device_pe(dn);
+        edev = of_node_to_eeh_dev(dn);
 
         /* Access to IO BARs might get this far and still not want checking. */
-        if (!(pdn->eeh_mode & EEH_MODE_SUPPORTED) ||
-            pdn->eeh_mode & EEH_MODE_NOCHECK) {
-                ignored_check++;
+        if (!(edev->mode & EEH_MODE_SUPPORTED) ||
+            edev->mode & EEH_MODE_NOCHECK) {
+                eeh_stats.ignored_check++;
                 pr_debug("EEH: Ignored check (%x) for %s %s\n",
-                         pdn->eeh_mode, eeh_pci_name(dev), dn->full_name);
+                        edev->mode, eeh_pci_name(dev), dn->full_name);
                 return 0;
         }
 
-        if (!pdn->eeh_config_addr && !pdn->eeh_pe_config_addr) {
-                no_cfg_addr++;
+        if (!edev->config_addr && !edev->pe_config_addr) {
+                eeh_stats.no_cfg_addr++;
                 return 0;
         }
 
@@ -544,15 +434,15 @@ int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev)
          */
         raw_spin_lock_irqsave(&confirm_error_lock, flags);
         rc = 1;
-        if (pdn->eeh_mode & EEH_MODE_ISOLATED) {
-                pdn->eeh_check_count ++;
-                if (pdn->eeh_check_count % EEH_MAX_FAILS == 0) {
+        if (edev->mode & EEH_MODE_ISOLATED) {
+                edev->check_count++;
+                if (edev->check_count % EEH_MAX_FAILS == 0) {
                         location = of_get_property(dn, "ibm,loc-code", NULL);
-                        printk (KERN_ERR "EEH: %d reads ignored for recovering device at "
+                        printk(KERN_ERR "EEH: %d reads ignored for recovering device at "
                                 "location=%s driver=%s pci addr=%s\n",
-                                pdn->eeh_check_count, location,
+                                edev->check_count, location,
                                 eeh_driver_name(dev), eeh_pci_name(dev));
-                        printk (KERN_ERR "EEH: Might be infinite loop in %s driver\n",
+                        printk(KERN_ERR "EEH: Might be infinite loop in %s driver\n",
                                 eeh_driver_name(dev));
                         dump_stack();
                 }
@@ -566,58 +456,39 @@ int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev)
          * function zero of a multi-function device.
          * In any case they must share a common PHB.
          */
-        ret = read_slot_reset_state(pdn, rets);
-
-        /* If the call to firmware failed, punt */
-        if (ret != 0) {
-                printk(KERN_WARNING "EEH: read_slot_reset_state() failed; rc=%d dn=%s\n",
-                       ret, dn->full_name);
-                false_positives++;
-                pdn->eeh_false_positives ++;
-                rc = 0;
-                goto dn_unlock;
-        }
+        ret = eeh_ops->get_state(dn, NULL);
 
         /* Note that config-io to empty slots may fail;
-         * they are empty when they don't have children. */
-        if ((rets[0] == 5) && (rets[2] == 0) && (dn->child == NULL)) {
-                false_positives++;
-                pdn->eeh_false_positives ++;
-                rc = 0;
-                goto dn_unlock;
-        }
-
-        /* If EEH is not supported on this device, punt. */
-        if (rets[1] != 1) {
-                printk(KERN_WARNING "EEH: event on unsupported device, rc=%d dn=%s\n",
-                       ret, dn->full_name);
-                false_positives++;
-                pdn->eeh_false_positives ++;
-                rc = 0;
-                goto dn_unlock;
-        }
-
-        /* If not the kind of error we know about, punt. */
-        if (rets[0] != 1 && rets[0] != 2 && rets[0] != 4 && rets[0] != 5) {
-                false_positives++;
-                pdn->eeh_false_positives ++;
+         * they are empty when they don't have children.
+         * We will punt with the following conditions: Failure to get
+         * PE's state, EEH not support and Permanently unavailable
+         * state, PE is in good state.
+         */
+        if ((ret < 0) ||
+            (ret == EEH_STATE_NOT_SUPPORT) ||
+            (ret & (EEH_STATE_MMIO_ACTIVE | EEH_STATE_DMA_ACTIVE)) ==
+            (EEH_STATE_MMIO_ACTIVE | EEH_STATE_DMA_ACTIVE)) {
+                eeh_stats.false_positives++;
+                edev->false_positives ++;
                 rc = 0;
                 goto dn_unlock;
         }
 
-        slot_resets++;
+        eeh_stats.slot_resets++;
  
         /* Avoid repeated reports of this failure, including problems
          * with other functions on this device, and functions under
-         * bridges. */
-        eeh_mark_slot (dn, EEH_MODE_ISOLATED);
+         * bridges.
+         */
+        eeh_mark_slot(dn, EEH_MODE_ISOLATED);
         raw_spin_unlock_irqrestore(&confirm_error_lock, flags);
 
-        eeh_send_failure_event (dn, dev);
+        eeh_send_failure_event(edev);
 
         /* Most EEH events are due to device driver bugs.  Having
          * a stack trace will help the device-driver authors figure
-         * out what happened.  So print that out. */
+         * out what happened.  So print that out.
+         */
         dump_stack();
         return 1;
 
@@ -629,9 +500,9 @@ dn_unlock:
 EXPORT_SYMBOL_GPL(eeh_dn_check_failure);
 
 /**
- * eeh_check_failure - check if all 1's data is due to EEH slot freeze
- * @token i/o token, should be address in the form 0xA....
- * @val value, should be all 1's (XXX why do we need this arg??)
+ * eeh_check_failure - Check if all 1's data is due to EEH slot freeze
+ * @token: I/O token, should be address in the form 0xA....
+ * @val: value, should be all 1's (XXX why do we need this arg??)
  *
  * Check for an EEH failure at the given token address.  Call this
  * routine if the result of a read was all 0xff's and you want to
@@ -648,14 +519,14 @@ unsigned long eeh_check_failure(const volatile void __iomem *token, unsigned lon
 
         /* Finding the phys addr + pci device; this is pretty quick. */
         addr = eeh_token_to_phys((unsigned long __force) token);
-        dev = pci_get_device_by_addr(addr);
+        dev = pci_addr_cache_get_device(addr);
         if (!dev) {
-                no_device++;
+                eeh_stats.no_device++;
                 return val;
         }
 
         dn = pci_device_to_OF_node(dev);
-        eeh_dn_check_failure (dn, dev);
+        eeh_dn_check_failure(dn, dev);
 
         pci_dev_put(dev);
         return val;
@@ -663,115 +534,54 @@ unsigned long eeh_check_failure(const volatile void __iomem *token, unsigned lon
 
 EXPORT_SYMBOL(eeh_check_failure);
 
-/* ------------------------------------------------------------- */
-/* The code below deals with error recovery */
 
 /**
- * rtas_pci_enable - enable MMIO or DMA transfers for this slot
- * @pdn pci device node
+ * eeh_pci_enable - Enable MMIO or DMA transfers for this slot
+ * @edev: pci device node
+ *
+ * This routine should be called to reenable frozen MMIO or DMA
+ * so that it would work correctly again. It's useful while doing
+ * recovery or log collection on the indicated device.
  */
-
-int
-rtas_pci_enable(struct pci_dn *pdn, int function)
+int eeh_pci_enable(struct eeh_dev *edev, int function)
 {
-        int config_addr;
         int rc;
+        struct device_node *dn = eeh_dev_to_of_node(edev);
 
-        /* Use PE configuration address, if present */
-        config_addr = pdn->eeh_config_addr;
-        if (pdn->eeh_pe_config_addr)
-                config_addr = pdn->eeh_pe_config_addr;
-
-        rc = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
-                       config_addr,
-                       BUID_HI(pdn->phb->buid),
-                       BUID_LO(pdn->phb->buid),
-                            function);
-
+        rc = eeh_ops->set_option(dn, function);
         if (rc)
                 printk(KERN_WARNING "EEH: Unexpected state change %d, err=%d dn=%s\n",
-                        function, rc, pdn->node->full_name);
+                        function, rc, dn->full_name);
 
-        rc = eeh_wait_for_slot_status (pdn, PCI_BUS_RESET_WAIT_MSEC);
-        if ((rc == 4) && (function == EEH_THAW_MMIO))
+        rc = eeh_ops->wait_state(dn, PCI_BUS_RESET_WAIT_MSEC);
+        if (rc > 0 && (rc & EEH_STATE_MMIO_ENABLED) &&
+           (function == EEH_OPT_THAW_MMIO))
                 return 0;
 
         return rc;
 }
 
 /**
- * rtas_pci_slot_reset - raises/lowers the pci #RST line
- * @pdn pci device node
- * @state: 1/0 to raise/lower the #RST
- *
- * Clear the EEH-frozen condition on a slot.  This routine
- * asserts the PCI #RST line if the 'state' argument is '1',
- * and drops the #RST line if 'state is '0'.  This routine is
- * safe to call in an interrupt context.
- *
- */
-
-static void
-rtas_pci_slot_reset(struct pci_dn *pdn, int state)
-{
-        int config_addr;
-        int rc;
-
-        BUG_ON (pdn==NULL); 
-
-        if (!pdn->phb) {
-                printk (KERN_WARNING "EEH: in slot reset, device node %s has no phb\n",
-                        pdn->node->full_name);
-                return;
-        }
-
-        /* Use PE configuration address, if present */
-        config_addr = pdn->eeh_config_addr;
-        if (pdn->eeh_pe_config_addr)
-                config_addr = pdn->eeh_pe_config_addr;
-
-        rc = rtas_call(ibm_set_slot_reset, 4, 1, NULL,
-                       config_addr,
-                       BUID_HI(pdn->phb->buid),
-                       BUID_LO(pdn->phb->buid),
-                       state);
-
-        /* Fundamental-reset not supported on this PE, try hot-reset */
-        if (rc == -8 && state == 3) {
-                rc = rtas_call(ibm_set_slot_reset, 4, 1, NULL,
-                               config_addr,
-                               BUID_HI(pdn->phb->buid),
-                               BUID_LO(pdn->phb->buid), 1);
-                if (rc)
-                        printk(KERN_WARNING
-                                "EEH: Unable to reset the failed slot,"
-                                " #RST=%d dn=%s\n",
-                                rc, pdn->node->full_name);
-        }
-}
-
-/**
  * pcibios_set_pcie_slot_reset - Set PCI-E reset state
- * @dev:        pci device struct
- * @state:      reset state to enter
+ * @dev: pci device struct
+ * @state: reset state to enter
  *
  * Return value:
  *      0 if success
- **/
+ */
 int pcibios_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state)
 {
         struct device_node *dn = pci_device_to_OF_node(dev);
-        struct pci_dn *pdn = PCI_DN(dn);
 
         switch (state) {
         case pcie_deassert_reset:
-                rtas_pci_slot_reset(pdn, 0);
+                eeh_ops->reset(dn, EEH_RESET_DEACTIVATE);
                 break;
         case pcie_hot_reset:
-                rtas_pci_slot_reset(pdn, 1);
+                eeh_ops->reset(dn, EEH_RESET_HOT);
                 break;
         case pcie_warm_reset:
-                rtas_pci_slot_reset(pdn, 3);
+                eeh_ops->reset(dn, EEH_RESET_FUNDAMENTAL);
                 break;
         default:
                 return -EINVAL;
@@ -781,13 +591,66 @@ int pcibios_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state stat
 }
 
 /**
- * rtas_set_slot_reset -- assert the pci #RST line for 1/4 second
- * @pdn: pci device node to be reset.
+ * __eeh_set_pe_freset - Check the required reset for child devices
+ * @parent: parent device
+ * @freset: return value
+ *
+ * Each device might have its preferred reset type: fundamental or
+ * hot reset. The routine is used to collect the information from
+ * the child devices so that they could be reset accordingly.
+ */
+void __eeh_set_pe_freset(struct device_node *parent, unsigned int *freset)
+{
+        struct device_node *dn;
+
+        for_each_child_of_node(parent, dn) {
+                if (of_node_to_eeh_dev(dn)) {
+                        struct pci_dev *dev = of_node_to_eeh_dev(dn)->pdev;
+
+                        if (dev && dev->driver)
+                                *freset |= dev->needs_freset;
+
+                        __eeh_set_pe_freset(dn, freset);
+                }
+        }
+}
+
+/**
+ * eeh_set_pe_freset - Check the required reset for the indicated device and its children
+ * @dn: parent device
+ * @freset: return value
+ *
+ * Each device might have its preferred reset type: fundamental or
+ * hot reset. The routine is used to collected the information for
+ * the indicated device and its children so that the bunch of the
+ * devices could be reset properly.
  */
+void eeh_set_pe_freset(struct device_node *dn, unsigned int *freset)
+{
+        struct pci_dev *dev;
+        dn = eeh_find_device_pe(dn);
+
+        /* Back up one, since config addrs might be shared */
+        if (!pcibios_find_pci_bus(dn) && of_node_to_eeh_dev(dn->parent))
+                dn = dn->parent;
+
+        dev = of_node_to_eeh_dev(dn)->pdev;
+        if (dev)
+                *freset |= dev->needs_freset;
 
-static void __rtas_set_slot_reset(struct pci_dn *pdn)
+        __eeh_set_pe_freset(dn, freset);
+}
+
+/**
+ * eeh_reset_pe_once - Assert the pci #RST line for 1/4 second
+ * @edev: pci device node to be reset.
+ *
+ * Assert the PCI #RST line for 1/4 second.
+ */
+static void eeh_reset_pe_once(struct eeh_dev *edev)
 {
         unsigned int freset = 0;
+        struct device_node *dn = eeh_dev_to_of_node(edev);
 
         /* Determine type of EEH reset required for
          * Partitionable Endpoint, a hot-reset (1)
@@ -795,58 +658,68 @@ static void __rtas_set_slot_reset(struct pci_dn *pdn)
          * A fundamental reset required by any device under
          * Partitionable Endpoint trumps hot-reset.
          */
-        eeh_set_pe_freset(pdn->node, &freset);
+        eeh_set_pe_freset(dn, &freset);
 
         if (freset)
-                rtas_pci_slot_reset(pdn, 3);
+                eeh_ops->reset(dn, EEH_RESET_FUNDAMENTAL);
         else
-                rtas_pci_slot_reset(pdn, 1);
+                eeh_ops->reset(dn, EEH_RESET_HOT);
 
         /* The PCI bus requires that the reset be held high for at least
-         * a 100 milliseconds. We wait a bit longer 'just in case'.  */
-
+         * a 100 milliseconds. We wait a bit longer 'just in case'.
+         */
 #define PCI_BUS_RST_HOLD_TIME_MSEC 250
-        msleep (PCI_BUS_RST_HOLD_TIME_MSEC);
+        msleep(PCI_BUS_RST_HOLD_TIME_MSEC);
         
         /* We might get hit with another EEH freeze as soon as the 
          * pci slot reset line is dropped. Make sure we don't miss
-         * these, and clear the flag now. */
-        eeh_clear_slot (pdn->node, EEH_MODE_ISOLATED);
+         * these, and clear the flag now.
+         */
+        eeh_clear_slot(dn, EEH_MODE_ISOLATED);
 
-        rtas_pci_slot_reset (pdn, 0);
+        eeh_ops->reset(dn, EEH_RESET_DEACTIVATE);
 
         /* After a PCI slot has been reset, the PCI Express spec requires
          * a 1.5 second idle time for the bus to stabilize, before starting
-         * up traffic. */
+         * up traffic.
+         */
 #define PCI_BUS_SETTLE_TIME_MSEC 1800
-        msleep (PCI_BUS_SETTLE_TIME_MSEC);
+        msleep(PCI_BUS_SETTLE_TIME_MSEC);
 }
 
-int rtas_set_slot_reset(struct pci_dn *pdn)
+/**
+ * eeh_reset_pe - Reset the indicated PE
+ * @edev: PCI device associated EEH device
+ *
+ * This routine should be called to reset indicated device, including
+ * PE. A PE might include multiple PCI devices and sometimes PCI bridges
+ * might be involved as well.
+ */
+int eeh_reset_pe(struct eeh_dev *edev)
 {
         int i, rc;
+        struct device_node *dn = eeh_dev_to_of_node(edev);
 
         /* Take three shots at resetting the bus */
         for (i=0; i<3; i++) {
-                __rtas_set_slot_reset(pdn);
+                eeh_reset_pe_once(edev);
 
-                rc = eeh_wait_for_slot_status(pdn, PCI_BUS_RESET_WAIT_MSEC);
-                if (rc == 0)
+                rc = eeh_ops->wait_state(dn, PCI_BUS_RESET_WAIT_MSEC);
+                if (rc == (EEH_STATE_MMIO_ACTIVE | EEH_STATE_DMA_ACTIVE))
                         return 0;
 
                 if (rc < 0) {
                         printk(KERN_ERR "EEH: unrecoverable slot failure %s\n",
-                               pdn->node->full_name);
+                               dn->full_name);
                         return -1;
                 }
                 printk(KERN_ERR "EEH: bus reset %d failed on slot %s, rc=%d\n",
-                       i+1, pdn->node->full_name, rc);
+                       i+1, dn->full_name, rc);
         }
 
         return -1;
 }
 
-/* ------------------------------------------------------- */
 /** Save and restore of PCI BARs
  *
  * Although firmware will set up BARs during boot, it doesn't
@@ -856,181 +729,122 @@ int rtas_set_slot_reset(struct pci_dn *pdn)
  */
 
 /**
- * __restore_bars - Restore the Base Address Registers
- * @pdn: pci device node
+ * eeh_restore_one_device_bars - Restore the Base Address Registers for one device
+ * @edev: PCI device associated EEH device
  *
  * Loads the PCI configuration space base address registers,
  * the expansion ROM base address, the latency timer, and etc.
  * from the saved values in the device node.
  */
-static inline void __restore_bars (struct pci_dn *pdn)
+static inline void eeh_restore_one_device_bars(struct eeh_dev *edev)
 {
         int i;
         u32 cmd;
+        struct device_node *dn = eeh_dev_to_of_node(edev);
+
+        if (!edev->phb)
+                return;
 
-        if (NULL==pdn->phb) return;
         for (i=4; i<10; i++) {
-                rtas_write_config(pdn, i*4, 4, pdn->config_space[i]);
+                eeh_ops->write_config(dn, i*4, 4, edev->config_space[i]);
         }
 
         /* 12 == Expansion ROM Address */
-        rtas_write_config(pdn, 12*4, 4, pdn->config_space[12]);
+        eeh_ops->write_config(dn, 12*4, 4, edev->config_space[12]);
 
 #define BYTE_SWAP(OFF) (8*((OFF)/4)+3-(OFF))
-#define SAVED_BYTE(OFF) (((u8 *)(pdn->config_space))[BYTE_SWAP(OFF)])
+#define SAVED_BYTE(OFF) (((u8 *)(edev->config_space))[BYTE_SWAP(OFF)])
 
-        rtas_write_config (pdn, PCI_CACHE_LINE_SIZE, 1,
+        eeh_ops->write_config(dn, PCI_CACHE_LINE_SIZE, 1,
                     SAVED_BYTE(PCI_CACHE_LINE_SIZE));
 
-        rtas_write_config (pdn, PCI_LATENCY_TIMER, 1,
+        eeh_ops->write_config(dn, PCI_LATENCY_TIMER, 1,
                     SAVED_BYTE(PCI_LATENCY_TIMER));
 
         /* max latency, min grant, interrupt pin and line */
-        rtas_write_config(pdn, 15*4, 4, pdn->config_space[15]);
+        eeh_ops->write_config(dn, 15*4, 4, edev->config_space[15]);
 
         /* Restore PERR & SERR bits, some devices require it,
-           don't touch the other command bits */
-        rtas_read_config(pdn, PCI_COMMAND, 4, &cmd);
-        if (pdn->config_space[1] & PCI_COMMAND_PARITY)
+         * don't touch the other command bits
+         */
+        eeh_ops->read_config(dn, PCI_COMMAND, 4, &cmd);
+        if (edev->config_space[1] & PCI_COMMAND_PARITY)
                 cmd |= PCI_COMMAND_PARITY;
         else
                 cmd &= ~PCI_COMMAND_PARITY;
-        if (pdn->config_space[1] & PCI_COMMAND_SERR)
+        if (edev->config_space[1] & PCI_COMMAND_SERR)
                 cmd |= PCI_COMMAND_SERR;
         else
                 cmd &= ~PCI_COMMAND_SERR;
-        rtas_write_config(pdn, PCI_COMMAND, 4, cmd);
+        eeh_ops->write_config(dn, PCI_COMMAND, 4, cmd);
 }
 
 /**
- * eeh_restore_bars - restore the PCI config space info
+ * eeh_restore_bars - Restore the PCI config space info
+ * @edev: EEH device
  *
  * This routine performs a recursive walk to the children
  * of this device as well.
  */
-void eeh_restore_bars(struct pci_dn *pdn)
+void eeh_restore_bars(struct eeh_dev *edev)
 {
         struct device_node *dn;
-        if (!pdn) 
+        if (!edev)
                 return;
         
-        if ((pdn->eeh_mode & EEH_MODE_SUPPORTED) && !IS_BRIDGE(pdn->class_code))
-                __restore_bars (pdn);
+        if ((edev->mode & EEH_MODE_SUPPORTED) && !IS_BRIDGE(edev->class_code))
+                eeh_restore_one_device_bars(edev);
 
-        for_each_child_of_node(pdn->node, dn)
-                eeh_restore_bars (PCI_DN(dn));
+        for_each_child_of_node(eeh_dev_to_of_node(edev), dn)
+                eeh_restore_bars(of_node_to_eeh_dev(dn));
 }
 
 /**
- * eeh_save_bars - save device bars
+ * eeh_save_bars - Save device bars
+ * @edev: PCI device associated EEH device
  *
  * Save the values of the device bars. Unlike the restore
  * routine, this routine is *not* recursive. This is because
  * PCI devices are added individually; but, for the restore,
  * an entire slot is reset at a time.
  */
-static void eeh_save_bars(struct pci_dn *pdn)
+static void eeh_save_bars(struct eeh_dev *edev)
 {
         int i;
+        struct device_node *dn;
 
-        if (!pdn )
+        if (!edev)
                 return;
+        dn = eeh_dev_to_of_node(edev);
         
         for (i = 0; i < 16; i++)
-                rtas_read_config(pdn, i * 4, 4, &pdn->config_space[i]);
-}
-
-void
-rtas_configure_bridge(struct pci_dn *pdn)
-{
-        int config_addr;
-        int rc;
-        int token;
-
-        /* Use PE configuration address, if present */
-        config_addr = pdn->eeh_config_addr;
-        if (pdn->eeh_pe_config_addr)
-                config_addr = pdn->eeh_pe_config_addr;
-
-        /* Use new configure-pe function, if supported */
-        if (ibm_configure_pe != RTAS_UNKNOWN_SERVICE)
-                token = ibm_configure_pe;
-        else
-                token = ibm_configure_bridge;
-
-        rc = rtas_call(token, 3, 1, NULL,
-                       config_addr,
-                       BUID_HI(pdn->phb->buid),
-                       BUID_LO(pdn->phb->buid));
-        if (rc) {
-                printk (KERN_WARNING "EEH: Unable to configure device bridge (%d) for %s\n",
-                        rc, pdn->node->full_name);
-        }
+                eeh_ops->read_config(dn, i * 4, 4, &edev->config_space[i]);
 }
 
-/* ------------------------------------------------------------- */
-/* The code below deals with enabling EEH for devices during  the
- * early boot sequence.  EEH must be enabled before any PCI probing
- * can be done.
+/**
+ * eeh_early_enable - Early enable EEH on the indicated device
+ * @dn: device node
+ * @data: BUID
+ *
+ * Enable EEH functionality on the specified PCI device. The function
+ * is expected to be called before real PCI probing is done. However,
+ * the PHBs have been initialized at this point.
  */
-
-#define EEH_ENABLE 1
-
-struct eeh_early_enable_info {
-        unsigned int buid_hi;
-        unsigned int buid_lo;
-};
-
-static int get_pe_addr (int config_addr,
-                        struct eeh_early_enable_info *info)
+static void *eeh_early_enable(struct device_node *dn, void *data)
 {
-        unsigned int rets[3];
-        int ret;
-
-        /* Use latest config-addr token on power6 */
-        if (ibm_get_config_addr_info2 != RTAS_UNKNOWN_SERVICE) {
-                /* Make sure we have a PE in hand */
-                ret = rtas_call (ibm_get_config_addr_info2, 4, 2, rets,
-                        config_addr, info->buid_hi, info->buid_lo, 1);
-                if (ret || (rets[0]==0))
-                        return 0;
-
-                ret = rtas_call (ibm_get_config_addr_info2, 4, 2, rets,
-                        config_addr, info->buid_hi, info->buid_lo, 0);
-                if (ret)
-                        return 0;
-                return rets[0];
-        }
-
-        /* Use older config-addr token on power5 */
-        if (ibm_get_config_addr_info != RTAS_UNKNOWN_SERVICE) {
-                ret = rtas_call (ibm_get_config_addr_info, 4, 2, rets,
-                        config_addr, info->buid_hi, info->buid_lo, 0);
-                if (ret)
-                        return 0;
-                return rets[0];
-        }
-        return 0;
-}
-
-/* Enable eeh for the given device node. */
-static void *early_enable_eeh(struct device_node *dn, void *data)
-{
-        unsigned int rets[3];
-        struct eeh_early_enable_info *info = data;
         int ret;
         const u32 *class_code = of_get_property(dn, "class-code", NULL);
         const u32 *vendor_id = of_get_property(dn, "vendor-id", NULL);
         const u32 *device_id = of_get_property(dn, "device-id", NULL);
         const u32 *regs;
         int enable;
-        struct pci_dn *pdn = PCI_DN(dn);
+        struct eeh_dev *edev = of_node_to_eeh_dev(dn);
 
-        pdn->class_code = 0;
-        pdn->eeh_mode = 0;
-        pdn->eeh_check_count = 0;
-        pdn->eeh_freeze_count = 0;
-        pdn->eeh_false_positives = 0;
+        edev->class_code = 0;
+        edev->mode = 0;
+        edev->check_count = 0;
+        edev->freeze_count = 0;
+        edev->false_positives = 0;
 
         if (!of_device_is_available(dn))
                 return NULL;
@@ -1041,54 +855,56 @@ static void *early_enable_eeh(struct device_node *dn, void *data)
 
         /* There is nothing to check on PCI to ISA bridges */
         if (dn->type && !strcmp(dn->type, "isa")) {
-                pdn->eeh_mode |= EEH_MODE_NOCHECK;
+                edev->mode |= EEH_MODE_NOCHECK;
                 return NULL;
         }
-        pdn->class_code = *class_code;
+        edev->class_code = *class_code;
 
         /* Ok... see if this device supports EEH.  Some do, some don't,
-         * and the only way to find out is to check each and every one. */
+         * and the only way to find out is to check each and every one.
+         */
         regs = of_get_property(dn, "reg", NULL);
         if (regs) {
                 /* First register entry is addr (00BBSS00)  */
                 /* Try to enable eeh */
-                ret = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
-                                regs[0], info->buid_hi, info->buid_lo,
-                                EEH_ENABLE);
+                ret = eeh_ops->set_option(dn, EEH_OPT_ENABLE);
 
                 enable = 0;
                 if (ret == 0) {
-                        pdn->eeh_config_addr = regs[0];
+                        edev->config_addr = regs[0];
 
                         /* If the newer, better, ibm,get-config-addr-info is supported, 
-                         * then use that instead. */
-                        pdn->eeh_pe_config_addr = get_pe_addr(pdn->eeh_config_addr, info);
+                         * then use that instead.
+                         */
+                        edev->pe_config_addr = eeh_ops->get_pe_addr(dn);
 
                         /* Some older systems (Power4) allow the
                          * ibm,set-eeh-option call to succeed even on nodes
                          * where EEH is not supported. Verify support
-                         * explicitly. */
-                        ret = read_slot_reset_state(pdn, rets);
-                        if ((ret == 0) && (rets[1] == 1))
+                         * explicitly.
+                         */
+                        ret = eeh_ops->get_state(dn, NULL);
+                        if (ret > 0 && ret != EEH_STATE_NOT_SUPPORT)
                                 enable = 1;
                 }
 
                 if (enable) {
                         eeh_subsystem_enabled = 1;
-                        pdn->eeh_mode |= EEH_MODE_SUPPORTED;
+                        edev->mode |= EEH_MODE_SUPPORTED;
 
                         pr_debug("EEH: %s: eeh enabled, config=%x pe_config=%x\n",
-                                 dn->full_name, pdn->eeh_config_addr,
-                                 pdn->eeh_pe_config_addr);
+                                 dn->full_name, edev->config_addr,
+                                 edev->pe_config_addr);
                 } else {
 
                         /* This device doesn't support EEH, but it may have an
-                         * EEH parent, in which case we mark it as supported. */
-                        if (dn->parent && PCI_DN(dn->parent)
-                            && (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
+                         * EEH parent, in which case we mark it as supported.
+                         */
+                        if (dn->parent && of_node_to_eeh_dev(dn->parent) &&
+                            (of_node_to_eeh_dev(dn->parent)->mode & EEH_MODE_SUPPORTED)) {
                                 /* Parent supports EEH. */
-                                pdn->eeh_mode |= EEH_MODE_SUPPORTED;
-                                pdn->eeh_config_addr = PCI_DN(dn->parent)->eeh_config_addr;
+                                edev->mode |= EEH_MODE_SUPPORTED;
+                                edev->config_addr = of_node_to_eeh_dev(dn->parent)->config_addr;
                                 return NULL;
                         }
                 }
@@ -1097,11 +913,63 @@ static void *early_enable_eeh(struct device_node *dn, void *data)
                        dn->full_name);
         }
 
-        eeh_save_bars(pdn);
+        eeh_save_bars(edev);
         return NULL;
 }
 
-/*
+/**
+ * eeh_ops_register - Register platform dependent EEH operations
+ * @ops: platform dependent EEH operations
+ *
+ * Register the platform dependent EEH operation callback
+ * functions. The platform should call this function before
+ * any other EEH operations.
+ */
+int __init eeh_ops_register(struct eeh_ops *ops)
+{
+        if (!ops->name) {
+                pr_warning("%s: Invalid EEH ops name for %p\n",
+                        __func__, ops);
+                return -EINVAL;
+        }
+
+        if (eeh_ops && eeh_ops != ops) {
+                pr_warning("%s: EEH ops of platform %s already existing (%s)\n",
+                        __func__, eeh_ops->name, ops->name);
+                return -EEXIST;
+        }
+
+        eeh_ops = ops;
+
+        return 0;
+}
+
+/**
+ * eeh_ops_unregister - Unreigster platform dependent EEH operations
+ * @name: name of EEH platform operations
+ *
+ * Unregister the platform dependent EEH operation callback
+ * functions.
+ */
+int __exit eeh_ops_unregister(const char *name)
+{
+        if (!name || !strlen(name)) {
+                pr_warning("%s: Invalid EEH ops name\n",
+                        __func__);
+                return -EINVAL;
+        }
+
+        if (eeh_ops && !strcmp(eeh_ops->name, name)) {
+                eeh_ops = NULL;
+                return 0;
+        }
+
+        return -EEXIST;
+}
+
+/**
+ * eeh_init - EEH initialization
+ *
  * Initialize EEH by trying to enable it for all of the adapters in the system.
  * As a side effect we can determine here if eeh is supported at all.
  * Note that we leave EEH on so failed config cycles won't cause a machine
@@ -1117,50 +985,35 @@ static void *early_enable_eeh(struct device_node *dn, void *data)
 void __init eeh_init(void)
 {
         struct device_node *phb, *np;
-        struct eeh_early_enable_info info;
+        int ret;
+
+        /* call platform initialization function */
+        if (!eeh_ops) {
+                pr_warning("%s: Platform EEH operation not found\n",
+                        __func__);
+                return;
+        } else if ((ret = eeh_ops->init())) {
+                pr_warning("%s: Failed to call platform init function (%d)\n",
+                        __func__, ret);
+                return;
+        }
 
         raw_spin_lock_init(&confirm_error_lock);
-        spin_lock_init(&slot_errbuf_lock);
 
         np = of_find_node_by_path("/rtas");
         if (np == NULL)
                 return;
 
-        ibm_set_eeh_option = rtas_token("ibm,set-eeh-option");
-        ibm_set_slot_reset = rtas_token("ibm,set-slot-reset");
-        ibm_read_slot_reset_state2 = rtas_token("ibm,read-slot-reset-state2");
-        ibm_read_slot_reset_state = rtas_token("ibm,read-slot-reset-state");
-        ibm_slot_error_detail = rtas_token("ibm,slot-error-detail");
-        ibm_get_config_addr_info = rtas_token("ibm,get-config-addr-info");
-        ibm_get_config_addr_info2 = rtas_token("ibm,get-config-addr-info2");
-        ibm_configure_bridge = rtas_token ("ibm,configure-bridge");
-        ibm_configure_pe = rtas_token("ibm,configure-pe");
-
-        if (ibm_set_eeh_option == RTAS_UNKNOWN_SERVICE)
-                return;
-
-        eeh_error_buf_size = rtas_token("rtas-error-log-max");
-        if (eeh_error_buf_size == RTAS_UNKNOWN_SERVICE) {
-                eeh_error_buf_size = 1024;
-        }
-        if (eeh_error_buf_size > RTAS_ERROR_LOG_MAX) {
-                printk(KERN_WARNING "EEH: rtas-error-log-max is bigger than allocated "
-                      "buffer ! (%d vs %d)", eeh_error_buf_size, RTAS_ERROR_LOG_MAX);
-                eeh_error_buf_size = RTAS_ERROR_LOG_MAX;
-        }
-
         /* Enable EEH for all adapters.  Note that eeh requires buid's */
         for (phb = of_find_node_by_name(NULL, "pci"); phb;
              phb = of_find_node_by_name(phb, "pci")) {
                 unsigned long buid;
 
                 buid = get_phb_buid(phb);
-                if (buid == 0 || PCI_DN(phb) == NULL)
+                if (buid == 0 || !of_node_to_eeh_dev(phb))
                         continue;
 
-                info.buid_lo = BUID_LO(buid);
-                info.buid_hi = BUID_HI(buid);
-                traverse_pci_devices(phb, early_enable_eeh, &info);
+                traverse_pci_devices(phb, eeh_early_enable, NULL);
         }
 
         if (eeh_subsystem_enabled)
@@ -1170,7 +1023,7 @@ void __init eeh_init(void)
 }
 
 /**
- * eeh_add_device_early - enable EEH for the indicated device_node
+ * eeh_add_device_early - Enable EEH for the indicated device_node
  * @dn: device node for which to set up EEH
  *
  * This routine must be used to perform EEH initialization for PCI
@@ -1184,21 +1037,26 @@ void __init eeh_init(void)
 static void eeh_add_device_early(struct device_node *dn)
 {
         struct pci_controller *phb;
-        struct eeh_early_enable_info info;
 
-        if (!dn || !PCI_DN(dn))
+        if (!dn || !of_node_to_eeh_dev(dn))
                 return;
-        phb = PCI_DN(dn)->phb;
+        phb = of_node_to_eeh_dev(dn)->phb;
 
         /* USB Bus children of PCI devices will not have BUID's */
         if (NULL == phb || 0 == phb->buid)
                 return;
 
-        info.buid_hi = BUID_HI(phb->buid);
-        info.buid_lo = BUID_LO(phb->buid);
-        early_enable_eeh(dn, &info);
+        eeh_early_enable(dn, NULL);
 }
 
+/**
+ * eeh_add_device_tree_early - Enable EEH for the indicated device
+ * @dn: device node
+ *
+ * This routine must be used to perform EEH initialization for the
+ * indicated PCI device that was added after system boot (e.g.
+ * hotplug, dlpar).
+ */
 void eeh_add_device_tree_early(struct device_node *dn)
 {
         struct device_node *sib;
@@ -1210,7 +1068,7 @@ void eeh_add_device_tree_early(struct device_node *dn)
 EXPORT_SYMBOL_GPL(eeh_add_device_tree_early);
 
 /**
- * eeh_add_device_late - perform EEH initialization for the indicated pci device
+ * eeh_add_device_late - Perform EEH initialization for the indicated pci device
  * @dev: pci device for which to set up EEH
  *
  * This routine must be used to complete EEH initialization for PCI
@@ -1219,7 +1077,7 @@ EXPORT_SYMBOL_GPL(eeh_add_device_tree_early);
 static void eeh_add_device_late(struct pci_dev *dev)
 {
         struct device_node *dn;
-        struct pci_dn *pdn;
+        struct eeh_dev *edev;
 
         if (!dev || !eeh_subsystem_enabled)
                 return;
@@ -1227,20 +1085,29 @@ static void eeh_add_device_late(struct pci_dev *dev)
         pr_debug("EEH: Adding device %s\n", pci_name(dev));
 
         dn = pci_device_to_OF_node(dev);
-        pdn = PCI_DN(dn);
-        if (pdn->pcidev == dev) {
+        edev = pci_dev_to_eeh_dev(dev);
+        if (edev->pdev == dev) {
                 pr_debug("EEH: Already referenced !\n");
                 return;
         }
-        WARN_ON(pdn->pcidev);
+        WARN_ON(edev->pdev);
 
-        pci_dev_get (dev);
-        pdn->pcidev = dev;
+        pci_dev_get(dev);
+        edev->pdev = dev;
+        dev->dev.archdata.edev = edev;
 
         pci_addr_cache_insert_device(dev);
         eeh_sysfs_add_device(dev);
 }
 
+/**
+ * eeh_add_device_tree_late - Perform EEH initialization for the indicated PCI bus
+ * @bus: PCI bus
+ *
+ * This routine must be used to perform EEH initialization for PCI
+ * devices which are attached to the indicated PCI bus. The PCI bus
+ * is added after system boot through hotplug or dlpar.
+ */
 void eeh_add_device_tree_late(struct pci_bus *bus)
 {
         struct pci_dev *dev;
@@ -1257,7 +1124,7 @@ void eeh_add_device_tree_late(struct pci_bus *bus)
 EXPORT_SYMBOL_GPL(eeh_add_device_tree_late);
 
 /**
- * eeh_remove_device - undo EEH setup for the indicated pci device
+ * eeh_remove_device - Undo EEH setup for the indicated pci device
  * @dev: pci device to be removed
  *
  * This routine should be called when a device is removed from
@@ -1268,25 +1135,35 @@ EXPORT_SYMBOL_GPL(eeh_add_device_tree_late);
  */
 static void eeh_remove_device(struct pci_dev *dev)
 {
-        struct device_node *dn;
+        struct eeh_dev *edev;
+
         if (!dev || !eeh_subsystem_enabled)
                 return;
+        edev = pci_dev_to_eeh_dev(dev);
 
         /* Unregister the device with the EEH/PCI address search system */
         pr_debug("EEH: Removing device %s\n", pci_name(dev));
 
-        dn = pci_device_to_OF_node(dev);
-        if (PCI_DN(dn)->pcidev == NULL) {
+        if (!edev || !edev->pdev) {
                 pr_debug("EEH: Not referenced !\n");
                 return;
         }
-        PCI_DN(dn)->pcidev = NULL;
-        pci_dev_put (dev);
+        edev->pdev = NULL;
+        dev->dev.archdata.edev = NULL;
+        pci_dev_put(dev);
 
         pci_addr_cache_remove_device(dev);
         eeh_sysfs_remove_device(dev);
 }
 
+/**
+ * eeh_remove_bus_device - Undo EEH setup for the indicated PCI device
+ * @dev: PCI device
+ *
+ * This routine must be called when a device is removed from the
+ * running system through hotplug or dlpar. The corresponding
+ * PCI address cache will be removed.
+ */
 void eeh_remove_bus_device(struct pci_dev *dev)
 {
         struct pci_bus *bus = dev->subordinate;
@@ -1305,21 +1182,24 @@ static int proc_eeh_show(struct seq_file *m, void *v)
 {
         if (0 == eeh_subsystem_enabled) {
                 seq_printf(m, "EEH Subsystem is globally disabled\n");
-                seq_printf(m, "eeh_total_mmio_ffs=%ld\n", total_mmio_ffs);
+                seq_printf(m, "eeh_total_mmio_ffs=%llu\n", eeh_stats.total_mmio_ffs);
         } else {
                 seq_printf(m, "EEH Subsystem is enabled\n");
                 seq_printf(m,
-                                "no device=%ld\n"
-                                "no device node=%ld\n"
-                                "no config address=%ld\n"
-                                "check not wanted=%ld\n"
-                                "eeh_total_mmio_ffs=%ld\n"
-                                "eeh_false_positives=%ld\n"
-                                "eeh_slot_resets=%ld\n",
-                                no_device, no_dn, no_cfg_addr, 
-                                ignored_check, total_mmio_ffs, 
-                                false_positives,
-                                slot_resets);
+                                "no device=%llu\n"
+                                "no device node=%llu\n"
+                                "no config address=%llu\n"
+                                "check not wanted=%llu\n"
+                                "eeh_total_mmio_ffs=%llu\n"
+                                "eeh_false_positives=%llu\n"
+                                "eeh_slot_resets=%llu\n",
+                                eeh_stats.no_device,
+                                eeh_stats.no_dn,
+                                eeh_stats.no_cfg_addr,
+                                eeh_stats.ignored_check,
+                                eeh_stats.total_mmio_ffs,
+                                eeh_stats.false_positives,
+                                eeh_stats.slot_resets);
         }
 
         return 0;