blob: bb61ca58ca6d8272955d7023852f97cbe180c676 [file] [log] [blame]
Linas Vepstas77bd7412005-11-03 18:52:49 -06001/*
2 * PCI Error Recovery Driver for RPA-compliant PPC64 platform.
Linas Vepstas3c8c90a2007-05-24 03:28:01 +10003 * Copyright IBM Corp. 2004 2005
4 * Copyright Linas Vepstas <linas@linas.org> 2004, 2005
Linas Vepstas77bd7412005-11-03 18:52:49 -06005 *
6 * All rights reserved.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or (at
11 * your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
16 * NON INFRINGEMENT. See the GNU General Public License for more
17 * details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
Linas Vepstas3c8c90a2007-05-24 03:28:01 +100023 * Send comments and feedback to Linas Vepstas <linas@austin.ibm.com>
Linas Vepstas77bd7412005-11-03 18:52:49 -060024 */
25#include <linux/delay.h>
Linas Vepstas77bd7412005-11-03 18:52:49 -060026#include <linux/interrupt.h>
Linas Vepstasac325ac2006-04-18 21:05:21 -070027#include <linux/irq.h>
Gavin Shanfeadf7c2012-09-17 04:34:27 +000028#include <linux/module.h>
Linas Vepstas77bd7412005-11-03 18:52:49 -060029#include <linux/pci.h>
30#include <asm/eeh.h>
31#include <asm/eeh_event.h>
32#include <asm/ppc-pci.h>
33#include <asm/pci-bridge.h>
34#include <asm/prom.h>
35#include <asm/rtas.h>
36
Gavin Shan29f8bf12012-02-27 20:04:02 +000037/**
38 * eeh_pcid_name - Retrieve name of PCI device driver
39 * @pdev: PCI device
40 *
41 * This routine is used to retrieve the name of PCI device driver
42 * if that's valid.
43 */
Gavin Shan40a7cd92012-02-27 20:04:08 +000044static inline const char *eeh_pcid_name(struct pci_dev *pdev)
Linas Vepstas77bd7412005-11-03 18:52:49 -060045{
Olaf Hering273d2802006-02-27 15:52:59 +010046 if (pdev && pdev->dev.driver)
Linas Vepstas77bd7412005-11-03 18:52:49 -060047 return pdev->dev.driver->name;
48 return "";
49}
50
Gavin Shanfeadf7c2012-09-17 04:34:27 +000051/**
52 * eeh_pcid_get - Get the PCI device driver
53 * @pdev: PCI device
54 *
55 * The function is used to retrieve the PCI device driver for
56 * the indicated PCI device. Besides, we will increase the reference
57 * of the PCI device driver to prevent that being unloaded on
58 * the fly. Otherwise, kernel crash would be seen.
59 */
60static inline struct pci_driver *eeh_pcid_get(struct pci_dev *pdev)
61{
62 if (!pdev || !pdev->driver)
63 return NULL;
64
65 if (!try_module_get(pdev->driver->driver.owner))
66 return NULL;
67
68 return pdev->driver;
69}
70
71/**
72 * eeh_pcid_put - Dereference on the PCI device driver
73 * @pdev: PCI device
74 *
75 * The function is called to do dereference on the PCI device
76 * driver of the indicated PCI device.
77 */
78static inline void eeh_pcid_put(struct pci_dev *pdev)
79{
80 if (!pdev || !pdev->driver)
81 return;
82
83 module_put(pdev->driver->driver.owner);
84}
85
Tony Breedsdcfcfe72008-07-31 16:54:20 +100086#if 0
Andrew Morton8e015202008-06-10 09:26:10 +100087static void print_device_node_tree(struct pci_dn *pdn, int dent)
Linas Vepstas77bd7412005-11-03 18:52:49 -060088{
89 int i;
Andrew Morton8e015202008-06-10 09:26:10 +100090 struct device_node *pc;
91
92 if (!pdn)
93 return;
94 for (i = 0; i < dent; i++)
Linas Vepstas77bd7412005-11-03 18:52:49 -060095 printk(" ");
96 printk("dn=%s mode=%x \tcfg_addr=%x pe_addr=%x \tfull=%s\n",
97 pdn->node->name, pdn->eeh_mode, pdn->eeh_config_addr,
98 pdn->eeh_pe_config_addr, pdn->node->full_name);
99 dent += 3;
Andrew Morton8e015202008-06-10 09:26:10 +1000100 pc = pdn->node->child;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600101 while (pc) {
102 print_device_node_tree(PCI_DN(pc), dent);
103 pc = pc->sibling;
104 }
105}
106#endif
107
Mike Mason8535ef02009-02-10 11:12:21 +0000108/**
Gavin Shan29f8bf12012-02-27 20:04:02 +0000109 * eeh_disable_irq - Disable interrupt for the recovering device
110 * @dev: PCI device
111 *
112 * This routine must be called when reporting temporary or permanent
113 * error to the particular PCI device to disable interrupt of that
114 * device. If the device has enabled MSI or MSI-X interrupt, we needn't
115 * do real work because EEH should freeze DMA transfers for those PCI
116 * devices encountering EEH errors, which includes MSI or MSI-X.
Mike Mason8535ef02009-02-10 11:12:21 +0000117 */
118static void eeh_disable_irq(struct pci_dev *dev)
119{
Gavin Shan40a7cd92012-02-27 20:04:08 +0000120 struct eeh_dev *edev = pci_dev_to_eeh_dev(dev);
Mike Mason8535ef02009-02-10 11:12:21 +0000121
122 /* Don't disable MSI and MSI-X interrupts. They are
123 * effectively disabled by the DMA Stopped state
124 * when an EEH error occurs.
Gavin Shan29f8bf12012-02-27 20:04:02 +0000125 */
Mike Mason8535ef02009-02-10 11:12:21 +0000126 if (dev->msi_enabled || dev->msix_enabled)
127 return;
128
Michael Ellerman59e3f832009-10-13 19:44:47 +0000129 if (!irq_has_action(dev->irq))
Mike Mason8535ef02009-02-10 11:12:21 +0000130 return;
131
Gavin Shandbbceee2012-09-07 22:44:20 +0000132 edev->mode |= EEH_DEV_IRQ_DISABLED;
Mike Mason8535ef02009-02-10 11:12:21 +0000133 disable_irq_nosync(dev->irq);
134}
135
136/**
Gavin Shan29f8bf12012-02-27 20:04:02 +0000137 * eeh_enable_irq - Enable interrupt for the recovering device
138 * @dev: PCI device
139 *
140 * This routine must be called to enable interrupt while failed
141 * device could be resumed.
Mike Mason8535ef02009-02-10 11:12:21 +0000142 */
143static void eeh_enable_irq(struct pci_dev *dev)
144{
Gavin Shan40a7cd92012-02-27 20:04:08 +0000145 struct eeh_dev *edev = pci_dev_to_eeh_dev(dev);
Mike Mason8535ef02009-02-10 11:12:21 +0000146
Gavin Shandbbceee2012-09-07 22:44:20 +0000147 if ((edev->mode) & EEH_DEV_IRQ_DISABLED) {
148 edev->mode &= ~EEH_DEV_IRQ_DISABLED;
Thomas Gleixnerb8a9a112014-02-23 21:40:09 +0000149 /*
150 * FIXME !!!!!
151 *
152 * This is just ass backwards. This maze has
153 * unbalanced irq_enable/disable calls. So instead of
154 * finding the root cause it works around the warning
155 * in the irq_enable code by conditionally calling
156 * into it.
157 *
158 * That's just wrong.The warning in the core code is
159 * there to tell people to fix their assymetries in
160 * their own code, not by abusing the core information
161 * to avoid it.
162 *
163 * I so wish that the assymetry would be the other way
164 * round and a few more irq_disable calls render that
165 * shit unusable forever.
166 *
167 * tglx
168 */
Thomas Gleixner57310c32014-03-05 00:06:11 +0100169 if (irqd_irq_disabled(irq_get_irq_data(dev->irq)))
Gavin Shan91150af2013-07-24 10:25:00 +0800170 enable_irq(dev->irq);
Thomas Gleixner57310c32014-03-05 00:06:11 +0100171 }
Mike Mason8535ef02009-02-10 11:12:21 +0000172}
173
Linas Vepstascb5b56242006-09-15 18:56:35 -0500174/**
Gavin Shan29f8bf12012-02-27 20:04:02 +0000175 * eeh_report_error - Report pci error to each device driver
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000176 * @data: eeh device
Gavin Shan29f8bf12012-02-27 20:04:02 +0000177 * @userdata: return value
Gavin Shana84f2732013-06-20 13:20:51 +0800178 *
179 * Report an EEH error to each device driver, collect up and
180 * merge the device driver responses. Cumulative response
Linas Vepstascb5b56242006-09-15 18:56:35 -0500181 * passed back in "userdata".
Linas Vepstas77bd7412005-11-03 18:52:49 -0600182 */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000183static void *eeh_report_error(void *data, void *userdata)
Linas Vepstas77bd7412005-11-03 18:52:49 -0600184{
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000185 struct eeh_dev *edev = (struct eeh_dev *)data;
186 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
Paul Mackerras18eb3b32005-11-29 17:17:02 +1100187 enum pci_ers_result rc, *res = userdata;
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000188 struct pci_driver *driver;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600189
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000190 /* We might not have the associated PCI device,
191 * then we should continue for next one.
192 */
193 if (!dev) return NULL;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600194 dev->error_state = pci_channel_io_frozen;
195
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000196 driver = eeh_pcid_get(dev);
197 if (!driver) return NULL;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600198
Mike Mason8535ef02009-02-10 11:12:21 +0000199 eeh_disable_irq(dev);
200
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500201 if (!driver->err_handler ||
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000202 !driver->err_handler->error_detected) {
203 eeh_pcid_put(dev);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000204 return NULL;
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000205 }
Linas Vepstas77bd7412005-11-03 18:52:49 -0600206
Gavin Shan29f8bf12012-02-27 20:04:02 +0000207 rc = driver->err_handler->error_detected(dev, pci_channel_io_frozen);
Linas Vepstas2a50f142007-11-03 07:27:50 +1100208
209 /* A driver that needs a reset trumps all others */
210 if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
Paul Mackerras18eb3b32005-11-29 17:17:02 +1100211 if (*res == PCI_ERS_RESULT_NONE) *res = rc;
Zhang, Yanmin70298c62009-06-16 13:34:38 +0800212
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000213 eeh_pcid_put(dev);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000214 return NULL;
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500215}
216
217/**
Gavin Shan29f8bf12012-02-27 20:04:02 +0000218 * eeh_report_mmio_enabled - Tell drivers that MMIO has been enabled
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000219 * @data: eeh device
Gavin Shan29f8bf12012-02-27 20:04:02 +0000220 * @userdata: return value
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500221 *
Linas Vepstas638799b2007-11-03 07:25:55 +1100222 * Tells each device driver that IO ports, MMIO and config space I/O
223 * are now enabled. Collects up and merges the device driver responses.
224 * Cumulative response passed back in "userdata".
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500225 */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000226static void *eeh_report_mmio_enabled(void *data, void *userdata)
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500227{
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000228 struct eeh_dev *edev = (struct eeh_dev *)data;
229 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500230 enum pci_ers_result rc, *res = userdata;
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000231 struct pci_driver *driver;
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500232
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000233 driver = eeh_pcid_get(dev);
234 if (!driver) return NULL;
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000235
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000236 if (!driver->err_handler ||
Gavin Shanf26c7a02014-01-12 14:13:45 +0800237 !driver->err_handler->mmio_enabled ||
238 (edev->mode & EEH_DEV_NO_HANDLER)) {
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000239 eeh_pcid_put(dev);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000240 return NULL;
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000241 }
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500242
Gavin Shan29f8bf12012-02-27 20:04:02 +0000243 rc = driver->err_handler->mmio_enabled(dev);
Linas Vepstas2a50f142007-11-03 07:27:50 +1100244
245 /* A driver that needs a reset trumps all others */
246 if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500247 if (*res == PCI_ERS_RESULT_NONE) *res = rc;
Zhang, Yanmin70298c62009-06-16 13:34:38 +0800248
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000249 eeh_pcid_put(dev);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000250 return NULL;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600251}
252
Linas Vepstascb5b56242006-09-15 18:56:35 -0500253/**
Gavin Shan29f8bf12012-02-27 20:04:02 +0000254 * eeh_report_reset - Tell device that slot has been reset
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000255 * @data: eeh device
Gavin Shan29f8bf12012-02-27 20:04:02 +0000256 * @userdata: return value
257 *
258 * This routine must be called while EEH tries to reset particular
259 * PCI device so that the associated PCI device driver could take
260 * some actions, usually to save data the driver needs so that the
261 * driver can work again while the device is recovered.
Linas Vepstas77bd7412005-11-03 18:52:49 -0600262 */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000263static void *eeh_report_reset(void *data, void *userdata)
Linas Vepstas77bd7412005-11-03 18:52:49 -0600264{
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000265 struct eeh_dev *edev = (struct eeh_dev *)data;
266 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500267 enum pci_ers_result rc, *res = userdata;
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000268 struct pci_driver *driver;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600269
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000270 if (!dev) return NULL;
Mike Masonc58dc572009-04-10 08:57:03 +0000271 dev->error_state = pci_channel_io_normal;
272
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000273 driver = eeh_pcid_get(dev);
274 if (!driver) return NULL;
275
Mike Mason8535ef02009-02-10 11:12:21 +0000276 eeh_enable_irq(dev);
277
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500278 if (!driver->err_handler ||
Gavin Shanf26c7a02014-01-12 14:13:45 +0800279 !driver->err_handler->slot_reset ||
280 (edev->mode & EEH_DEV_NO_HANDLER)) {
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000281 eeh_pcid_put(dev);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000282 return NULL;
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000283 }
Linas Vepstas77bd7412005-11-03 18:52:49 -0600284
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500285 rc = driver->err_handler->slot_reset(dev);
Linas Vepstas5794dbc2007-03-19 14:55:51 -0500286 if ((*res == PCI_ERS_RESULT_NONE) ||
287 (*res == PCI_ERS_RESULT_RECOVERED)) *res = rc;
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500288 if (*res == PCI_ERS_RESULT_DISCONNECT &&
289 rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
Zhang, Yanmin70298c62009-06-16 13:34:38 +0800290
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000291 eeh_pcid_put(dev);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000292 return NULL;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600293}
294
Linas Vepstascb5b56242006-09-15 18:56:35 -0500295/**
Gavin Shan29f8bf12012-02-27 20:04:02 +0000296 * eeh_report_resume - Tell device to resume normal operations
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000297 * @data: eeh device
Gavin Shan29f8bf12012-02-27 20:04:02 +0000298 * @userdata: return value
299 *
300 * This routine must be called to notify the device driver that it
301 * could resume so that the device driver can do some initialization
302 * to make the recovered device work again.
Linas Vepstascb5b56242006-09-15 18:56:35 -0500303 */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000304static void *eeh_report_resume(void *data, void *userdata)
Linas Vepstas77bd7412005-11-03 18:52:49 -0600305{
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000306 struct eeh_dev *edev = (struct eeh_dev *)data;
307 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
308 struct pci_driver *driver;
309
310 if (!dev) return NULL;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600311 dev->error_state = pci_channel_io_normal;
312
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000313 driver = eeh_pcid_get(dev);
314 if (!driver) return NULL;
Linas Vepstasd0e70342006-12-06 12:32:20 -0600315
Mike Mason8535ef02009-02-10 11:12:21 +0000316 eeh_enable_irq(dev);
317
Linas Vepstasd0e70342006-12-06 12:32:20 -0600318 if (!driver->err_handler ||
Gavin Shanf26c7a02014-01-12 14:13:45 +0800319 !driver->err_handler->resume ||
320 (edev->mode & EEH_DEV_NO_HANDLER)) {
321 edev->mode &= ~EEH_DEV_NO_HANDLER;
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000322 eeh_pcid_put(dev);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000323 return NULL;
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000324 }
Linas Vepstas77bd7412005-11-03 18:52:49 -0600325
326 driver->err_handler->resume(dev);
Zhang, Yanmin70298c62009-06-16 13:34:38 +0800327
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000328 eeh_pcid_put(dev);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000329 return NULL;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600330}
331
Linas Vepstascb5b56242006-09-15 18:56:35 -0500332/**
Gavin Shan29f8bf12012-02-27 20:04:02 +0000333 * eeh_report_failure - Tell device driver that device is dead.
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000334 * @data: eeh device
Gavin Shan29f8bf12012-02-27 20:04:02 +0000335 * @userdata: return value
Linas Vepstascb5b56242006-09-15 18:56:35 -0500336 *
337 * This informs the device driver that the device is permanently
338 * dead, and that no further recovery attempts will be made on it.
339 */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000340static void *eeh_report_failure(void *data, void *userdata)
Linas Vepstas77bd7412005-11-03 18:52:49 -0600341{
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000342 struct eeh_dev *edev = (struct eeh_dev *)data;
343 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
344 struct pci_driver *driver;
345
346 if (!dev) return NULL;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600347 dev->error_state = pci_channel_io_perm_failure;
348
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000349 driver = eeh_pcid_get(dev);
350 if (!driver) return NULL;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600351
Mike Mason8535ef02009-02-10 11:12:21 +0000352 eeh_disable_irq(dev);
353
354 if (!driver->err_handler ||
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000355 !driver->err_handler->error_detected) {
356 eeh_pcid_put(dev);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000357 return NULL;
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000358 }
Mike Mason8535ef02009-02-10 11:12:21 +0000359
Linas Vepstas77bd7412005-11-03 18:52:49 -0600360 driver->err_handler->error_detected(dev, pci_channel_io_perm_failure);
Zhang, Yanmin70298c62009-06-16 13:34:38 +0800361
Gavin Shanfeadf7c2012-09-17 04:34:27 +0000362 eeh_pcid_put(dev);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000363 return NULL;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600364}
365
Gavin Shanf5c57712013-07-24 10:24:58 +0800366static void *eeh_rmv_device(void *data, void *userdata)
367{
368 struct pci_driver *driver;
369 struct eeh_dev *edev = (struct eeh_dev *)data;
370 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
371 int *removed = (int *)userdata;
372
373 /*
374 * Actually, we should remove the PCI bridges as well.
375 * However, that's lots of complexity to do that,
376 * particularly some of devices under the bridge might
377 * support EEH. So we just care about PCI devices for
378 * simplicity here.
379 */
380 if (!dev || (dev->hdr_type & PCI_HEADER_TYPE_BRIDGE))
381 return NULL;
Thadeu Lima de Souza Cascardo8cc6b6c2014-02-05 16:20:45 -0200382
Gavin Shanf5c57712013-07-24 10:24:58 +0800383 driver = eeh_pcid_get(dev);
Thadeu Lima de Souza Cascardo8cc6b6c2014-02-05 16:20:45 -0200384 if (driver) {
385 eeh_pcid_put(dev);
386 if (driver->err_handler)
387 return NULL;
388 }
Gavin Shanf5c57712013-07-24 10:24:58 +0800389
390 /* Remove it from PCI subsystem */
391 pr_debug("EEH: Removing %s without EEH sensitive driver\n",
392 pci_name(dev));
393 edev->bus = dev->bus;
394 edev->mode |= EEH_DEV_DISCONNECTED;
395 (*removed)++;
396
Rafael J. Wysocki1c2042c2014-01-15 14:33:20 +0100397 pci_lock_rescan_remove();
Gavin Shanf5c57712013-07-24 10:24:58 +0800398 pci_stop_and_remove_bus_device(dev);
Rafael J. Wysocki1c2042c2014-01-15 14:33:20 +0100399 pci_unlock_rescan_remove();
Gavin Shanf5c57712013-07-24 10:24:58 +0800400
401 return NULL;
402}
403
404static void *eeh_pe_detach_dev(void *data, void *userdata)
405{
406 struct eeh_pe *pe = (struct eeh_pe *)data;
407 struct eeh_dev *edev, *tmp;
408
409 eeh_pe_for_each_dev(pe, edev, tmp) {
410 if (!(edev->mode & EEH_DEV_DISCONNECTED))
411 continue;
412
413 edev->mode &= ~(EEH_DEV_DISCONNECTED | EEH_DEV_IRQ_DISABLED);
414 eeh_rmv_from_parent_pe(edev);
415 }
416
417 return NULL;
418}
419
Linas Vepstas77bd7412005-11-03 18:52:49 -0600420/**
Gavin Shan29f8bf12012-02-27 20:04:02 +0000421 * eeh_reset_device - Perform actual reset of a pci slot
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000422 * @pe: EEH PE
Gavin Shan29f8bf12012-02-27 20:04:02 +0000423 * @bus: PCI bus corresponding to the isolcated slot
Linas Vepstas77bd7412005-11-03 18:52:49 -0600424 *
Gavin Shan29f8bf12012-02-27 20:04:02 +0000425 * This routine must be called to do reset on the indicated PE.
426 * During the reset, udev might be invoked because those affected
427 * PCI devices will be removed and then added.
Linas Vepstas77bd7412005-11-03 18:52:49 -0600428 */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000429static int eeh_reset_device(struct eeh_pe *pe, struct pci_bus *bus)
Linas Vepstas77bd7412005-11-03 18:52:49 -0600430{
Gavin Shanf5c57712013-07-24 10:24:58 +0800431 struct pci_bus *frozen_bus = eeh_pe_bus_get(pe);
Gavin Shan5a719782013-06-20 13:21:01 +0800432 struct timeval tstamp;
Gavin Shanf5c57712013-07-24 10:24:58 +0800433 int cnt, rc, removed = 0;
Linas Vepstas42405452006-04-28 17:39:38 -0500434
435 /* pcibios will clear the counter; save the value */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000436 cnt = pe->freeze_count;
Gavin Shan5a719782013-06-20 13:21:01 +0800437 tstamp = pe->tstamp;
Linas Vepstas42405452006-04-28 17:39:38 -0500438
Gavin Shan20ee6a92012-09-11 19:16:17 +0000439 /*
440 * We don't remove the corresponding PE instances because
441 * we need the information afterwords. The attached EEH
442 * devices are expected to be attached soon when calling
443 * into pcibios_add_pci_devices().
444 */
Gavin Shanf5c57712013-07-24 10:24:58 +0800445 eeh_pe_state_mark(pe, EEH_PE_KEEP);
Rafael J. Wysocki1c2042c2014-01-15 14:33:20 +0100446 if (bus) {
447 pci_lock_rescan_remove();
Gavin Shan807a8272013-07-24 10:24:55 +0800448 pcibios_remove_pci_devices(bus);
Rafael J. Wysocki1c2042c2014-01-15 14:33:20 +0100449 pci_unlock_rescan_remove();
450 } else if (frozen_bus) {
Gavin Shanf5c57712013-07-24 10:24:58 +0800451 eeh_pe_dev_traverse(pe, eeh_rmv_device, &removed);
Rafael J. Wysocki1c2042c2014-01-15 14:33:20 +0100452 }
Linas Vepstas77bd7412005-11-03 18:52:49 -0600453
454 /* Reset the pci controller. (Asserts RST#; resets config space).
Linas Vepstasb6495c02005-11-03 18:54:54 -0600455 * Reconfigure bridges and devices. Don't try to bring the system
Gavin Shan29f8bf12012-02-27 20:04:02 +0000456 * up if the reset failed for some reason.
457 */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000458 rc = eeh_reset_pe(pe);
Linas Vepstasb6495c02005-11-03 18:54:54 -0600459 if (rc)
460 return rc;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600461
Rafael J. Wysocki1c2042c2014-01-15 14:33:20 +0100462 pci_lock_rescan_remove();
463
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000464 /* Restore PE */
465 eeh_ops->configure_bridge(pe);
466 eeh_pe_restore_bars(pe);
Linas Vepstas77bd7412005-11-03 18:52:49 -0600467
468 /* Give the system 5 seconds to finish running the user-space
Gavin Shana84f2732013-06-20 13:20:51 +0800469 * hotplug shutdown scripts, e.g. ifdown for ethernet. Yes,
470 * this is a hack, but if we don't do this, and try to bring
471 * the device up before the scripts have taken it down,
Linas Vepstas77bd7412005-11-03 18:52:49 -0600472 * potentially weird things happen.
473 */
474 if (bus) {
Gavin Shanf5c57712013-07-24 10:24:58 +0800475 pr_info("EEH: Sleep 5s ahead of complete hotplug\n");
Gavin Shan29f8bf12012-02-27 20:04:02 +0000476 ssleep(5);
Gavin Shanf5c57712013-07-24 10:24:58 +0800477
478 /*
479 * The EEH device is still connected with its parent
480 * PE. We should disconnect it so the binding can be
481 * rebuilt when adding PCI devices.
482 */
483 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
Linas Vepstas77bd7412005-11-03 18:52:49 -0600484 pcibios_add_pci_devices(bus);
Gavin Shanf5c57712013-07-24 10:24:58 +0800485 } else if (frozen_bus && removed) {
486 pr_info("EEH: Sleep 5s ahead of partial hotplug\n");
487 ssleep(5);
488
489 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
490 pcibios_add_pci_devices(frozen_bus);
Linas Vepstas77bd7412005-11-03 18:52:49 -0600491 }
Gavin Shanf5c57712013-07-24 10:24:58 +0800492 eeh_pe_state_clear(pe, EEH_PE_KEEP);
Gavin Shan5a719782013-06-20 13:21:01 +0800493
494 pe->tstamp = tstamp;
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000495 pe->freeze_count = cnt;
Linas Vepstasb6495c02005-11-03 18:54:54 -0600496
Rafael J. Wysocki1c2042c2014-01-15 14:33:20 +0100497 pci_unlock_rescan_remove();
Linas Vepstasb6495c02005-11-03 18:54:54 -0600498 return 0;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600499}
500
501/* The longest amount of time to wait for a pci device
502 * to come back on line, in seconds.
503 */
Brian Kingfb48dc22013-11-25 16:27:54 -0600504#define MAX_WAIT_FOR_RECOVERY 300
Linas Vepstas77bd7412005-11-03 18:52:49 -0600505
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800506static void eeh_handle_normal_event(struct eeh_pe *pe)
Linas Vepstas77bd7412005-11-03 18:52:49 -0600507{
Linas Vepstas77bd7412005-11-03 18:52:49 -0600508 struct pci_bus *frozen_bus;
Linas Vepstasb6495c02005-11-03 18:54:54 -0600509 int rc = 0;
Paul Mackerras18eb3b32005-11-29 17:17:02 +1100510 enum pci_ers_result result = PCI_ERS_RESULT_NONE;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600511
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000512 frozen_bus = eeh_pe_bus_get(pe);
Linas Vepstas77bd7412005-11-03 18:52:49 -0600513 if (!frozen_bus) {
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000514 pr_err("%s: Cannot find PCI bus for PHB#%d-PE#%x\n",
515 __func__, pe->phb->global_number, pe->addr);
516 return;
Linas Vepstas77bd7412005-11-03 18:52:49 -0600517 }
518
Gavin Shan5a719782013-06-20 13:21:01 +0800519 eeh_pe_update_time_stamp(pe);
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000520 pe->freeze_count++;
521 if (pe->freeze_count > EEH_MAX_ALLOWED_FREEZES)
Linas Vepstas8df83022006-03-29 15:31:04 -0600522 goto excess_failures;
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000523 pr_warning("EEH: This PCI device has failed %d times in the last hour\n",
524 pe->freeze_count);
Linas Vepstas77bd7412005-11-03 18:52:49 -0600525
526 /* Walk the various device drivers attached to this slot through
527 * a reset sequence, giving each an opportunity to do what it needs
528 * to accomplish the reset. Each child gets a report of the
529 * status ... if any child can't handle the reset, then the entire
530 * slot is dlpar removed and added.
531 */
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800532 pr_info("EEH: Notify device drivers to shutdown\n");
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000533 eeh_pe_dev_traverse(pe, eeh_report_error, &result);
Linas Vepstas77bd7412005-11-03 18:52:49 -0600534
Linas Vepstas5f1a7c82007-11-16 05:58:36 +1100535 /* Get the current PCI slot state. This can take a long time,
Gavin Shan29f8bf12012-02-27 20:04:02 +0000536 * sometimes over 3 seconds for certain systems.
537 */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000538 rc = eeh_ops->wait_state(pe, MAX_WAIT_FOR_RECOVERY*1000);
Gavin Shaneb594a42012-02-27 20:03:57 +0000539 if (rc < 0 || rc == EEH_STATE_NOT_SUPPORT) {
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800540 pr_warning("EEH: Permanent failure\n");
Linas Vepstas5f1a7c82007-11-16 05:58:36 +1100541 goto hard_fail;
542 }
543
Linas Vepstasede8ca22007-05-09 09:33:29 +1000544 /* Since rtas may enable MMIO when posting the error log,
545 * don't post the error log until after all dev drivers
Linas Vepstas17213c32007-05-10 02:38:11 +1000546 * have been informed.
547 */
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800548 pr_info("EEH: Collect temporary log\n");
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000549 eeh_slot_error_detail(pe, EEH_LOG_TEMP);
Linas Vepstasede8ca22007-05-09 09:33:29 +1000550
Linas Vepstas77bd7412005-11-03 18:52:49 -0600551 /* If all device drivers were EEH-unaware, then shut
552 * down all of the device drivers, and hope they
553 * go down willingly, without panicing the system.
554 */
Paul Mackerras18eb3b32005-11-29 17:17:02 +1100555 if (result == PCI_ERS_RESULT_NONE) {
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800556 pr_info("EEH: Reset with hotplug activity\n");
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000557 rc = eeh_reset_device(pe, frozen_bus);
Linas Vepstase0f90b62007-03-19 14:52:04 -0500558 if (rc) {
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800559 pr_warning("%s: Unable to reset, err=%d\n",
560 __func__, rc);
Linas Vepstasb6495c02005-11-03 18:54:54 -0600561 goto hard_fail;
Linas Vepstase0f90b62007-03-19 14:52:04 -0500562 }
Linas Vepstas77bd7412005-11-03 18:52:49 -0600563 }
564
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500565 /* If all devices reported they can proceed, then re-enable MMIO */
566 if (result == PCI_ERS_RESULT_CAN_RECOVER) {
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800567 pr_info("EEH: Enable I/O for affected devices\n");
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000568 rc = eeh_pci_enable(pe, EEH_OPT_THAW_MMIO);
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500569
Linas Vepstasfa1be472007-03-19 14:59:59 -0500570 if (rc < 0)
571 goto hard_fail;
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500572 if (rc) {
573 result = PCI_ERS_RESULT_NEED_RESET;
574 } else {
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800575 pr_info("EEH: Notify device drivers to resume I/O\n");
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500576 result = PCI_ERS_RESULT_NONE;
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000577 eeh_pe_dev_traverse(pe, eeh_report_mmio_enabled, &result);
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500578 }
579 }
580
581 /* If all devices reported they can proceed, then re-enable DMA */
582 if (result == PCI_ERS_RESULT_CAN_RECOVER) {
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800583 pr_info("EEH: Enabled DMA for affected devices\n");
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000584 rc = eeh_pci_enable(pe, EEH_OPT_THAW_DMA);
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500585
Linas Vepstasfa1be472007-03-19 14:59:59 -0500586 if (rc < 0)
587 goto hard_fail;
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500588 if (rc)
589 result = PCI_ERS_RESULT_NEED_RESET;
Linas Vepstasd0e70342006-12-06 12:32:20 -0600590 else
591 result = PCI_ERS_RESULT_RECOVERED;
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500592 }
593
594 /* If any device has a hard failure, then shut off everything. */
Linas Vepstase0f90b62007-03-19 14:52:04 -0500595 if (result == PCI_ERS_RESULT_DISCONNECT) {
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800596 pr_warning("EEH: Device driver gave up\n");
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500597 goto hard_fail;
Linas Vepstase0f90b62007-03-19 14:52:04 -0500598 }
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500599
Linas Vepstas77bd7412005-11-03 18:52:49 -0600600 /* If any device called out for a reset, then reset the slot */
Paul Mackerras18eb3b32005-11-29 17:17:02 +1100601 if (result == PCI_ERS_RESULT_NEED_RESET) {
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800602 pr_info("EEH: Reset without hotplug activity\n");
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000603 rc = eeh_reset_device(pe, NULL);
Linas Vepstase0f90b62007-03-19 14:52:04 -0500604 if (rc) {
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800605 pr_warning("%s: Cannot reset, err=%d\n",
606 __func__, rc);
Linas Vepstasb6495c02005-11-03 18:54:54 -0600607 goto hard_fail;
Linas Vepstase0f90b62007-03-19 14:52:04 -0500608 }
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800609
610 pr_info("EEH: Notify device drivers "
611 "the completion of reset\n");
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500612 result = PCI_ERS_RESULT_NONE;
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000613 eeh_pe_dev_traverse(pe, eeh_report_reset, &result);
Linas Vepstas77bd7412005-11-03 18:52:49 -0600614 }
615
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500616 /* All devices should claim they have recovered by now. */
Linas Vepstas90fdd612007-03-19 14:55:10 -0500617 if ((result != PCI_ERS_RESULT_RECOVERED) &&
618 (result != PCI_ERS_RESULT_NONE)) {
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800619 pr_warning("EEH: Not recovered\n");
Linas Vepstas6a1ca372006-09-15 18:58:59 -0500620 goto hard_fail;
Linas Vepstase0f90b62007-03-19 14:52:04 -0500621 }
Linas Vepstas77bd7412005-11-03 18:52:49 -0600622
623 /* Tell all device drivers that they can resume operations */
Gavin Shan56ca4fd2013-06-27 13:46:46 +0800624 pr_info("EEH: Notify device driver to resume\n");
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000625 eeh_pe_dev_traverse(pe, eeh_report_resume, NULL);
Linas Vepstasb6495c02005-11-03 18:54:54 -0600626
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000627 return;
Gavin Shana84f2732013-06-20 13:20:51 +0800628
Linas Vepstas8df83022006-03-29 15:31:04 -0600629excess_failures:
Linas Vepstasb6495c02005-11-03 18:54:54 -0600630 /*
631 * About 90% of all real-life EEH failures in the field
632 * are due to poorly seated PCI cards. Only 10% or so are
633 * due to actual, failed cards.
634 */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000635 pr_err("EEH: PHB#%d-PE#%x has failed %d times in the\n"
636 "last hour and has been permanently disabled.\n"
637 "Please try reseating or replacing it.\n",
638 pe->phb->global_number, pe->addr,
639 pe->freeze_count);
Linas Vepstas8df83022006-03-29 15:31:04 -0600640 goto perm_error;
Linas Vepstasb6495c02005-11-03 18:54:54 -0600641
Linas Vepstas8df83022006-03-29 15:31:04 -0600642hard_fail:
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000643 pr_err("EEH: Unable to recover from failure from PHB#%d-PE#%x.\n"
644 "Please try reseating or replacing it\n",
645 pe->phb->global_number, pe->addr);
Linas Vepstas8df83022006-03-29 15:31:04 -0600646
647perm_error:
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000648 eeh_slot_error_detail(pe, EEH_LOG_PERM);
Linas Vepstasb6495c02005-11-03 18:54:54 -0600649
650 /* Notify all devices that they're about to go down. */
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000651 eeh_pe_dev_traverse(pe, eeh_report_failure, NULL);
Linas Vepstasb6495c02005-11-03 18:54:54 -0600652
653 /* Shut down the device drivers for good. */
Rafael J. Wysocki1c2042c2014-01-15 14:33:20 +0100654 if (frozen_bus) {
655 pci_lock_rescan_remove();
Gavin Shan9b3c76f2012-09-07 22:44:19 +0000656 pcibios_remove_pci_devices(frozen_bus);
Rafael J. Wysocki1c2042c2014-01-15 14:33:20 +0100657 pci_unlock_rescan_remove();
658 }
Linas Vepstas77bd7412005-11-03 18:52:49 -0600659}
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800660
661static void eeh_handle_special_event(void)
662{
663 struct eeh_pe *pe, *phb_pe;
664 struct pci_bus *bus;
Gavin Shan7e4e7862014-01-15 13:16:11 +0800665 struct pci_controller *hose;
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800666 unsigned long flags;
Gavin Shan7e4e7862014-01-15 13:16:11 +0800667 int rc;
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800668
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800669
Gavin Shan7e4e7862014-01-15 13:16:11 +0800670 do {
671 rc = eeh_ops->next_error(&pe);
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800672
Gavin Shan7e4e7862014-01-15 13:16:11 +0800673 switch (rc) {
674 case EEH_NEXT_ERR_DEAD_IOC:
675 /* Mark all PHBs in dead state */
676 eeh_serialize_lock(&flags);
677
678 /* Purge all events */
679 eeh_remove_event(NULL);
680
681 list_for_each_entry(hose, &hose_list, list_node) {
682 phb_pe = eeh_phb_pe_get(hose);
683 if (!phb_pe) continue;
684
685 eeh_pe_state_mark(phb_pe,
686 EEH_PE_ISOLATED | EEH_PE_PHB_DEAD);
687 }
688
689 eeh_serialize_unlock(flags);
690
691 break;
692 case EEH_NEXT_ERR_FROZEN_PE:
693 case EEH_NEXT_ERR_FENCED_PHB:
694 case EEH_NEXT_ERR_DEAD_PHB:
695 /* Mark the PE in fenced state */
696 eeh_serialize_lock(&flags);
697
698 /* Purge all events of the PHB */
699 eeh_remove_event(pe);
700
701 if (rc == EEH_NEXT_ERR_DEAD_PHB)
702 eeh_pe_state_mark(pe,
703 EEH_PE_ISOLATED | EEH_PE_PHB_DEAD);
704 else
705 eeh_pe_state_mark(pe,
706 EEH_PE_ISOLATED | EEH_PE_RECOVERING);
707
708 eeh_serialize_unlock(flags);
709
710 break;
711 case EEH_NEXT_ERR_NONE:
712 return;
713 default:
714 pr_warn("%s: Invalid value %d from next_error()\n",
715 __func__, rc);
716 return;
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800717 }
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800718
Gavin Shan7e4e7862014-01-15 13:16:11 +0800719 /*
720 * For fenced PHB and frozen PE, it's handled as normal
721 * event. We have to remove the affected PHBs for dead
722 * PHB and IOC
723 */
724 if (rc == EEH_NEXT_ERR_FROZEN_PE ||
725 rc == EEH_NEXT_ERR_FENCED_PHB) {
726 eeh_handle_normal_event(pe);
727 } else {
Linus Torvalds1b173662014-01-27 21:11:26 -0800728 pci_lock_rescan_remove();
Gavin Shan7e4e7862014-01-15 13:16:11 +0800729 list_for_each_entry(hose, &hose_list, list_node) {
730 phb_pe = eeh_phb_pe_get(hose);
731 if (!phb_pe ||
732 !(phb_pe->state & EEH_PE_PHB_DEAD))
733 continue;
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800734
Gavin Shan7e4e7862014-01-15 13:16:11 +0800735 /* Notify all devices to be down */
736 bus = eeh_pe_bus_get(phb_pe);
737 eeh_pe_dev_traverse(pe,
738 eeh_report_failure, NULL);
739 pcibios_remove_pci_devices(bus);
740 }
Linus Torvalds1b173662014-01-27 21:11:26 -0800741 pci_unlock_rescan_remove();
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800742 }
Gavin Shan7e4e7862014-01-15 13:16:11 +0800743
744 /*
745 * If we have detected dead IOC, we needn't proceed
746 * any more since all PHBs would have been removed
747 */
748 if (rc == EEH_NEXT_ERR_DEAD_IOC)
749 break;
750 } while (rc != EEH_NEXT_ERR_NONE);
Gavin Shan8a6b1bc2013-06-20 13:21:04 +0800751}
752
753/**
754 * eeh_handle_event - Reset a PCI device after hard lockup.
755 * @pe: EEH PE
756 *
757 * While PHB detects address or data parity errors on particular PCI
758 * slot, the associated PE will be frozen. Besides, DMA's occurring
759 * to wild addresses (which usually happen due to bugs in device
760 * drivers or in PCI adapter firmware) can cause EEH error. #SERR,
761 * #PERR or other misc PCI-related errors also can trigger EEH errors.
762 *
763 * Recovery process consists of unplugging the device driver (which
764 * generated hotplug events to userspace), then issuing a PCI #RST to
765 * the device, then reconfiguring the PCI config space for all bridges
766 * & devices under this slot, and then finally restarting the device
767 * drivers (which cause a second set of hotplug events to go out to
768 * userspace).
769 */
770void eeh_handle_event(struct eeh_pe *pe)
771{
772 if (pe)
773 eeh_handle_normal_event(pe);
774 else
775 eeh_handle_special_event();
776}