pr_err("QAT: Can't find acceleration device\n");
                return PCI_ERS_RESULT_DISCONNECT;
        }
-       pci_cleanup_aer_uncorrect_error_status(pdev);
        if (adf_dev_aer_schedule_reset(accel_dev, ADF_DEV_RESET_SYNC))
                return PCI_ERS_RESULT_DISCONNECT;
 
 
 static pci_ers_result_t ioat_pcie_error_slot_reset(struct pci_dev *pdev)
 {
        pci_ers_result_t result = PCI_ERS_RESULT_RECOVERED;
-       int err;
 
        dev_dbg(&pdev->dev, "%s post reset handling\n", DRV_NAME);
 
                pci_wake_from_d3(pdev, false);
        }
 
-       err = pci_cleanup_aer_uncorrect_error_status(pdev);
-       if (err) {
-               dev_err(&pdev->dev,
-                       "AER uncorrect error status clear failed: %#x\n", err);
-       }
-
        return result;
 }
 
 
        struct hfi1_devdata *dd = pci_get_drvdata(pdev);
 
        dd_dev_info(dd, "HFI1 resume function called\n");
-       pci_cleanup_aer_uncorrect_error_status(pdev);
        /*
         * Running jobs will fail, since it's asynchronous
         * unlike sysfs-requested reset.   Better than
 
        struct qib_devdata *dd = pci_get_drvdata(pdev);
 
        qib_devinfo(pdev, "QIB resume function called\n");
-       pci_cleanup_aer_uncorrect_error_status(pdev);
        /*
         * Running jobs will fail, since it's asynchronous
         * unlike sysfs-requested reset.   Better than
 
        if (!alx_reset_mac(hw))
                rc = PCI_ERS_RESULT_RECOVERED;
 out:
-       pci_cleanup_aer_uncorrect_error_status(pdev);
-
        rtnl_unlock();
 
        return rc;
 
        if (!(bp->flags & BNX2_FLAG_AER_ENABLED))
                return result;
 
-       err = pci_cleanup_aer_uncorrect_error_status(pdev);
-       if (err) {
-               dev_err(&pdev->dev,
-                       "pci_cleanup_aer_uncorrect_error_status failed 0x%0x\n",
-                        err); /* non-fatal, continue */
-       }
-
        return result;
 }
 
 
 
        rtnl_unlock();
 
-       /* If AER, perform cleanup of the PCIe registers */
-       if (bp->flags & AER_ENABLED) {
-               if (pci_cleanup_aer_uncorrect_error_status(pdev))
-                       BNX2X_ERR("pci_cleanup_aer_uncorrect_error_status failed\n");
-               else
-                       DP(NETIF_MSG_HW, "pci_cleanup_aer_uncorrect_error_status succeeded\n");
-       }
-
        return PCI_ERS_RESULT_RECOVERED;
 }
 
 
 
        rtnl_unlock();
 
-       err = pci_cleanup_aer_uncorrect_error_status(pdev);
-       if (err) {
-               dev_err(&pdev->dev,
-                       "pci_cleanup_aer_uncorrect_error_status failed 0x%0x\n",
-                        err); /* non-fatal, continue */
-       }
-
        return PCI_ERS_RESULT_RECOVERED;
 }
 
 
        pci_set_master(pdev);
        pci_restore_state(pdev);
        pci_save_state(pdev);
-       pci_cleanup_aer_uncorrect_error_status(pdev);
 
        if (t4_wait_dev_ready(adap->regs) < 0)
                return PCI_ERS_RESULT_DISCONNECT;
 
        if (status)
                return PCI_ERS_RESULT_DISCONNECT;
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
        be_clear_error(adapter, BE_CLEAR_ALL);
        return PCI_ERS_RESULT_RECOVERED;
 }
 
                result = PCI_ERS_RESULT_RECOVERED;
        }
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
-
        return result;
 }
 
 
                result = PCI_ERS_RESULT_RECOVERED;
        }
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
-
        return result;
 }
 
 
 {
        struct i40e_pf *pf = pci_get_drvdata(pdev);
        pci_ers_result_t result;
-       int err;
        u32 reg;
 
        dev_dbg(&pdev->dev, "%s\n", __func__);
                        result = PCI_ERS_RESULT_DISCONNECT;
        }
 
-       err = pci_cleanup_aer_uncorrect_error_status(pdev);
-       if (err) {
-               dev_info(&pdev->dev,
-                        "pci_cleanup_aer_uncorrect_error_status failed 0x%0x\n",
-                        err);
-               /* non-fatal, continue */
-       }
-
        return result;
 }
 
 
        struct igb_adapter *adapter = netdev_priv(netdev);
        struct e1000_hw *hw = &adapter->hw;
        pci_ers_result_t result;
-       int err;
 
        if (pci_enable_device_mem(pdev)) {
                dev_err(&pdev->dev,
                result = PCI_ERS_RESULT_RECOVERED;
        }
 
-       err = pci_cleanup_aer_uncorrect_error_status(pdev);
-       if (err) {
-               dev_err(&pdev->dev,
-                       "pci_cleanup_aer_uncorrect_error_status failed 0x%0x\n",
-                       err);
-               /* non-fatal, continue */
-       }
-
        return result;
 }
 
 
                        /* Free device reference count */
                        pci_dev_put(vfdev);
                }
