== (EEH_STATE_MMIO_ACTIVE | EEH_STATE_DMA_ACTIVE);
 }
 
-typedef void *(*eeh_traverse_func)(void *data, void *flag);
+typedef void *(*eeh_edev_traverse_func)(struct eeh_dev *edev, void *flag);
+typedef void *(*eeh_pe_traverse_func)(struct eeh_pe *pe, void *flag);
 void eeh_set_pe_aux_size(int size);
 int eeh_phb_pe_create(struct pci_controller *phb);
 struct eeh_pe *eeh_phb_pe_get(struct pci_controller *phb);
 int eeh_rmv_from_parent_pe(struct eeh_dev *edev);
 void eeh_pe_update_time_stamp(struct eeh_pe *pe);
 void *eeh_pe_traverse(struct eeh_pe *root,
-               eeh_traverse_func fn, void *flag);
+                     eeh_pe_traverse_func fn, void *flag);
 void *eeh_pe_dev_traverse(struct eeh_pe *root,
-               eeh_traverse_func fn, void *flag);
+                         eeh_edev_traverse_func fn, void *flag);
 void eeh_pe_restore_bars(struct eeh_pe *pe);
 const char *eeh_pe_loc_get(struct eeh_pe *pe);
 struct pci_bus *eeh_pe_bus_get(struct eeh_pe *pe);
 
        return n;
 }
 
-static void *eeh_dump_pe_log(void *data, void *flag)
+static void *eeh_dump_pe_log(struct eeh_pe *pe, void *flag)
 {
-       struct eeh_pe *pe = data;
        struct eeh_dev *edev, *tmp;
        size_t *plen = flag;
 
        return rc;
 }
 
-static void *eeh_disable_and_save_dev_state(void *data, void *userdata)
+static void *eeh_disable_and_save_dev_state(struct eeh_dev *edev,
+                                           void *userdata)
 {
-       struct eeh_dev *edev = data;
        struct pci_dev *pdev = eeh_dev_to_pci_dev(edev);
        struct pci_dev *dev = userdata;
 
        return NULL;
 }
 
