mirror of
git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2025-08-05 16:54:27 +00:00

In some cases a bridge may not exist as the hardware controlling may be handled only by firmware and so is not visible to the OS. This scenario is also possible in future use cases involving non-native use of RCECs by firmware. In this scenario, we expect the platform to retain control of the bridge and to clear error status itself. Clear error status only when the OS has native control of AER. Signed-off-by: Sean V Kelley <sean.v.kelley@intel.com> Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
242 lines
6.5 KiB
C
242 lines
6.5 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* This file implements the error recovery as a core part of PCIe error
|
|
* reporting. When a PCIe error is delivered, an error message will be
|
|
* collected and printed to console, then, an error recovery procedure
|
|
* will be executed by following the PCI error recovery rules.
|
|
*
|
|
* Copyright (C) 2006 Intel Corp.
|
|
* Tom Long Nguyen (tom.l.nguyen@intel.com)
|
|
* Zhang Yanmin (yanmin.zhang@intel.com)
|
|
*/
|
|
|
|
#define dev_fmt(fmt) "AER: " fmt
|
|
|
|
#include <linux/pci.h>
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/aer.h>
|
|
#include "portdrv.h"
|
|
#include "../pci.h"
|
|
|
|
static pci_ers_result_t merge_result(enum pci_ers_result orig,
|
|
enum pci_ers_result new)
|
|
{
|
|
if (new == PCI_ERS_RESULT_NO_AER_DRIVER)
|
|
return PCI_ERS_RESULT_NO_AER_DRIVER;
|
|
|
|
if (new == PCI_ERS_RESULT_NONE)
|
|
return orig;
|
|
|
|
switch (orig) {
|
|
case PCI_ERS_RESULT_CAN_RECOVER:
|
|
case PCI_ERS_RESULT_RECOVERED:
|
|
orig = new;
|
|
break;
|
|
case PCI_ERS_RESULT_DISCONNECT:
|
|
if (new == PCI_ERS_RESULT_NEED_RESET)
|
|
orig = PCI_ERS_RESULT_NEED_RESET;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return orig;
|
|
}
|
|
|
|
static int report_error_detected(struct pci_dev *dev,
|
|
pci_channel_state_t state,
|
|
enum pci_ers_result *result)
|
|
{
|
|
pci_ers_result_t vote;
|
|
const struct pci_error_handlers *err_handler;
|
|
|
|
device_lock(&dev->dev);
|
|
if (!pci_dev_set_io_state(dev, state) ||
|
|
!dev->driver ||
|
|
!dev->driver->err_handler ||
|
|
!dev->driver->err_handler->error_detected) {
|
|
/*
|
|
* If any device in the subtree does not have an error_detected
|
|
* callback, PCI_ERS_RESULT_NO_AER_DRIVER prevents subsequent
|
|
* error callbacks of "any" device in the subtree, and will
|
|
* exit in the disconnected error state.
|
|
*/
|
|
if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
|
|
vote = PCI_ERS_RESULT_NO_AER_DRIVER;
|
|
pci_info(dev, "can't recover (no error_detected callback)\n");
|
|
} else {
|
|
vote = PCI_ERS_RESULT_NONE;
|
|
}
|
|
} else {
|
|
err_handler = dev->driver->err_handler;
|
|
vote = err_handler->error_detected(dev, state);
|
|
}
|
|
pci_uevent_ers(dev, vote);
|
|
*result = merge_result(*result, vote);
|
|
device_unlock(&dev->dev);
|
|
return 0;
|
|
}
|
|
|
|
static int report_frozen_detected(struct pci_dev *dev, void *data)
|
|
{
|
|
return report_error_detected(dev, pci_channel_io_frozen, data);
|
|
}
|
|
|
|
static int report_normal_detected(struct pci_dev *dev, void *data)
|
|
{
|
|
return report_error_detected(dev, pci_channel_io_normal, data);
|
|
}
|
|
|
|
static int report_mmio_enabled(struct pci_dev *dev, void *data)
|
|
{
|
|
pci_ers_result_t vote, *result = data;
|
|
const struct pci_error_handlers *err_handler;
|
|
|
|
device_lock(&dev->dev);
|
|
if (!dev->driver ||
|
|
!dev->driver->err_handler ||
|
|
!dev->driver->err_handler->mmio_enabled)
|
|
goto out;
|
|
|
|
err_handler = dev->driver->err_handler;
|
|
vote = err_handler->mmio_enabled(dev);
|
|
*result = merge_result(*result, vote);
|
|
out:
|
|
device_unlock(&dev->dev);
|
|
return 0;
|
|
}
|
|
|
|
static int report_slot_reset(struct pci_dev *dev, void *data)
|
|
{
|
|
pci_ers_result_t vote, *result = data;
|
|
const struct pci_error_handlers *err_handler;
|
|
|
|
device_lock(&dev->dev);
|
|
if (!dev->driver ||
|
|
!dev->driver->err_handler ||
|
|
!dev->driver->err_handler->slot_reset)
|
|
goto out;
|
|
|
|
err_handler = dev->driver->err_handler;
|
|
vote = err_handler->slot_reset(dev);
|
|
*result = merge_result(*result, vote);
|
|
out:
|
|
device_unlock(&dev->dev);
|
|
return 0;
|
|
}
|
|
|
|
static int report_resume(struct pci_dev *dev, void *data)
|
|
{
|
|
const struct pci_error_handlers *err_handler;
|
|
|
|
device_lock(&dev->dev);
|
|
if (!pci_dev_set_io_state(dev, pci_channel_io_normal) ||
|
|
!dev->driver ||
|
|
!dev->driver->err_handler ||
|
|
!dev->driver->err_handler->resume)
|
|
goto out;
|
|
|
|
err_handler = dev->driver->err_handler;
|
|
err_handler->resume(dev);
|
|
out:
|
|
pci_uevent_ers(dev, PCI_ERS_RESULT_RECOVERED);
|
|
device_unlock(&dev->dev);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pci_walk_bridge - walk bridges potentially AER affected
|
|
* @bridge: bridge which may be a Port
|
|
* @cb: callback to be called for each device found
|
|
* @userdata: arbitrary pointer to be passed to callback
|
|
*
|
|
* If the device provided is a bridge, walk the subordinate bus, including
|
|
* any bridged devices on buses under this bus. Call the provided callback
|
|
* on each device found.
|
|
*/
|
|
static void pci_walk_bridge(struct pci_dev *bridge,
|
|
int (*cb)(struct pci_dev *, void *),
|
|
void *userdata)
|
|
{
|
|
if (bridge->subordinate)
|
|
pci_walk_bus(bridge->subordinate, cb, userdata);
|
|
}
|
|
|
|
pci_ers_result_t pcie_do_recovery(struct pci_dev *dev,
|
|
pci_channel_state_t state,
|
|
pci_ers_result_t (*reset_subordinates)(struct pci_dev *pdev))
|
|
{
|
|
int type = pci_pcie_type(dev);
|
|
struct pci_dev *bridge;
|
|
pci_ers_result_t status = PCI_ERS_RESULT_CAN_RECOVER;
|
|
struct pci_host_bridge *host = pci_find_host_bridge(dev->bus);
|
|
|
|
/*
|
|
* Error recovery runs on all subordinates of the bridge. If the
|
|
* bridge detected the error, it is cleared at the end.
|
|
*/
|
|
if (type == PCI_EXP_TYPE_ROOT_PORT ||
|
|
type == PCI_EXP_TYPE_DOWNSTREAM)
|
|
bridge = dev;
|
|
else
|
|
bridge = pci_upstream_bridge(dev);
|
|
|
|
pci_dbg(bridge, "broadcast error_detected message\n");
|
|
if (state == pci_channel_io_frozen) {
|
|
pci_walk_bridge(bridge, report_frozen_detected, &status);
|
|
status = reset_subordinates(bridge);
|
|
if (status != PCI_ERS_RESULT_RECOVERED) {
|
|
pci_warn(bridge, "subordinate device reset failed\n");
|
|
goto failed;
|
|
}
|
|
} else {
|
|
pci_walk_bridge(bridge, report_normal_detected, &status);
|
|
}
|
|
|
|
if (status == PCI_ERS_RESULT_CAN_RECOVER) {
|
|
status = PCI_ERS_RESULT_RECOVERED;
|
|
pci_dbg(bridge, "broadcast mmio_enabled message\n");
|
|
pci_walk_bridge(bridge, report_mmio_enabled, &status);
|
|
}
|
|
|
|
if (status == PCI_ERS_RESULT_NEED_RESET) {
|
|
/*
|
|
* TODO: Should call platform-specific
|
|
* functions to reset slot before calling
|
|
* drivers' slot_reset callbacks?
|
|
*/
|
|
status = PCI_ERS_RESULT_RECOVERED;
|
|
pci_dbg(bridge, "broadcast slot_reset message\n");
|
|
pci_walk_bridge(bridge, report_slot_reset, &status);
|
|
}
|
|
|
|
if (status != PCI_ERS_RESULT_RECOVERED)
|
|
goto failed;
|
|
|
|
pci_dbg(bridge, "broadcast resume message\n");
|
|
pci_walk_bridge(bridge, report_resume, &status);
|
|
|
|
/*
|
|
* If we have native control of AER, clear error status in the Root
|
|
* Port or Downstream Port that signaled the error. If the
|
|
* platform retained control of AER, it is responsible for clearing
|
|
* this status. In that case, the signaling device may not even be
|
|
* visible to the OS.
|
|
*/
|
|
if (host->native_aer || pcie_ports_native) {
|
|
pcie_clear_device_status(bridge);
|
|
pci_aer_clear_nonfatal_status(bridge);
|
|
}
|
|
pci_info(bridge, "device recovery successful\n");
|
|
return status;
|
|
|
|
failed:
|
|
pci_uevent_ers(bridge, PCI_ERS_RESULT_DISCONNECT);
|
|
|
|
/* TODO: Should kernel panic here? */
|
|
pci_info(bridge, "device recovery failed\n");
|
|
|
|
return status;
|
|
}
|