Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright IBM Corp. 2012
4 *
5 * Author(s):
6 * Jan Glauber <jang@linux.vnet.ibm.com>
7 */
8
9#define KMSG_COMPONENT "zpci"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
12#include <linux/kernel.h>
13#include <linux/pci.h>
14#include <asm/pci_debug.h>
15#include <asm/pci_dma.h>
16#include <asm/sclp.h>
17
18#include "pci_bus.h"
19
20/* Content Code Description for PCI Function Error */
21struct zpci_ccdf_err {
22 u32 reserved1;
23 u32 fh; /* function handle */
24 u32 fid; /* function id */
25 u32 ett : 4; /* expected table type */
26 u32 mvn : 12; /* MSI vector number */
27 u32 dmaas : 8; /* DMA address space */
28 u32 : 6;
29 u32 q : 1; /* event qualifier */
30 u32 rw : 1; /* read/write */
31 u64 faddr; /* failing address */
32 u32 reserved3;
33 u16 reserved4;
34 u16 pec; /* PCI event code */
35} __packed;
36
37/* Content Code Description for PCI Function Availability */
38struct zpci_ccdf_avail {
39 u32 reserved1;
40 u32 fh; /* function handle */
41 u32 fid; /* function id */
42 u32 reserved2;
43 u32 reserved3;
44 u32 reserved4;
45 u32 reserved5;
46 u16 reserved6;
47 u16 pec; /* PCI event code */
48} __packed;
49
50static inline bool ers_result_indicates_abort(pci_ers_result_t ers_res)
51{
52 switch (ers_res) {
53 case PCI_ERS_RESULT_CAN_RECOVER:
54 case PCI_ERS_RESULT_RECOVERED:
55 case PCI_ERS_RESULT_NEED_RESET:
56 return false;
57 default:
58 return true;
59 }
60}
61
62static bool is_passed_through(struct pci_dev *pdev)
63{
64 struct zpci_dev *zdev = to_zpci(pdev);
65 bool ret;
66
67 mutex_lock(&zdev->kzdev_lock);
68 ret = !!zdev->kzdev;
69 mutex_unlock(&zdev->kzdev_lock);
70
71 return ret;
72}
73
74static bool is_driver_supported(struct pci_driver *driver)
75{
76 if (!driver || !driver->err_handler)
77 return false;
78 if (!driver->err_handler->error_detected)
79 return false;
80 if (!driver->err_handler->slot_reset)
81 return false;
82 if (!driver->err_handler->resume)
83 return false;
84 return true;
85}
86
87static pci_ers_result_t zpci_event_notify_error_detected(struct pci_dev *pdev,
88 struct pci_driver *driver)
89{
90 pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
91
92 ers_res = driver->err_handler->error_detected(pdev, pdev->error_state);
93 if (ers_result_indicates_abort(ers_res))
94 pr_info("%s: Automatic recovery failed after initial reporting\n", pci_name(pdev));
95 else if (ers_res == PCI_ERS_RESULT_NEED_RESET)
96 pr_debug("%s: Driver needs reset to recover\n", pci_name(pdev));
97
98 return ers_res;
99}
100
101static pci_ers_result_t zpci_event_do_error_state_clear(struct pci_dev *pdev,
102 struct pci_driver *driver)
103{
104 pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
105 struct zpci_dev *zdev = to_zpci(pdev);
106 int rc;
107
108 pr_info("%s: Unblocking device access for examination\n", pci_name(pdev));
109 rc = zpci_reset_load_store_blocked(zdev);
110 if (rc) {
111 pr_err("%s: Unblocking device access failed\n", pci_name(pdev));
112 /* Let's try a full reset instead */
113 return PCI_ERS_RESULT_NEED_RESET;
114 }
115
116 if (driver->err_handler->mmio_enabled) {
117 ers_res = driver->err_handler->mmio_enabled(pdev);
118 if (ers_result_indicates_abort(ers_res)) {
119 pr_info("%s: Automatic recovery failed after MMIO re-enable\n",
120 pci_name(pdev));
121 return ers_res;
122 } else if (ers_res == PCI_ERS_RESULT_NEED_RESET) {
123 pr_debug("%s: Driver needs reset to recover\n", pci_name(pdev));
124 return ers_res;
125 }
126 }
127
128 pr_debug("%s: Unblocking DMA\n", pci_name(pdev));
129 rc = zpci_clear_error_state(zdev);
130 if (!rc) {
131 pdev->error_state = pci_channel_io_normal;
132 } else {
133 pr_err("%s: Unblocking DMA failed\n", pci_name(pdev));
134 /* Let's try a full reset instead */
135 return PCI_ERS_RESULT_NEED_RESET;
136 }
137
138 return ers_res;
139}
140
141static pci_ers_result_t zpci_event_do_reset(struct pci_dev *pdev,
142 struct pci_driver *driver)
143{
144 pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
145
146 pr_info("%s: Initiating reset\n", pci_name(pdev));
147 if (zpci_hot_reset_device(to_zpci(pdev))) {
148 pr_err("%s: The reset request failed\n", pci_name(pdev));
149 return ers_res;
150 }
151 pdev->error_state = pci_channel_io_normal;
152 ers_res = driver->err_handler->slot_reset(pdev);
153 if (ers_result_indicates_abort(ers_res)) {
154 pr_info("%s: Automatic recovery failed after slot reset\n", pci_name(pdev));
155 return ers_res;
156 }
157
158 return ers_res;
159}
160
161/* zpci_event_attempt_error_recovery - Try to recover the given PCI function
162 * @pdev: PCI function to recover currently in the error state
163 *
164 * We follow the scheme outlined in Documentation/PCI/pci-error-recovery.rst.
165 * With the simplification that recovery always happens per function
166 * and the platform determines which functions are affected for
167 * multi-function devices.
168 */
169static pci_ers_result_t zpci_event_attempt_error_recovery(struct pci_dev *pdev)
170{
171 pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
172 struct pci_driver *driver;
173
174 /*
175 * Ensure that the PCI function is not removed concurrently, no driver
176 * is unbound or probed and that userspace can't access its
177 * configuration space while we perform recovery.
178 */
179 pci_dev_lock(pdev);
180 if (pdev->error_state == pci_channel_io_perm_failure) {
181 ers_res = PCI_ERS_RESULT_DISCONNECT;
182 goto out_unlock;
183 }
184 pdev->error_state = pci_channel_io_frozen;
185
186 if (is_passed_through(pdev)) {
187 pr_info("%s: Cannot be recovered in the host because it is a pass-through device\n",
188 pci_name(pdev));
189 goto out_unlock;
190 }
191
192 driver = to_pci_driver(pdev->dev.driver);
193 if (!is_driver_supported(driver)) {
194 if (!driver)
195 pr_info("%s: Cannot be recovered because no driver is bound to the device\n",
196 pci_name(pdev));
197 else
198 pr_info("%s: The %s driver bound to the device does not support error recovery\n",
199 pci_name(pdev),
200 driver->name);
201 goto out_unlock;
202 }
203
204 ers_res = zpci_event_notify_error_detected(pdev, driver);
205 if (ers_result_indicates_abort(ers_res))
206 goto out_unlock;
207
208 if (ers_res == PCI_ERS_RESULT_CAN_RECOVER) {
209 ers_res = zpci_event_do_error_state_clear(pdev, driver);
210 if (ers_result_indicates_abort(ers_res))
211 goto out_unlock;
212 }
213
214 if (ers_res == PCI_ERS_RESULT_NEED_RESET)
215 ers_res = zpci_event_do_reset(pdev, driver);
216
217 if (ers_res != PCI_ERS_RESULT_RECOVERED) {
218 pr_err("%s: Automatic recovery failed; operator intervention is required\n",
219 pci_name(pdev));
220 goto out_unlock;
221 }
222
223 pr_info("%s: The device is ready to resume operations\n", pci_name(pdev));
224 if (driver->err_handler->resume)
225 driver->err_handler->resume(pdev);
226out_unlock:
227 pci_dev_unlock(pdev);
228
229 return ers_res;
230}
231
232/* zpci_event_io_failure - Report PCI channel failure state to driver
233 * @pdev: PCI function for which to report
234 * @es: PCI channel failure state to report
235 */
236static void zpci_event_io_failure(struct pci_dev *pdev, pci_channel_state_t es)
237{
238 struct pci_driver *driver;
239
240 pci_dev_lock(pdev);
241 pdev->error_state = es;
242 /**
243 * While vfio-pci's error_detected callback notifies user-space QEMU
244 * reacts to this by freezing the guest. In an s390 environment PCI
245 * errors are rarely fatal so this is overkill. Instead in the future
246 * we will inject the error event and let the guest recover the device
247 * itself.
248 */
249 if (is_passed_through(pdev))
250 goto out;
251 driver = to_pci_driver(pdev->dev.driver);
252 if (driver && driver->err_handler && driver->err_handler->error_detected)
253 driver->err_handler->error_detected(pdev, pdev->error_state);
254out:
255 pci_dev_unlock(pdev);
256}
257
258static void __zpci_event_error(struct zpci_ccdf_err *ccdf)
259{
260 struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
261 struct pci_dev *pdev = NULL;
262 pci_ers_result_t ers_res;
263
264 zpci_dbg(3, "err fid:%x, fh:%x, pec:%x\n",
265 ccdf->fid, ccdf->fh, ccdf->pec);
266 zpci_err("error CCDF:\n");
267 zpci_err_hex(ccdf, sizeof(*ccdf));
268
269 if (zdev) {
270 mutex_lock(&zdev->state_lock);
271 zpci_update_fh(zdev, ccdf->fh);
272 if (zdev->zbus->bus)
273 pdev = pci_get_slot(zdev->zbus->bus, zdev->devfn);
274 }
275
276 pr_err("%s: Event 0x%x reports an error for PCI function 0x%x\n",
277 pdev ? pci_name(pdev) : "n/a", ccdf->pec, ccdf->fid);
278
279 if (!pdev)
280 goto no_pdev;
281
282 switch (ccdf->pec) {
283 case 0x002a: /* Error event concerns FMB */
284 case 0x002b:
285 case 0x002c:
286 break;
287 case 0x0040: /* Service Action or Error Recovery Failed */
288 case 0x003b:
289 zpci_event_io_failure(pdev, pci_channel_io_perm_failure);
290 break;
291 default: /* PCI function left in the error state attempt to recover */
292 ers_res = zpci_event_attempt_error_recovery(pdev);
293 if (ers_res != PCI_ERS_RESULT_RECOVERED)
294 zpci_event_io_failure(pdev, pci_channel_io_perm_failure);
295 break;
296 }
297 pci_dev_put(pdev);
298no_pdev:
299 if (zdev)
300 mutex_unlock(&zdev->state_lock);
301 zpci_zdev_put(zdev);
302}
303
304void zpci_event_error(void *data)
305{
306 if (zpci_is_enabled())
307 __zpci_event_error(data);
308}
309
310static void zpci_event_hard_deconfigured(struct zpci_dev *zdev, u32 fh)
311{
312 zpci_update_fh(zdev, fh);
313 /* Give the driver a hint that the function is
314 * already unusable.
315 */
316 zpci_bus_remove_device(zdev, true);
317 /* Even though the device is already gone we still
318 * need to free zPCI resources as part of the disable.
319 */
320 if (zdev_enabled(zdev))
321 zpci_disable_device(zdev);
322 zdev->state = ZPCI_FN_STATE_STANDBY;
323}
324
325static void __zpci_event_availability(struct zpci_ccdf_avail *ccdf)
326{
327 struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
328 bool existing_zdev = !!zdev;
329 enum zpci_state state;
330
331 zpci_dbg(3, "avl fid:%x, fh:%x, pec:%x\n",
332 ccdf->fid, ccdf->fh, ccdf->pec);
333
334 if (existing_zdev)
335 mutex_lock(&zdev->state_lock);
336
337 switch (ccdf->pec) {
338 case 0x0301: /* Reserved|Standby -> Configured */
339 if (!zdev) {
340 zdev = zpci_create_device(ccdf->fid, ccdf->fh, ZPCI_FN_STATE_CONFIGURED);
341 if (IS_ERR(zdev))
342 break;
343 if (zpci_add_device(zdev)) {
344 kfree(zdev);
345 break;
346 }
347 } else {
348 /* the configuration request may be stale */
349 if (zdev->state != ZPCI_FN_STATE_STANDBY)
350 break;
351 zdev->state = ZPCI_FN_STATE_CONFIGURED;
352 }
353 zpci_scan_configured_device(zdev, ccdf->fh);
354 break;
355 case 0x0302: /* Reserved -> Standby */
356 if (!zdev) {
357 zdev = zpci_create_device(ccdf->fid, ccdf->fh, ZPCI_FN_STATE_STANDBY);
358 if (IS_ERR(zdev))
359 break;
360 if (zpci_add_device(zdev)) {
361 kfree(zdev);
362 break;
363 }
364 } else {
365 zpci_update_fh(zdev, ccdf->fh);
366 }
367 break;
368 case 0x0303: /* Deconfiguration requested */
369 if (zdev) {
370 /* The event may have been queued before we configured
371 * the device.
372 */
373 if (zdev->state != ZPCI_FN_STATE_CONFIGURED)
374 break;
375 zpci_update_fh(zdev, ccdf->fh);
376 zpci_deconfigure_device(zdev);
377 }
378 break;
379 case 0x0304: /* Configured -> Standby|Reserved */
380 if (zdev) {
381 /* The event may have been queued before we configured
382 * the device.:
383 */
384 if (zdev->state == ZPCI_FN_STATE_CONFIGURED)
385 zpci_event_hard_deconfigured(zdev, ccdf->fh);
386 /* The 0x0304 event may immediately reserve the device */
387 if (!clp_get_state(zdev->fid, &state) &&
388 state == ZPCI_FN_STATE_RESERVED) {
389 zpci_device_reserved(zdev);
390 }
391 }
392 break;
393 case 0x0306: /* 0x308 or 0x302 for multiple devices */
394 zpci_remove_reserved_devices();
395 zpci_scan_devices();
396 break;
397 case 0x0308: /* Standby -> Reserved */
398 if (!zdev)
399 break;
400 zpci_device_reserved(zdev);
401 break;
402 default:
403 break;
404 }
405 if (existing_zdev) {
406 mutex_unlock(&zdev->state_lock);
407 zpci_zdev_put(zdev);
408 }
409}
410
411void zpci_event_availability(void *data)
412{
413 if (zpci_is_enabled())
414 __zpci_event_availability(data);
415}
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright IBM Corp. 2012
4 *
5 * Author(s):
6 * Jan Glauber <jang@linux.vnet.ibm.com>
7 */
8
9#define KMSG_COMPONENT "zpci"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
12#include <linux/kernel.h>
13#include <linux/pci.h>
14#include <asm/pci_debug.h>
15#include <asm/pci_dma.h>
16#include <asm/sclp.h>
17
18#include "pci_bus.h"
19
20/* Content Code Description for PCI Function Error */
21struct zpci_ccdf_err {
22 u32 reserved1;
23 u32 fh; /* function handle */
24 u32 fid; /* function id */
25 u32 ett : 4; /* expected table type */
26 u32 mvn : 12; /* MSI vector number */
27 u32 dmaas : 8; /* DMA address space */
28 u32 : 6;
29 u32 q : 1; /* event qualifier */
30 u32 rw : 1; /* read/write */
31 u64 faddr; /* failing address */
32 u32 reserved3;
33 u16 reserved4;
34 u16 pec; /* PCI event code */
35} __packed;
36
37/* Content Code Description for PCI Function Availability */
38struct zpci_ccdf_avail {
39 u32 reserved1;
40 u32 fh; /* function handle */
41 u32 fid; /* function id */
42 u32 reserved2;
43 u32 reserved3;
44 u32 reserved4;
45 u32 reserved5;
46 u16 reserved6;
47 u16 pec; /* PCI event code */
48} __packed;
49
50static void __zpci_event_error(struct zpci_ccdf_err *ccdf)
51{
52 struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
53 struct pci_dev *pdev = NULL;
54
55 zpci_err("error CCDF:\n");
56 zpci_err_hex(ccdf, sizeof(*ccdf));
57
58 if (zdev)
59 pdev = pci_get_slot(zdev->zbus->bus, zdev->devfn);
60
61 pr_err("%s: Event 0x%x reports an error for PCI function 0x%x\n",
62 pdev ? pci_name(pdev) : "n/a", ccdf->pec, ccdf->fid);
63
64 if (!pdev)
65 return;
66
67 pdev->error_state = pci_channel_io_perm_failure;
68 pci_dev_put(pdev);
69}
70
71void zpci_event_error(void *data)
72{
73 if (zpci_is_enabled())
74 __zpci_event_error(data);
75}
76
77static void zpci_event_hard_deconfigured(struct zpci_dev *zdev, u32 fh)
78{
79 zdev->fh = fh;
80 /* Give the driver a hint that the function is
81 * already unusable.
82 */
83 zpci_bus_remove_device(zdev, true);
84 /* Even though the device is already gone we still
85 * need to free zPCI resources as part of the disable.
86 */
87 zpci_disable_device(zdev);
88 zdev->state = ZPCI_FN_STATE_STANDBY;
89}
90
91static void __zpci_event_availability(struct zpci_ccdf_avail *ccdf)
92{
93 struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
94 enum zpci_state state;
95
96 zpci_err("avail CCDF:\n");
97 zpci_err_hex(ccdf, sizeof(*ccdf));
98
99 switch (ccdf->pec) {
100 case 0x0301: /* Reserved|Standby -> Configured */
101 if (!zdev) {
102 zdev = zpci_create_device(ccdf->fid, ccdf->fh, ZPCI_FN_STATE_CONFIGURED);
103 if (IS_ERR(zdev))
104 break;
105 } else {
106 /* the configuration request may be stale */
107 if (zdev->state != ZPCI_FN_STATE_STANDBY)
108 break;
109 zdev->state = ZPCI_FN_STATE_CONFIGURED;
110 }
111 zpci_scan_configured_device(zdev, ccdf->fh);
112 break;
113 case 0x0302: /* Reserved -> Standby */
114 if (!zdev)
115 zpci_create_device(ccdf->fid, ccdf->fh, ZPCI_FN_STATE_STANDBY);
116 else
117 zdev->fh = ccdf->fh;
118 break;
119 case 0x0303: /* Deconfiguration requested */
120 if (zdev) {
121 /* The event may have been queued before we confirgured
122 * the device.
123 */
124 if (zdev->state != ZPCI_FN_STATE_CONFIGURED)
125 break;
126 zdev->fh = ccdf->fh;
127 zpci_deconfigure_device(zdev);
128 }
129 break;
130 case 0x0304: /* Configured -> Standby|Reserved */
131 if (zdev) {
132 /* The event may have been queued before we confirgured
133 * the device.:
134 */
135 if (zdev->state == ZPCI_FN_STATE_CONFIGURED)
136 zpci_event_hard_deconfigured(zdev, ccdf->fh);
137 /* The 0x0304 event may immediately reserve the device */
138 if (!clp_get_state(zdev->fid, &state) &&
139 state == ZPCI_FN_STATE_RESERVED) {
140 zpci_device_reserved(zdev);
141 }
142 }
143 break;
144 case 0x0306: /* 0x308 or 0x302 for multiple devices */
145 zpci_remove_reserved_devices();
146 clp_scan_pci_devices();
147 break;
148 case 0x0308: /* Standby -> Reserved */
149 if (!zdev)
150 break;
151 zpci_device_reserved(zdev);
152 break;
153 default:
154 break;
155 }
156}
157
158void zpci_event_availability(void *data)
159{
160 if (zpci_is_enabled())
161 __zpci_event_availability(data);
162}