-static void *eeh_restore_dev_state(void *data, void *userdata)
+static void *eeh_restore_dev_state(struct eeh_dev *edev, void *userdata)
 {
-       struct eeh_dev *edev = data;
        struct pci_dn *pdn = eeh_dev_to_pdn(edev);
        struct pci_dev *pdev = eeh_dev_to_pci_dev(edev);
        struct pci_dev *dev = userdata;
  * the indicated device and its children so that the bunch of the
  * devices could be reset properly.
  */
-static void *eeh_set_dev_freset(void *data, void *flag)
+static void *eeh_set_dev_freset(struct eeh_dev *edev, void *flag)
 {
        struct pci_dev *dev;
        unsigned int *freset = (unsigned int *)flag;
-       struct eeh_dev *edev = (struct eeh_dev *)data;
 
        dev = eeh_dev_to_pci_dev(edev);
        if (dev)
 
        return false;
 }
 
-static void *eeh_dev_save_state(void *data, void *userdata)
+static void *eeh_dev_save_state(struct eeh_dev *edev, void *userdata)
 {
-       struct eeh_dev *edev = data;
        struct pci_dev *pdev;
 
        if (!edev)
  * merge the device driver responses. Cumulative response
  * passed back in "userdata".
  */
-static void *eeh_report_error(void *data, void *userdata)
+static void *eeh_report_error(struct eeh_dev *edev, void *userdata)
 {
-       struct eeh_dev *edev = (struct eeh_dev *)data;
        struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
        enum pci_ers_result rc, *res = userdata;
        struct pci_driver *driver;
  * are now enabled. Collects up and merges the device driver responses.
  * Cumulative response passed back in "userdata".
  */
-static void *eeh_report_mmio_enabled(void *data, void *userdata)
+static void *eeh_report_mmio_enabled(struct eeh_dev *edev, void *userdata)
 {
-       struct eeh_dev *edev = (struct eeh_dev *)data;
        struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
        enum pci_ers_result rc, *res = userdata;
        struct pci_driver *driver;
  * some actions, usually to save data the driver needs so that the
  * driver can work again while the device is recovered.
  */
-static void *eeh_report_reset(void *data, void *userdata)
+static void *eeh_report_reset(struct eeh_dev *edev, void *userdata)
 {
-       struct eeh_dev *edev = (struct eeh_dev *)data;
        struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
        enum pci_ers_result rc, *res = userdata;
        struct pci_driver *driver;
        return NULL;
 }
 
-static void *eeh_dev_restore_state(void *data, void *userdata)
+static void *eeh_dev_restore_state(struct eeh_dev *edev, void *userdata)
 {
-       struct eeh_dev *edev = data;
        struct pci_dev *pdev;
 
        if (!edev)
  * could resume so that the device driver can do some initialization
  * to make the recovered device work again.
  */
-static void *eeh_report_resume(void *data, void *userdata)
+static void *eeh_report_resume(struct eeh_dev *edev, void *userdata)
 {
-       struct eeh_dev *edev = (struct eeh_dev *)data;
        struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
        bool was_in_error;
        struct pci_driver *driver;
  * This informs the device driver that the device is permanently
  * dead, and that no further recovery attempts will be made on it.
  */
-static void *eeh_report_failure(void *data, void *userdata)
+static void *eeh_report_failure(struct eeh_dev *edev, void *userdata)
 {
-       struct eeh_dev *edev = (struct eeh_dev *)data;
        struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
        struct pci_driver *driver;
 
        return NULL;
 }
 
-static void *eeh_rmv_device(void *data, void *userdata)
+static void *eeh_rmv_device(struct eeh_dev *edev, void *userdata)
 {
        struct pci_driver *driver;
-       struct eeh_dev *edev = (struct eeh_dev *)data;
        struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
        struct eeh_rmv_data *rmv_data = (struct eeh_rmv_data *)userdata;
        int *removed = rmv_data ? &rmv_data->removed : NULL;
        return NULL;
 }
 
-static void *eeh_pe_detach_dev(void *data, void *userdata)
+static void *eeh_pe_detach_dev(struct eeh_pe *pe, void *userdata)
 {
-       struct eeh_pe *pe = (struct eeh_pe *)data;
        struct eeh_dev *edev, *tmp;
 
        eeh_pe_for_each_dev(pe, edev, tmp) {
  * PE reset (for 3 times), we try to clear the frozen state
  * for 3 times as well.
  */
-static void *__eeh_clear_pe_frozen_state(void *data, void *flag)
+static void *__eeh_clear_pe_frozen_state(struct eeh_pe *pe, void *flag)
 {
-       struct eeh_pe *pe = (struct eeh_pe *)data;
        bool clear_sw_state = *(bool *)flag;
        int i, rc = 1;
 
 
  * to be traversed.
  */
 void *eeh_pe_traverse(struct eeh_pe *root,
-                     eeh_traverse_func fn, void *flag)
+                     eeh_pe_traverse_func fn, void *flag)
 {
        struct eeh_pe *pe;
        void *ret;
  * PE and its child PEs.
  */
 void *eeh_pe_dev_traverse(struct eeh_pe *root,
-               eeh_traverse_func fn, void *flag)
+                         eeh_edev_traverse_func fn, void *flag)
 {
        struct eeh_pe *pe;
        struct eeh_dev *edev, *tmp;
        int config_addr;
 };
 
-static void *__eeh_pe_get(void *data, void *flag)
+static void *__eeh_pe_get(struct eeh_pe *pe, void *flag)
 {
-       struct eeh_pe *pe = (struct eeh_pe *)data;
        struct eeh_pe_get_flag *tmp = (struct eeh_pe_get_flag *) flag;
 
        /* Unexpected PHB PE */
  * PE. Also, the associated PCI devices will be put into IO frozen
  * state as well.
  */
-static void *__eeh_pe_state_mark(void *data, void *flag)
+static void *__eeh_pe_state_mark(struct eeh_pe *pe, void *flag)
 {
-       struct eeh_pe *pe = (struct eeh_pe *)data;
        int state = *((int *)flag);
        struct eeh_dev *edev, *tmp;
        struct pci_dev *pdev;
 }
 EXPORT_SYMBOL_GPL(eeh_pe_state_mark);
 
-static void *__eeh_pe_dev_mode_mark(void *data, void *flag)
+static void *__eeh_pe_dev_mode_mark(struct eeh_dev *edev, void *flag)
 {
-       struct eeh_dev *edev = data;
        int mode = *((int *)flag);
 
        edev->mode |= mode;
  * given PE. Besides, we also clear the check count of the PE
  * as well.
  */
-static void *__eeh_pe_state_clear(void *data, void *flag)
+static void *__eeh_pe_state_clear(struct eeh_pe *pe, void *flag)
 {
-       struct eeh_pe *pe = (struct eeh_pe *)data;
        int state = *((int *)flag);
        struct eeh_dev *edev, *tmp;
        struct pci_dev *pdev;
  * the expansion ROM base address, the latency timer, and etc.
  * from the saved values in the device node.
  */
-static void *eeh_restore_one_device_bars(void *data, void *flag)
+static void *eeh_restore_one_device_bars(struct eeh_dev *edev, void *flag)
 {
-       struct eeh_dev *edev = (struct eeh_dev *)data;
        struct pci_dn *pdn = eeh_dev_to_pdn(edev);
 
        /* Do special restore for bridges */