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                                  enum pci_channel_state state,
  50                                  enum pci_ers_result *result)
  51 {
  52         pci_ers_result_t vote;
  53         const struct pci_error_handlers *err_handler;
  54
  55         device_lock(&dev->dev);
  56         if (!pci_dev_set_io_state(dev, state) ||
  57                 !dev->driver ||
  58                 !dev->driver->err_handler ||
  59                 !dev->driver->err_handler->error_detected) {
  60                 /*
  61                  * If any device in the subtree does not have an error_detected
  62                  * callback, PCI_ERS_RESULT_NO_AER_DRIVER prevents subsequent
  63                  * error callbacks of "any" device in the subtree, and will
  64                  * exit in the disconnected error state.
  65                  */
  66                 if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
  67                         vote = PCI_ERS_RESULT_NO_AER_DRIVER;
  68                         pci_info(dev, "can't recover (no error_detected callback)\n");
  69                 } else {
  70                         vote = PCI_ERS_RESULT_NONE;
  71                 }
  72         } else {
  73                 err_handler = dev->driver->err_handler;
  74                 vote = err_handler->error_detected(dev, state);
  75         }
  76         pci_uevent_ers(dev, vote);
  77         *result = merge_result(*result, vote);
  78         device_unlock(&dev->dev);
  79         return 0;
  80 }
  81
  82 static int report_frozen_detected(struct pci_dev *dev, void *data)
  83 {
  84         return report_error_detected(dev, pci_channel_io_frozen, data);
  85 }
  86
  87 static int report_normal_detected(struct pci_dev *dev, void *data)
  88 {
  89         return report_error_detected(dev, pci_channel_io_normal, data);
  90 }
  91
  92 static int report_mmio_enabled(struct pci_dev *dev, void *data)
  93 {
  94         pci_ers_result_t vote, *result = data;
  95         const struct pci_error_handlers *err_handler;
  96
  97         device_lock(&dev->dev);
  98         if (!dev->driver ||
  99                 !dev->driver->err_handler ||
 100                 !dev->driver->err_handler->mmio_enabled)
 101                 goto out;
 102
 103         err_handler = dev->driver->err_handler;
 104         vote = err_handler->mmio_enabled(dev);
 105         *result = merge_result(*result, vote);
 106 out:
 107         device_unlock(&dev->dev);
 108         return 0;
 109 }
 110
 111 static int report_slot_reset(struct pci_dev *dev, void *data)
 112 {
 113         pci_ers_result_t vote, *result = data;
 114         const struct pci_error_handlers *err_handler;
 115
 116         device_lock(&dev->dev);
 117         if (!dev->driver ||
 118                 !dev->driver->err_handler ||
 119                 !dev->driver->err_handler->slot_reset)
 120                 goto out;
 121
 122         err_handler = dev->driver->err_handler;
 123         vote = err_handler->slot_reset(dev);
 124         *result = merge_result(*result, vote);
 125 out:
 126         device_unlock(&dev->dev);
 127         return 0;
 128 }
 129
 130 static int report_resume(struct pci_dev *dev, void *data)
 131 {
 132         const struct pci_error_handlers *err_handler;
 133
 134         device_lock(&dev->dev);
 135         if (!pci_dev_set_io_state(dev, pci_channel_io_normal) ||
 136                 !dev->driver ||
 137                 !dev->driver->err_handler ||
 138                 !dev->driver->err_handler->resume)
 139                 goto out;
 140
 141         err_handler = dev->driver->err_handler;
 142         err_handler->resume(dev);
 143 out:
 144         pci_uevent_ers(dev, PCI_ERS_RESULT_RECOVERED);
 145         device_unlock(&dev->dev);
 146         return 0;
 147 }
 148
 149 /**
 150  * default_reset_link - default reset function
 151  * @dev: pointer to pci_dev data structure
 152  *
 153  * Invoked when performing link reset on a Downstream Port or a
 154  * Root Port with no aer driver.
 155  */
 156 static pci_ers_result_t default_reset_link(struct pci_dev *dev)
 157 {
 158         int rc;
 159
 160         rc = pci_bus_error_reset(dev);
 161         pci_printk(KERN_DEBUG, dev, "downstream link has been reset\n");
 162         return rc ? PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_RECOVERED;
 163 }
 164
 165 static pci_ers_result_t reset_link(struct pci_dev *dev, u32 service)
 166 {
 167         pci_ers_result_t status;
 168         struct pcie_port_service_driver *driver = NULL;
 169
 170         driver = pcie_port_find_service(dev, service);
 171         if (driver && driver->reset_link) {
 172                 status = driver->reset_link(dev);
 173         } else if (pcie_downstream_port(dev)) {
 174                 status = default_reset_link(dev);
 175         } else {
 176                 pci_printk(KERN_DEBUG, dev, "no link-reset support at upstream device %s\n",
 177                         pci_name(dev));
 178                 return PCI_ERS_RESULT_DISCONNECT;
 179         }
 180
 181         if (status != PCI_ERS_RESULT_RECOVERED) {
 182                 pci_printk(KERN_DEBUG, dev, "link reset at upstream device %s failed\n",
 183                         pci_name(dev));
 184                 return PCI_ERS_RESULT_DISCONNECT;
 185         }
 186
 187         return status;
 188 }
 189
 190 void pcie_do_recovery(struct pci_dev *dev, enum pci_channel_state state,
 191                       u32 service)
 192 {
 193         pci_ers_result_t status = PCI_ERS_RESULT_CAN_RECOVER;
 194         struct pci_bus *bus;
 195
 196         /*
 197          * Error recovery runs on all subordinates of the first downstream port.
 198          * If the downstream port detected the error, it is cleared at the end.
 199          */
 200         if (!(pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT ||
 201               pci_pcie_type(dev) == PCI_EXP_TYPE_DOWNSTREAM))
 202                 dev = dev->bus->self;
 203         bus = dev->subordinate;
 204
 205         pci_dbg(dev, "broadcast error_detected message\n");
 206         if (state == pci_channel_io_frozen)
 207                 pci_walk_bus(bus, report_frozen_detected, &status);
 208         else
 209                 pci_walk_bus(bus, report_normal_detected, &status);
 210
 211         if (state == pci_channel_io_frozen &&
 212             reset_link(dev, service) != PCI_ERS_RESULT_RECOVERED)
 213                 goto failed;
 214
 215         if (status == PCI_ERS_RESULT_CAN_RECOVER) {
 216                 status = PCI_ERS_RESULT_RECOVERED;
 217                 pci_dbg(dev, "broadcast mmio_enabled message\n");
 218                 pci_walk_bus(bus, report_mmio_enabled, &status);
 219         }
 220
 221         if (status == PCI_ERS_RESULT_NEED_RESET) {
 222                 /*
 223                  * TODO: Should call platform-specific
 224                  * functions to reset slot before calling
 225                  * drivers' slot_reset callbacks?
 226                  */
 227                 status = PCI_ERS_RESULT_RECOVERED;
 228                 pci_dbg(dev, "broadcast slot_reset message\n");
 229                 pci_walk_bus(bus, report_slot_reset, &status);
 230         }
 231
 232         if (status != PCI_ERS_RESULT_RECOVERED)
 233                 goto failed;
 234
 235         pci_dbg(dev, "broadcast resume message\n");
 236         pci_walk_bus(bus, report_resume, &status);
 237
 238         pci_aer_clear_device_status(dev);
 239         pci_cleanup_aer_uncorrect_error_status(dev);
 240         pci_info(dev, "device recovery successful\n");
 241         return;
 242
 243 failed:
 244         pci_uevent_ers(dev, PCI_ERS_RESULT_DISCONNECT);
 245
 246         /* TODO: Should kernel panic here? */
 247         pci_info(dev, "device recovery failed\n");
 248 }