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 
merge_result(enum pci_ers_result orig,enum pci_ers_result new)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 
report_error_detected(struct pci_dev * dev,pci_channel_state_t state,enum pci_ers_result * result)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 
report_frozen_detected(struct pci_dev * dev,void * data)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 
report_normal_detected(struct pci_dev * dev,void * data)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 
report_mmio_enabled(struct pci_dev * dev,void * data)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 
report_slot_reset(struct pci_dev * dev,void * data)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 
report_resume(struct pci_dev * dev,void * data)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  */
pci_walk_bridge(struct pci_dev * bridge,int (* cb)(struct pci_dev *,void *),void * userdata)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 
pcie_do_recovery(struct pci_dev * dev,pci_channel_state_t state,pci_ers_result_t (* reset_subordinates)(struct pci_dev * pdev))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