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