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 } 265