Linux Audio

Check our new training course

Yocto / OpenEmbedded training

Mar 24-27, 2025, special US time zones
Register
Loading...
v6.9.4
  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 0x003a: /* Service Action or Error Recovery Successful */
284		ers_res = zpci_event_attempt_error_recovery(pdev);
285		if (ers_res != PCI_ERS_RESULT_RECOVERED)
286			zpci_event_io_failure(pdev, pci_channel_io_perm_failure);
287		break;
288	default:
289		/*
290		 * Mark as frozen not permanently failed because the device
291		 * could be subsequently recovered by the platform.
292		 */
293		zpci_event_io_failure(pdev, pci_channel_io_frozen);
294		break;
295	}
296	pci_dev_put(pdev);
297no_pdev:
298	if (zdev)
299		mutex_unlock(&zdev->state_lock);
300	zpci_zdev_put(zdev);
301}
302
303void zpci_event_error(void *data)
304{
305	if (zpci_is_enabled())
306		__zpci_event_error(data);
307}
308
309static void zpci_event_hard_deconfigured(struct zpci_dev *zdev, u32 fh)
310{
311	zpci_update_fh(zdev, fh);
312	/* Give the driver a hint that the function is
313	 * already unusable.
314	 */
315	zpci_bus_remove_device(zdev, true);
316	/* Even though the device is already gone we still
317	 * need to free zPCI resources as part of the disable.
318	 */
 
 
319	if (zdev_enabled(zdev))
320		zpci_disable_device(zdev);
321	zdev->state = ZPCI_FN_STATE_STANDBY;
322}
323
324static void __zpci_event_availability(struct zpci_ccdf_avail *ccdf)
325{
326	struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
327	bool existing_zdev = !!zdev;
328	enum zpci_state state;
329
330	zpci_dbg(3, "avl fid:%x, fh:%x, pec:%x\n",
331		 ccdf->fid, ccdf->fh, ccdf->pec);
332
333	if (existing_zdev)
334		mutex_lock(&zdev->state_lock);
335
336	switch (ccdf->pec) {
337	case 0x0301: /* Reserved|Standby -> Configured */
338		if (!zdev) {
339			zdev = zpci_create_device(ccdf->fid, ccdf->fh, ZPCI_FN_STATE_CONFIGURED);
340			if (IS_ERR(zdev))
341				break;
342		} else {
343			/* the configuration request may be stale */
344			if (zdev->state != ZPCI_FN_STATE_STANDBY)
345				break;
346			zdev->state = ZPCI_FN_STATE_CONFIGURED;
347		}
348		zpci_scan_configured_device(zdev, ccdf->fh);
349		break;
350	case 0x0302: /* Reserved -> Standby */
351		if (!zdev)
352			zpci_create_device(ccdf->fid, ccdf->fh, ZPCI_FN_STATE_STANDBY);
353		else
354			zpci_update_fh(zdev, ccdf->fh);
355		break;
356	case 0x0303: /* Deconfiguration requested */
357		if (zdev) {
358			/* The event may have been queued before we configured
359			 * the device.
360			 */
361			if (zdev->state != ZPCI_FN_STATE_CONFIGURED)
362				break;
363			zpci_update_fh(zdev, ccdf->fh);
364			zpci_deconfigure_device(zdev);
365		}
366		break;
367	case 0x0304: /* Configured -> Standby|Reserved */
368		if (zdev) {
369			/* The event may have been queued before we configured
370			 * the device.:
371			 */
372			if (zdev->state == ZPCI_FN_STATE_CONFIGURED)
373				zpci_event_hard_deconfigured(zdev, ccdf->fh);
374			/* The 0x0304 event may immediately reserve the device */
375			if (!clp_get_state(zdev->fid, &state) &&
376			    state == ZPCI_FN_STATE_RESERVED) {
377				zpci_device_reserved(zdev);
378			}
379		}
380		break;
381	case 0x0306: /* 0x308 or 0x302 for multiple devices */
382		zpci_remove_reserved_devices();
383		clp_scan_pci_devices();
384		break;
385	case 0x0308: /* Standby -> Reserved */
386		if (!zdev)
387			break;
388		zpci_device_reserved(zdev);
389		break;
390	default:
391		break;
392	}
393	if (existing_zdev) {
394		mutex_unlock(&zdev->state_lock);
395		zpci_zdev_put(zdev);
396	}
397}
398
399void zpci_event_availability(void *data)
400{
401	if (zpci_is_enabled())
402		__zpci_event_availability(data);
403}
v6.2
  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 zpci_dev *zdev)
 63{
 64	return zdev->s390_domain;
 
 
 
 
 
 
 
 65}
 66
 67static bool is_driver_supported(struct pci_driver *driver)
 68{
 69	if (!driver || !driver->err_handler)
 70		return false;
 71	if (!driver->err_handler->error_detected)
 72		return false;
 73	if (!driver->err_handler->slot_reset)
 74		return false;
 75	if (!driver->err_handler->resume)
 76		return false;
 77	return true;
 78}
 79
 80static pci_ers_result_t zpci_event_notify_error_detected(struct pci_dev *pdev,
 81							 struct pci_driver *driver)
 82{
 83	pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
 84
 85	ers_res = driver->err_handler->error_detected(pdev,  pdev->error_state);
 86	if (ers_result_indicates_abort(ers_res))
 87		pr_info("%s: Automatic recovery failed after initial reporting\n", pci_name(pdev));
 88	else if (ers_res == PCI_ERS_RESULT_NEED_RESET)
 89		pr_debug("%s: Driver needs reset to recover\n", pci_name(pdev));
 90
 91	return ers_res;
 92}
 93
 94static pci_ers_result_t zpci_event_do_error_state_clear(struct pci_dev *pdev,
 95							struct pci_driver *driver)
 96{
 97	pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
 98	struct zpci_dev *zdev = to_zpci(pdev);
 99	int rc;
100
101	pr_info("%s: Unblocking device access for examination\n", pci_name(pdev));
102	rc = zpci_reset_load_store_blocked(zdev);
103	if (rc) {
104		pr_err("%s: Unblocking device access failed\n", pci_name(pdev));
105		/* Let's try a full reset instead */
106		return PCI_ERS_RESULT_NEED_RESET;
107	}
108
109	if (driver->err_handler->mmio_enabled) {
110		ers_res = driver->err_handler->mmio_enabled(pdev);
111		if (ers_result_indicates_abort(ers_res)) {
112			pr_info("%s: Automatic recovery failed after MMIO re-enable\n",
113				pci_name(pdev));
114			return ers_res;
115		} else if (ers_res == PCI_ERS_RESULT_NEED_RESET) {
116			pr_debug("%s: Driver needs reset to recover\n", pci_name(pdev));
117			return ers_res;
118		}
119	}
120
121	pr_debug("%s: Unblocking DMA\n", pci_name(pdev));
122	rc = zpci_clear_error_state(zdev);
123	if (!rc) {
124		pdev->error_state = pci_channel_io_normal;
125	} else {
126		pr_err("%s: Unblocking DMA failed\n", pci_name(pdev));
127		/* Let's try a full reset instead */
128		return PCI_ERS_RESULT_NEED_RESET;
129	}
130
131	return ers_res;
132}
133
134static pci_ers_result_t zpci_event_do_reset(struct pci_dev *pdev,
135					    struct pci_driver *driver)
136{
137	pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
138
139	pr_info("%s: Initiating reset\n", pci_name(pdev));
140	if (zpci_hot_reset_device(to_zpci(pdev))) {
141		pr_err("%s: The reset request failed\n", pci_name(pdev));
142		return ers_res;
143	}
144	pdev->error_state = pci_channel_io_normal;
145	ers_res = driver->err_handler->slot_reset(pdev);
146	if (ers_result_indicates_abort(ers_res)) {
147		pr_info("%s: Automatic recovery failed after slot reset\n", pci_name(pdev));
148		return ers_res;
149	}
150
151	return ers_res;
152}
153
154/* zpci_event_attempt_error_recovery - Try to recover the given PCI function
155 * @pdev: PCI function to recover currently in the error state
156 *
157 * We follow the scheme outlined in Documentation/PCI/pci-error-recovery.rst.
158 * With the simplification that recovery always happens per function
159 * and the platform determines which functions are affected for
160 * multi-function devices.
161 */
162static pci_ers_result_t zpci_event_attempt_error_recovery(struct pci_dev *pdev)
163{
164	pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
165	struct pci_driver *driver;
166
167	/*
168	 * Ensure that the PCI function is not removed concurrently, no driver
169	 * is unbound or probed and that userspace can't access its
170	 * configuration space while we perform recovery.
171	 */
172	pci_dev_lock(pdev);
173	if (pdev->error_state == pci_channel_io_perm_failure) {
174		ers_res = PCI_ERS_RESULT_DISCONNECT;
175		goto out_unlock;
176	}
177	pdev->error_state = pci_channel_io_frozen;
178
179	if (is_passed_through(to_zpci(pdev))) {
180		pr_info("%s: Cannot be recovered in the host because it is a pass-through device\n",
181			pci_name(pdev));
182		goto out_unlock;
183	}
184
185	driver = to_pci_driver(pdev->dev.driver);
186	if (!is_driver_supported(driver)) {
187		if (!driver)
188			pr_info("%s: Cannot be recovered because no driver is bound to the device\n",
189				pci_name(pdev));
190		else
191			pr_info("%s: The %s driver bound to the device does not support error recovery\n",
192				pci_name(pdev),
193				driver->name);
194		goto out_unlock;
195	}
196
197	ers_res = zpci_event_notify_error_detected(pdev, driver);
198	if (ers_result_indicates_abort(ers_res))
199		goto out_unlock;
200
201	if (ers_res == PCI_ERS_RESULT_CAN_RECOVER) {
202		ers_res = zpci_event_do_error_state_clear(pdev, driver);
203		if (ers_result_indicates_abort(ers_res))
204			goto out_unlock;
205	}
206
207	if (ers_res == PCI_ERS_RESULT_NEED_RESET)
208		ers_res = zpci_event_do_reset(pdev, driver);
209
210	if (ers_res != PCI_ERS_RESULT_RECOVERED) {
211		pr_err("%s: Automatic recovery failed; operator intervention is required\n",
212		       pci_name(pdev));
213		goto out_unlock;
214	}
215
216	pr_info("%s: The device is ready to resume operations\n", pci_name(pdev));
217	if (driver->err_handler->resume)
218		driver->err_handler->resume(pdev);
219out_unlock:
220	pci_dev_unlock(pdev);
221
222	return ers_res;
223}
224
225/* zpci_event_io_failure - Report PCI channel failure state to driver
226 * @pdev: PCI function for which to report
227 * @es: PCI channel failure state to report
228 */
229static void zpci_event_io_failure(struct pci_dev *pdev, pci_channel_state_t es)
230{
231	struct pci_driver *driver;
232
233	pci_dev_lock(pdev);
234	pdev->error_state = es;
235	/**
236	 * While vfio-pci's error_detected callback notifies user-space QEMU
237	 * reacts to this by freezing the guest. In an s390 environment PCI
238	 * errors are rarely fatal so this is overkill. Instead in the future
239	 * we will inject the error event and let the guest recover the device
240	 * itself.
241	 */
242	if (is_passed_through(to_zpci(pdev)))
243		goto out;
244	driver = to_pci_driver(pdev->dev.driver);
245	if (driver && driver->err_handler && driver->err_handler->error_detected)
246		driver->err_handler->error_detected(pdev, pdev->error_state);
247out:
248	pci_dev_unlock(pdev);
249}
250
251static void __zpci_event_error(struct zpci_ccdf_err *ccdf)
252{
253	struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
254	struct pci_dev *pdev = NULL;
255	pci_ers_result_t ers_res;
256
257	zpci_dbg(3, "err fid:%x, fh:%x, pec:%x\n",
258		 ccdf->fid, ccdf->fh, ccdf->pec);
259	zpci_err("error CCDF:\n");
260	zpci_err_hex(ccdf, sizeof(*ccdf));
261
262	if (zdev) {
 
263		zpci_update_fh(zdev, ccdf->fh);
264		if (zdev->zbus->bus)
265			pdev = pci_get_slot(zdev->zbus->bus, zdev->devfn);
266	}
267
268	pr_err("%s: Event 0x%x reports an error for PCI function 0x%x\n",
269	       pdev ? pci_name(pdev) : "n/a", ccdf->pec, ccdf->fid);
270
271	if (!pdev)
272		goto no_pdev;
273
274	switch (ccdf->pec) {
275	case 0x003a: /* Service Action or Error Recovery Successful */
276		ers_res = zpci_event_attempt_error_recovery(pdev);
277		if (ers_res != PCI_ERS_RESULT_RECOVERED)
278			zpci_event_io_failure(pdev, pci_channel_io_perm_failure);
279		break;
280	default:
281		/*
282		 * Mark as frozen not permanently failed because the device
283		 * could be subsequently recovered by the platform.
284		 */
285		zpci_event_io_failure(pdev, pci_channel_io_frozen);
286		break;
287	}
288	pci_dev_put(pdev);
289no_pdev:
 
 
290	zpci_zdev_put(zdev);
291}
292
293void zpci_event_error(void *data)
294{
295	if (zpci_is_enabled())
296		__zpci_event_error(data);
297}
298
299static void zpci_event_hard_deconfigured(struct zpci_dev *zdev, u32 fh)
300{
301	zpci_update_fh(zdev, fh);
302	/* Give the driver a hint that the function is
303	 * already unusable.
304	 */
305	zpci_bus_remove_device(zdev, true);
306	/* Even though the device is already gone we still
307	 * need to free zPCI resources as part of the disable.
308	 */
309	if (zdev->dma_table)
310		zpci_dma_exit_device(zdev);
311	if (zdev_enabled(zdev))
312		zpci_disable_device(zdev);
313	zdev->state = ZPCI_FN_STATE_STANDBY;
314}
315
316static void __zpci_event_availability(struct zpci_ccdf_avail *ccdf)
317{
318	struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
319	bool existing_zdev = !!zdev;
320	enum zpci_state state;
321
322	zpci_dbg(3, "avl fid:%x, fh:%x, pec:%x\n",
323		 ccdf->fid, ccdf->fh, ccdf->pec);
 
 
 
 
324	switch (ccdf->pec) {
325	case 0x0301: /* Reserved|Standby -> Configured */
326		if (!zdev) {
327			zdev = zpci_create_device(ccdf->fid, ccdf->fh, ZPCI_FN_STATE_CONFIGURED);
328			if (IS_ERR(zdev))
329				break;
330		} else {
331			/* the configuration request may be stale */
332			if (zdev->state != ZPCI_FN_STATE_STANDBY)
333				break;
334			zdev->state = ZPCI_FN_STATE_CONFIGURED;
335		}
336		zpci_scan_configured_device(zdev, ccdf->fh);
337		break;
338	case 0x0302: /* Reserved -> Standby */
339		if (!zdev)
340			zpci_create_device(ccdf->fid, ccdf->fh, ZPCI_FN_STATE_STANDBY);
341		else
342			zpci_update_fh(zdev, ccdf->fh);
343		break;
344	case 0x0303: /* Deconfiguration requested */
345		if (zdev) {
346			/* The event may have been queued before we confirgured
347			 * the device.
348			 */
349			if (zdev->state != ZPCI_FN_STATE_CONFIGURED)
350				break;
351			zpci_update_fh(zdev, ccdf->fh);
352			zpci_deconfigure_device(zdev);
353		}
354		break;
355	case 0x0304: /* Configured -> Standby|Reserved */
356		if (zdev) {
357			/* The event may have been queued before we confirgured
358			 * the device.:
359			 */
360			if (zdev->state == ZPCI_FN_STATE_CONFIGURED)
361				zpci_event_hard_deconfigured(zdev, ccdf->fh);
362			/* The 0x0304 event may immediately reserve the device */
363			if (!clp_get_state(zdev->fid, &state) &&
364			    state == ZPCI_FN_STATE_RESERVED) {
365				zpci_device_reserved(zdev);
366			}
367		}
368		break;
369	case 0x0306: /* 0x308 or 0x302 for multiple devices */
370		zpci_remove_reserved_devices();
371		clp_scan_pci_devices();
372		break;
373	case 0x0308: /* Standby -> Reserved */
374		if (!zdev)
375			break;
376		zpci_device_reserved(zdev);
377		break;
378	default:
379		break;
380	}
381	if (existing_zdev)
 
382		zpci_zdev_put(zdev);
 
383}
384
385void zpci_event_availability(void *data)
386{
387	if (zpci_is_enabled())
388		__zpci_event_availability(data);
389}