drivers/pci/pcie/err.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * This file implements the error recovery as a core part of PCIe error
   4  * reporting. When a PCIe error is delivered, an error message will be
   5  * collected and printed to console, then, an error recovery procedure
   6  * will be executed by following the PCI error recovery rules.
   7  *
   8  * Copyright (C) 2006 Intel Corp.
   9  *      Tom Long Nguyen (tom.l.nguyen@intel.com)
  10  *      Zhang Yanmin (yanmin.zhang@intel.com)
  11  */
  12
  13 #define dev_fmt(fmt) "AER: " fmt
  14
  15 #include <linux/pci.h>
  16 #include <linux/module.h>
  17 #include <linux/kernel.h>
  18 #include <linux/errno.h>
  19 #include <linux/aer.h>
  20 #include "portdrv.h"
  21 #include "../pci.h"
  22
  23 static pci_ers_result_t merge_result(enum pci_ers_result orig,
  24                                   enum pci_ers_result new)
  25 {
  26         if (new == PCI_ERS_RESULT_NO_AER_DRIVER)
  27                 return PCI_ERS_RESULT_NO_AER_DRIVER;
  28
  29         if (new == PCI_ERS_RESULT_NONE)
  30                 return orig;
  31
  32         switch (orig) {
  33         case PCI_ERS_RESULT_CAN_RECOVER:
  34         case PCI_ERS_RESULT_RECOVERED:
  35                 orig = new;
  36                 break;
  37         case PCI_ERS_RESULT_DISCONNECT:
  38                 if (new == PCI_ERS_RESULT_NEED_RESET)
  39                         orig = PCI_ERS_RESULT_NEED_RESET;
  40                 break;
  41         default:
  42                 break;
  43         }
  44
  45         return orig;
  46 }
  47
  48 static int report_error_detected(struct pci_dev *dev,
  49                                  pci_channel_state_t state,
  50                                  enum pci_ers_result *result)
  51 {
  52         struct pci_driver *pdrv;
  53         pci_ers_result_t vote;
  54         const struct pci_error_handlers *err_handler;
  55
  56         device_lock(&dev->dev);
  57         pdrv = dev->driver;
  58         if (pci_dev_is_disconnected(dev)) {
  59                 vote = PCI_ERS_RESULT_DISCONNECT;
  60         } else if (!pci_dev_set_io_state(dev, state)) {
  61                 pci_info(dev, "can't recover (state transition %u -> %u invalid)\n",
  62                         dev->error_state, state);
  63                 vote = PCI_ERS_RESULT_NONE;
  64         } else if (!pdrv || !pdrv->err_handler ||
  65                    !pdrv->err_handler->error_detected) {
  66                 /*
  67                  * If any device in the subtree does not have an error_detected
  68                  * callback, PCI_ERS_RESULT_NO_AER_DRIVER prevents subsequent
  69                  * error callbacks of "any" device in the subtree, and will
  70                  * exit in the disconnected error state.
  71                  */
  72                 if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
  73                         vote = PCI_ERS_RESULT_NO_AER_DRIVER;
  74                         pci_info(dev, "can't recover (no error_detected callback)\n");
  75                 } else {
  76                         vote = PCI_ERS_RESULT_NONE;
  77                 }
  78         } else {
  79                 err_handler = pdrv->err_handler;
  80                 vote = err_handler->error_detected(dev, state);
  81         }
  82         pci_uevent_ers(dev, vote);
  83         *result = merge_result(*result, vote);
  84         device_unlock(&dev->dev);
  85         return 0;
  86 }
  87
  88 static int report_frozen_detected(struct pci_dev *dev, void *data)
  89 {
  90         return report_error_detected(dev, pci_channel_io_frozen, data);
  91 }
  92
  93 static int report_normal_detected(struct pci_dev *dev, void *data)
  94 {
  95         return report_error_detected(dev, pci_channel_io_normal, data);
  96 }
  97
  98 static int report_mmio_enabled(struct pci_dev *dev, void *data)
  99 {
 100         struct pci_driver *pdrv;
 101         pci_ers_result_t vote, *result = data;
 102         const struct pci_error_handlers *err_handler;
 103
 104         device_lock(&dev->dev);
 105         pdrv = dev->driver;
 106         if (!pdrv ||
 107                 !pdrv->err_handler ||
 108                 !pdrv->err_handler->mmio_enabled)
 109                 goto out;
 110
 111         err_handler = pdrv->err_handler;
 112         vote = err_handler->mmio_enabled(dev);
 113         *result = merge_result(*result, vote);
 114 out:
 115         device_unlock(&dev->dev);
 116         return 0;
 117 }
 118
 119 static int report_slot_reset(struct pci_dev *dev, void *data)
 120 {
 121         struct pci_driver *pdrv;
 122         pci_ers_result_t vote, *result = data;
 123         const struct pci_error_handlers *err_handler;
 124
 125         device_lock(&dev->dev);
 126         pdrv = dev->driver;
 127         if (!pdrv ||
 128                 !pdrv->err_handler ||
 129                 !pdrv->err_handler->slot_reset)
 130                 goto out;
 131
 132         err_handler = pdrv->err_handler;
 133         vote = err_handler->slot_reset(dev);
 134         *result = merge_result(*result, vote);
 135 out:
 136         device_unlock(&dev->dev);
 137         return 0;
 138 }
 139
 140 static int report_resume(struct pci_dev *dev, void *data)
 141 {
 142         struct pci_driver *pdrv;
 143         const struct pci_error_handlers *err_handler;
 144
 145         device_lock(&dev->dev);
 146         pdrv = dev->driver;
 147         if (!pci_dev_set_io_state(dev, pci_channel_io_normal) ||
 148                 !pdrv ||
 149                 !pdrv->err_handler ||
 150                 !pdrv->err_handler->resume)
 151                 goto out;
 152
 153         err_handler = pdrv->err_handler;
 154         err_handler->resume(dev);
 155 out:
 156         pci_uevent_ers(dev, PCI_ERS_RESULT_RECOVERED);
 157         device_unlock(&dev->dev);
 158         return 0;
 159 }
 160
 161 /**
 162  * pci_walk_bridge - walk bridges potentially AER affected
 163  * @bridge:     bridge which may be a Port, an RCEC, or an RCiEP
 164  * @cb:         callback to be called for each device found
 165  * @userdata:   arbitrary pointer to be passed to callback
 166  *
 167  * If the device provided is a bridge, walk the subordinate bus, including
 168  * any bridged devices on buses under this bus.  Call the provided callback
 169  * on each device found.
 170  *
 171  * If the device provided has no subordinate bus, e.g., an RCEC or RCiEP,
 172  * call the callback on the device itself.
 173  */
 174 static void pci_walk_bridge(struct pci_dev *bridge,
 175                             int (*cb)(struct pci_dev *, void *),
 176                             void *userdata)
 177 {
 178         if (bridge->subordinate)
 179                 pci_walk_bus(bridge->subordinate, cb, userdata);
 180         else
 181                 cb(bridge, userdata);
 182 }
 183
 184 pci_ers_result_t pcie_do_recovery(struct pci_dev *dev,
 185                 pci_channel_state_t state,
 186                 pci_ers_result_t (*reset_subordinates)(struct pci_dev *pdev))
 187 {
 188         int type = pci_pcie_type(dev);
 189         struct pci_dev *bridge;
 190         pci_ers_result_t status = PCI_ERS_RESULT_CAN_RECOVER;
 191         struct pci_host_bridge *host = pci_find_host_bridge(dev->bus);
 192
 193         /*
 194          * If the error was detected by a Root Port, Downstream Port, RCEC,
 195          * or RCiEP, recovery runs on the device itself.  For Ports, that
 196          * also includes any subordinate devices.
 197          *
 198          * If it was detected by another device (Endpoint, etc), recovery
 199          * runs on the device and anything else under the same Port, i.e.,
 200          * everything under "bridge".
 201          */
 202         if (type == PCI_EXP_TYPE_ROOT_PORT ||
 203             type == PCI_EXP_TYPE_DOWNSTREAM ||
 204             type == PCI_EXP_TYPE_RC_EC ||
 205             type == PCI_EXP_TYPE_RC_END)
 206                 bridge = dev;
 207         else
 208                 bridge = pci_upstream_bridge(dev);
 209
 210         pci_dbg(bridge, "broadcast error_detected message\n");
 211         if (state == pci_channel_io_frozen) {
 212                 pci_walk_bridge(bridge, report_frozen_detected, &status);
 213                 if (reset_subordinates(bridge) != PCI_ERS_RESULT_RECOVERED) {
 214                         pci_warn(bridge, "subordinate device reset failed\n");
 215                         goto failed;
 216                 }
 217         } else {
 218                 pci_walk_bridge(bridge, report_normal_detected, &status);
 219         }
 220
 221         if (status == PCI_ERS_RESULT_CAN_RECOVER) {
 222                 status = PCI_ERS_RESULT_RECOVERED;
 223                 pci_dbg(bridge, "broadcast mmio_enabled message\n");
 224                 pci_walk_bridge(bridge, report_mmio_enabled, &status);
 225         }
 226
 227         if (status == PCI_ERS_RESULT_NEED_RESET) {
 228                 /*
 229                  * TODO: Should call platform-specific
 230                  * functions to reset slot before calling
 231                  * drivers' slot_reset callbacks?
 232                  */
 233                 status = PCI_ERS_RESULT_RECOVERED;
 234                 pci_dbg(bridge, "broadcast slot_reset message\n");
 235                 pci_walk_bridge(bridge, report_slot_reset, &status);
 236         }
 237
 238         if (status != PCI_ERS_RESULT_RECOVERED)
 239                 goto failed;
 240
 241         pci_dbg(bridge, "broadcast resume message\n");
 242         pci_walk_bridge(bridge, report_resume, &status);
 243
 244         /*
 245          * If we have native control of AER, clear error status in the device
 246          * that detected the error.  If the platform retained control of AER,
 247          * it is responsible for clearing this status.  In that case, the
 248          * signaling device may not even be visible to the OS.
 249          */
 250         if (host->native_aer || pcie_ports_native) {
 251                 pcie_clear_device_status(dev);
 252                 pci_aer_clear_nonfatal_status(dev);
 253         }
 254         pci_info(bridge, "device recovery successful\n");
 255         return status;
 256
 257 failed:
 258         pci_uevent_ers(bridge, PCI_ERS_RESULT_DISCONNECT);
 259
 260         /* TODO: Should kernel panic here? */
 261         pci_info(bridge, "device recovery failed\n");
 262
 263         return status;
 264 }