-
-               pci_cleanup_aer_uncorrect_error_status(pdev);
        }
 
        /*
 {
        struct ixgbe_adapter *adapter = pci_get_drvdata(pdev);
        pci_ers_result_t result;
-       int err;
 
        if (pci_enable_device_mem(pdev)) {
                e_err(probe, "Cannot re-enable PCI device after reset.\n");
                result = PCI_ERS_RESULT_RECOVERED;
        }
 
-       err = pci_cleanup_aer_uncorrect_error_status(pdev);
-       if (err) {
-               e_dev_err("pci_cleanup_aer_uncorrect_error_status "
-                         "failed 0x%0x\n", err);
-               /* non-fatal, continue */
-       }
-
        return result;
 }
 
 
        return err ? PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_RECOVERED;
 }
 
-static void netxen_io_resume(struct pci_dev *pdev)
-{
-       pci_cleanup_aer_uncorrect_error_status(pdev);
-}
-
 static void netxen_nic_shutdown(struct pci_dev *pdev)
 {
        struct netxen_adapter *adapter = pci_get_drvdata(pdev);
 static const struct pci_error_handlers netxen_err_handler = {
        .error_detected = netxen_io_error_detected,
        .slot_reset = netxen_io_slot_reset,
-       .resume = netxen_io_resume,
 };
 
 static struct pci_driver netxen_driver = {
 
 {
        struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
        if (test_and_clear_bit(__QLCNIC_AER, &adapter->state))
                qlcnic_83xx_aer_start_poll_work(adapter);
 }
 
        u32 state;
        struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
        state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
        if (state == QLCNIC_DEV_READY && test_and_clear_bit(__QLCNIC_AER,
                                                            &adapter->state))
 
 {
        struct efx_nic *efx = pci_get_drvdata(pdev);
        pci_ers_result_t status = PCI_ERS_RESULT_RECOVERED;
-       int rc;
 
        if (pci_enable_device(pdev)) {
                netif_err(efx, hw, efx->net_dev,
                status =  PCI_ERS_RESULT_DISCONNECT;
        }
 
-       rc = pci_cleanup_aer_uncorrect_error_status(pdev);
-       if (rc) {
-               netif_err(efx, hw, efx->net_dev,
-               "pci_cleanup_aer_uncorrect_error_status failed (%d)\n", rc);
-               /* Non-fatal error. Continue. */
-       }
-
        return status;
 }
 
 
 {
        struct ef4_nic *efx = pci_get_drvdata(pdev);
        pci_ers_result_t status = PCI_ERS_RESULT_RECOVERED;
-       int rc;
 
        if (pci_enable_device(pdev)) {
                netif_err(efx, hw, efx->net_dev,
                status =  PCI_ERS_RESULT_DISCONNECT;
        }
 
-       rc = pci_cleanup_aer_uncorrect_error_status(pdev);
-       if (rc) {
-               netif_err(efx, hw, efx->net_dev,
-               "pci_cleanup_aer_uncorrect_error_status failed (%d)\n", rc);
-               /* Non-fatal error. Continue. */
-       }
-
        return status;
 }
 
 
        struct nvme_dev *dev = pci_get_drvdata(pdev);
 
        flush_work(&dev->ctrl.reset_work);
-       pci_cleanup_aer_uncorrect_error_status(pdev);
 }
 
 static const struct pci_error_handlers nvme_err_handler = {
 
        struct scsi_device *sdev = NULL;
        struct aac_dev *aac = (struct aac_dev *)shost_priv(shost);
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
-
        if (aac_adapter_ioremap(aac, aac->base_size)) {
 
                dev_err(&pdev->dev, "aacraid: ioremap failed\n");
 
                return PCI_ERS_RESULT_DISCONNECT;
        }
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
        return PCI_ERS_RESULT_RECOVERED;
 }
 
 
                if (pci_set_dma_mask(bfad->pcidev, DMA_BIT_MASK(32)) != 0)
                        goto out_disable_device;
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
-
        if (restart_bfa(bfad) == -1)
                goto out_disable_device;
 
 
        pci_set_master(pdev);
        pci_restore_state(pdev);
        pci_save_state(pdev);
-       pci_cleanup_aer_uncorrect_error_status(pdev);
 
        /* Bring HW s/m to ready state.
         * but don't resume IOs.
 
 
        /* Bring device online, it will be no-op for non-fatal error resume */
        lpfc_online(phba);
-
-       /* Clean up Advanced Error Reporting (AER) if needed */
-       if (phba->hba_flag & HBA_AER_ENABLED)
-               pci_cleanup_aer_uncorrect_error_status(pdev);
 }
 
 /**
                /* Bring the device back online */
                lpfc_online(phba);
        }
-
-       /* Clean up Advanced Error Reporting (AER) if needed */
-       if (phba->hba_flag & HBA_AER_ENABLED)
-               pci_cleanup_aer_uncorrect_error_status(pdev);
 }
 
 /**
 
 
        pr_info(MPT3SAS_FMT "PCI error: resume callback!!\n", ioc->name);
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
        mpt3sas_base_start_watchdog(ioc);
        scsi_unblock_requests(ioc->shost);
 }
 
                    "The device failed to resume I/O from slot/link_reset.\n");
        }
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
-
        ha->flags.eeh_busy = 0;
 }
 
 
                     __func__);
        }
 
-       pci_cleanup_aer_uncorrect_error_status(pdev);
        clear_bit(AF_EEH_BUSY, &ha->flags);
 }