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 23static 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 48static int report_error_detected(struct pci_dev *dev, 49 pci_channel_state_t 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 82static int report_frozen_detected(struct pci_dev *dev, void *data) 83{ 84 return report_error_detected(dev, pci_channel_io_frozen, data); 85} 86 87static int report_normal_detected(struct pci_dev *dev, void *data) 88{ 89 return report_error_detected(dev, pci_channel_io_normal, data); 90} 91 92static 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); 106out: 107 device_unlock(&dev->dev); 108 return 0; 109} 110 111static 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); 125out: 126 device_unlock(&dev->dev); 127 return 0; 128} 129 130static 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); 143out: 144 pci_uevent_ers(dev, PCI_ERS_RESULT_RECOVERED); 145 device_unlock(&dev->dev); 146 return 0; 147} 148 149/** 150 * pci_walk_bridge - walk bridges potentially AER affected 151 * @bridge: bridge which may be a Port or an RCEC 152 * @cb: callback to be called for each device found 153 * @userdata: arbitrary pointer to be passed to callback 154 * 155 * If the device provided is a bridge, walk the subordinate bus, including 156 * any bridged devices on buses under this bus. Call the provided callback 157 * on each device found. 158 * 159 * If the device provided has no subordinate bus, e.g., an RCEC, call the 160 * callback on the device itself. 161 */ 162static void pci_walk_bridge(struct pci_dev *bridge, 163 int (*cb)(struct pci_dev *, void *), 164 void *userdata) 165{ 166 if (bridge->subordinate) 167 pci_walk_bus(bridge->subordinate, cb, userdata); 168 else 169 cb(bridge, userdata); 170} 171 172pci_ers_result_t pcie_do_recovery(struct pci_dev *dev, 173 pci_channel_state_t state, 174 pci_ers_result_t (*reset_subordinates)(struct pci_dev *pdev)) 175{ 176 int type = pci_pcie_type(dev); 177 struct pci_dev *bridge; 178 pci_ers_result_t status = PCI_ERS_RESULT_CAN_RECOVER; 179 180 /* 181 * If the error was detected by a Root Port, Downstream Port, or 182 * RCEC, recovery runs on the device itself. For Ports, that also 183 * includes any subordinate devices. 184 * 185 * If it was detected by another device (Endpoint, etc), recovery 186 * runs on the device and anything else under the same Port, i.e., 187 * everything under "bridge". 188 */ 189 if (type == PCI_EXP_TYPE_ROOT_PORT || 190 type == PCI_EXP_TYPE_DOWNSTREAM || 191 type == PCI_EXP_TYPE_RC_EC) 192 bridge = dev; 193 else 194 bridge = pci_upstream_bridge(dev); 195 196 pci_dbg(bridge, "broadcast error_detected message\n"); 197 if (state == pci_channel_io_frozen) { 198 pci_walk_bridge(bridge, report_frozen_detected, &status); 199 if (reset_subordinates(bridge) != PCI_ERS_RESULT_RECOVERED) { 200 pci_warn(bridge, "subordinate device reset failed\n"); 201 goto failed; 202 } 203 } else { 204 pci_walk_bridge(bridge, report_normal_detected, &status); 205 } 206 207 if (status == PCI_ERS_RESULT_CAN_RECOVER) { 208 status = PCI_ERS_RESULT_RECOVERED; 209 pci_dbg(bridge, "broadcast mmio_enabled message\n"); 210 pci_walk_bridge(bridge, report_mmio_enabled, &status); 211 } 212 213 if (status == PCI_ERS_RESULT_NEED_RESET) { 214 /* 215 * TODO: Should call platform-specific 216 * functions to reset slot before calling 217 * drivers' slot_reset callbacks? 218 */ 219 status = PCI_ERS_RESULT_RECOVERED; 220 pci_dbg(bridge, "broadcast slot_reset message\n"); 221 pci_walk_bridge(bridge, report_slot_reset, &status); 222 } 223 224 if (status != PCI_ERS_RESULT_RECOVERED) 225 goto failed; 226 227 pci_dbg(bridge, "broadcast resume message\n"); 228 pci_walk_bridge(bridge, report_resume, &status); 229 230 if (pcie_aer_is_native(bridge)) 231 pcie_clear_device_status(bridge); 232 pci_aer_clear_nonfatal_status(bridge); 233 pci_info(bridge, "device recovery successful\n"); 234 return status; 235 236failed: 237 pci_uevent_ers(bridge, PCI_ERS_RESULT_DISCONNECT); 238 239 /* TODO: Should kernel panic here? */ 240 pci_info(bridge, "device recovery failed\n"); 241 242 return status; 243} 244