/arch/powerpc/platforms/pseries/eeh_driver.c
C | 507 lines | 275 code | 90 blank | 142 comment | 67 complexity | 5fe6ab2f5b6100c6d6b4462e9b3f80b1 MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0, AGPL-1.0
1/*
2 * PCI Error Recovery Driver for RPA-compliant PPC64 platform.
3 * Copyright IBM Corp. 2004 2005
4 * Copyright Linas Vepstas <linas@linas.org> 2004, 2005
5 *
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 *
23 * Send comments and feedback to Linas Vepstas <linas@austin.ibm.com>
24 */
25#include <linux/delay.h>
26#include <linux/interrupt.h>
27#include <linux/irq.h>
28#include <linux/pci.h>
29#include <asm/eeh.h>
30#include <asm/eeh_event.h>
31#include <asm/ppc-pci.h>
32#include <asm/pci-bridge.h>
33#include <asm/prom.h>
34#include <asm/rtas.h>
35
36
37static inline const char * pcid_name (struct pci_dev *pdev)
38{
39 if (pdev && pdev->dev.driver)
40 return pdev->dev.driver->name;
41 return "";
42}
43
44#if 0
45static void print_device_node_tree(struct pci_dn *pdn, int dent)
46{
47 int i;
48 struct device_node *pc;
49
50 if (!pdn)
51 return;
52 for (i = 0; i < dent; i++)
53 printk(" ");
54 printk("dn=%s mode=%x \tcfg_addr=%x pe_addr=%x \tfull=%s\n",
55 pdn->node->name, pdn->eeh_mode, pdn->eeh_config_addr,
56 pdn->eeh_pe_config_addr, pdn->node->full_name);
57 dent += 3;
58 pc = pdn->node->child;
59 while (pc) {
60 print_device_node_tree(PCI_DN(pc), dent);
61 pc = pc->sibling;
62 }
63}
64#endif
65
66/**
67 * eeh_disable_irq - disable interrupt for the recovering device
68 */
69static void eeh_disable_irq(struct pci_dev *dev)
70{
71 struct device_node *dn = pci_device_to_OF_node(dev);
72
73 /* Don't disable MSI and MSI-X interrupts. They are
74 * effectively disabled by the DMA Stopped state
75 * when an EEH error occurs.
76 */
77 if (dev->msi_enabled || dev->msix_enabled)
78 return;
79
80 if (!irq_has_action(dev->irq))
81 return;
82
83 PCI_DN(dn)->eeh_mode |= EEH_MODE_IRQ_DISABLED;
84 disable_irq_nosync(dev->irq);
85}
86
87/**
88 * eeh_enable_irq - enable interrupt for the recovering device
89 */
90static void eeh_enable_irq(struct pci_dev *dev)
91{
92 struct device_node *dn = pci_device_to_OF_node(dev);
93
94 if ((PCI_DN(dn)->eeh_mode) & EEH_MODE_IRQ_DISABLED) {
95 PCI_DN(dn)->eeh_mode &= ~EEH_MODE_IRQ_DISABLED;
96 enable_irq(dev->irq);
97 }
98}
99
100/* ------------------------------------------------------- */
101/**
102 * eeh_report_error - report pci error to each device driver
103 *
104 * Report an EEH error to each device driver, collect up and
105 * merge the device driver responses. Cumulative response
106 * passed back in "userdata".
107 */
108
109static int eeh_report_error(struct pci_dev *dev, void *userdata)
110{
111 enum pci_ers_result rc, *res = userdata;
112 struct pci_driver *driver = dev->driver;
113
114 dev->error_state = pci_channel_io_frozen;
115
116 if (!driver)
117 return 0;
118
119 eeh_disable_irq(dev);
120
121 if (!driver->err_handler ||
122 !driver->err_handler->error_detected)
123 return 0;
124
125 rc = driver->err_handler->error_detected (dev, pci_channel_io_frozen);
126
127 /* A driver that needs a reset trumps all others */
128 if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
129 if (*res == PCI_ERS_RESULT_NONE) *res = rc;
130
131 return 0;
132}
133
134/**
135 * eeh_report_mmio_enabled - tell drivers that MMIO has been enabled
136 *
137 * Tells each device driver that IO ports, MMIO and config space I/O
138 * are now enabled. Collects up and merges the device driver responses.
139 * Cumulative response passed back in "userdata".
140 */
141
142static int eeh_report_mmio_enabled(struct pci_dev *dev, void *userdata)
143{
144 enum pci_ers_result rc, *res = userdata;
145 struct pci_driver *driver = dev->driver;
146
147 if (!driver ||
148 !driver->err_handler ||
149 !driver->err_handler->mmio_enabled)
150 return 0;
151
152 rc = driver->err_handler->mmio_enabled (dev);
153
154 /* A driver that needs a reset trumps all others */
155 if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
156 if (*res == PCI_ERS_RESULT_NONE) *res = rc;
157
158 return 0;
159}
160
161/**
162 * eeh_report_reset - tell device that slot has been reset
163 */
164
165static int eeh_report_reset(struct pci_dev *dev, void *userdata)
166{
167 enum pci_ers_result rc, *res = userdata;
168 struct pci_driver *driver = dev->driver;
169
170 if (!driver)
171 return 0;
172
173 dev->error_state = pci_channel_io_normal;
174
175 eeh_enable_irq(dev);
176
177 if (!driver->err_handler ||
178 !driver->err_handler->slot_reset)
179 return 0;
180
181 rc = driver->err_handler->slot_reset(dev);
182 if ((*res == PCI_ERS_RESULT_NONE) ||
183 (*res == PCI_ERS_RESULT_RECOVERED)) *res = rc;
184 if (*res == PCI_ERS_RESULT_DISCONNECT &&
185 rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
186
187 return 0;
188}
189
190/**
191 * eeh_report_resume - tell device to resume normal operations
192 */
193
194static int eeh_report_resume(struct pci_dev *dev, void *userdata)
195{
196 struct pci_driver *driver = dev->driver;
197
198 dev->error_state = pci_channel_io_normal;
199
200 if (!driver)
201 return 0;
202
203 eeh_enable_irq(dev);
204
205 if (!driver->err_handler ||
206 !driver->err_handler->resume)
207 return 0;
208
209 driver->err_handler->resume(dev);
210
211 return 0;
212}
213
214/**
215 * eeh_report_failure - tell device driver that device is dead.
216 *
217 * This informs the device driver that the device is permanently
218 * dead, and that no further recovery attempts will be made on it.
219 */
220
221static int eeh_report_failure(struct pci_dev *dev, void *userdata)
222{
223 struct pci_driver *driver = dev->driver;
224
225 dev->error_state = pci_channel_io_perm_failure;
226
227 if (!driver)
228 return 0;
229
230 eeh_disable_irq(dev);
231
232 if (!driver->err_handler ||
233 !driver->err_handler->error_detected)
234 return 0;
235
236 driver->err_handler->error_detected(dev, pci_channel_io_perm_failure);
237
238 return 0;
239}
240
241/* ------------------------------------------------------- */
242/**
243 * handle_eeh_events -- reset a PCI device after hard lockup.
244 *
245 * pSeries systems will isolate a PCI slot if the PCI-Host
246 * bridge detects address or data parity errors, DMA's
247 * occurring to wild addresses (which usually happen due to
248 * bugs in device drivers or in PCI adapter firmware).
249 * Slot isolations also occur if #SERR, #PERR or other misc
250 * PCI-related errors are detected.
251 *
252 * Recovery process consists of unplugging the device driver
253 * (which generated hotplug events to userspace), then issuing
254 * a PCI #RST to the device, then reconfiguring the PCI config
255 * space for all bridges & devices under this slot, and then
256 * finally restarting the device drivers (which cause a second
257 * set of hotplug events to go out to userspace).
258 */
259
260/**
261 * eeh_reset_device() -- perform actual reset of a pci slot
262 * @bus: pointer to the pci bus structure corresponding
263 * to the isolated slot. A non-null value will
264 * cause all devices under the bus to be removed
265 * and then re-added.
266 * @pe_dn: pointer to a "Partionable Endpoint" device node.
267 * This is the top-level structure on which pci
268 * bus resets can be performed.
269 */
270
271static int eeh_reset_device (struct pci_dn *pe_dn, struct pci_bus *bus)
272{
273 struct device_node *dn;
274 int cnt, rc;
275
276 /* pcibios will clear the counter; save the value */
277 cnt = pe_dn->eeh_freeze_count;
278
279 if (bus)
280 pcibios_remove_pci_devices(bus);
281
282 /* Reset the pci controller. (Asserts RST#; resets config space).
283 * Reconfigure bridges and devices. Don't try to bring the system
284 * up if the reset failed for some reason. */
285 rc = rtas_set_slot_reset(pe_dn);
286 if (rc)
287 return rc;
288
289 /* Walk over all functions on this device. */
290 dn = pe_dn->node;
291 if (!pcibios_find_pci_bus(dn) && PCI_DN(dn->parent))
292 dn = dn->parent->child;
293
294 while (dn) {
295 struct pci_dn *ppe = PCI_DN(dn);
296 /* On Power4, always true because eeh_pe_config_addr=0 */
297 if (pe_dn->eeh_pe_config_addr == ppe->eeh_pe_config_addr) {
298 rtas_configure_bridge(ppe);
299 eeh_restore_bars(ppe);
300 }
301 dn = dn->sibling;
302 }
303
304 /* Give the system 5 seconds to finish running the user-space
305 * hotplug shutdown scripts, e.g. ifdown for ethernet. Yes,
306 * this is a hack, but if we don't do this, and try to bring
307 * the device up before the scripts have taken it down,
308 * potentially weird things happen.
309 */
310 if (bus) {
311 ssleep (5);
312 pcibios_add_pci_devices(bus);
313 }
314 pe_dn->eeh_freeze_count = cnt;
315
316 return 0;
317}
318
319/* The longest amount of time to wait for a pci device
320 * to come back on line, in seconds.
321 */
322#define MAX_WAIT_FOR_RECOVERY 150
323
324struct pci_dn * handle_eeh_events (struct eeh_event *event)
325{
326 struct device_node *frozen_dn;
327 struct pci_dn *frozen_pdn;
328 struct pci_bus *frozen_bus;
329 int rc = 0;
330 enum pci_ers_result result = PCI_ERS_RESULT_NONE;
331 const char *location, *pci_str, *drv_str;
332
333 frozen_dn = find_device_pe(event->dn);
334 if (!frozen_dn) {
335
336 location = of_get_property(event->dn, "ibm,loc-code", NULL);
337 location = location ? location : "unknown";
338 printk(KERN_ERR "EEH: Error: Cannot find partition endpoint "
339 "for location=%s pci addr=%s\n",
340 location, eeh_pci_name(event->dev));
341 return NULL;
342 }
343
344 frozen_bus = pcibios_find_pci_bus(frozen_dn);
345 location = of_get_property(frozen_dn, "ibm,loc-code", NULL);
346 location = location ? location : "unknown";
347
348 /* There are two different styles for coming up with the PE.
349 * In the old style, it was the highest EEH-capable device
350 * which was always an EADS pci bridge. In the new style,
351 * there might not be any EADS bridges, and even when there are,
352 * the firmware marks them as "EEH incapable". So another
353 * two-step is needed to find the pci bus.. */
354 if (!frozen_bus)
355 frozen_bus = pcibios_find_pci_bus (frozen_dn->parent);
356
357 if (!frozen_bus) {
358 printk(KERN_ERR "EEH: Cannot find PCI bus "
359 "for location=%s dn=%s\n",
360 location, frozen_dn->full_name);
361 return NULL;
362 }
363
364 frozen_pdn = PCI_DN(frozen_dn);
365 frozen_pdn->eeh_freeze_count++;
366
367 if (frozen_pdn->pcidev) {
368 pci_str = pci_name (frozen_pdn->pcidev);
369 drv_str = pcid_name (frozen_pdn->pcidev);
370 } else {
371 pci_str = eeh_pci_name(event->dev);
372 drv_str = pcid_name (event->dev);
373 }
374
375 if (frozen_pdn->eeh_freeze_count > EEH_MAX_ALLOWED_FREEZES)
376 goto excess_failures;
377
378 printk(KERN_WARNING
379 "EEH: This PCI device has failed %d times in the last hour:\n",
380 frozen_pdn->eeh_freeze_count);
381 printk(KERN_WARNING
382 "EEH: location=%s driver=%s pci addr=%s\n",
383 location, drv_str, pci_str);
384
385 /* Walk the various device drivers attached to this slot through
386 * a reset sequence, giving each an opportunity to do what it needs
387 * to accomplish the reset. Each child gets a report of the
388 * status ... if any child can't handle the reset, then the entire
389 * slot is dlpar removed and added.
390 */
391 pci_walk_bus(frozen_bus, eeh_report_error, &result);
392
393 /* Get the current PCI slot state. This can take a long time,
394 * sometimes over 3 seconds for certain systems. */
395 rc = eeh_wait_for_slot_status (frozen_pdn, MAX_WAIT_FOR_RECOVERY*1000);
396 if (rc < 0) {
397 printk(KERN_WARNING "EEH: Permanent failure\n");
398 goto hard_fail;
399 }
400
401 /* Since rtas may enable MMIO when posting the error log,
402 * don't post the error log until after all dev drivers
403 * have been informed.
404 */
405 eeh_slot_error_detail(frozen_pdn, EEH_LOG_TEMP_FAILURE);
406
407 /* If all device drivers were EEH-unaware, then shut
408 * down all of the device drivers, and hope they
409 * go down willingly, without panicing the system.
410 */
411 if (result == PCI_ERS_RESULT_NONE) {
412 rc = eeh_reset_device(frozen_pdn, frozen_bus);
413 if (rc) {
414 printk(KERN_WARNING "EEH: Unable to reset, rc=%d\n", rc);
415 goto hard_fail;
416 }
417 }
418
419 /* If all devices reported they can proceed, then re-enable MMIO */
420 if (result == PCI_ERS_RESULT_CAN_RECOVER) {
421 rc = rtas_pci_enable(frozen_pdn, EEH_THAW_MMIO);
422
423 if (rc < 0)
424 goto hard_fail;
425 if (rc) {
426 result = PCI_ERS_RESULT_NEED_RESET;
427 } else {
428 result = PCI_ERS_RESULT_NONE;
429 pci_walk_bus(frozen_bus, eeh_report_mmio_enabled, &result);
430 }
431 }
432
433 /* If all devices reported they can proceed, then re-enable DMA */
434 if (result == PCI_ERS_RESULT_CAN_RECOVER) {
435 rc = rtas_pci_enable(frozen_pdn, EEH_THAW_DMA);
436
437 if (rc < 0)
438 goto hard_fail;
439 if (rc)
440 result = PCI_ERS_RESULT_NEED_RESET;
441 else
442 result = PCI_ERS_RESULT_RECOVERED;
443 }
444
445 /* If any device has a hard failure, then shut off everything. */
446 if (result == PCI_ERS_RESULT_DISCONNECT) {
447 printk(KERN_WARNING "EEH: Device driver gave up\n");
448 goto hard_fail;
449 }
450
451 /* If any device called out for a reset, then reset the slot */
452 if (result == PCI_ERS_RESULT_NEED_RESET) {
453 rc = eeh_reset_device(frozen_pdn, NULL);
454 if (rc) {
455 printk(KERN_WARNING "EEH: Cannot reset, rc=%d\n", rc);
456 goto hard_fail;
457 }
458 result = PCI_ERS_RESULT_NONE;
459 pci_walk_bus(frozen_bus, eeh_report_reset, &result);
460 }
461
462 /* All devices should claim they have recovered by now. */
463 if ((result != PCI_ERS_RESULT_RECOVERED) &&
464 (result != PCI_ERS_RESULT_NONE)) {
465 printk(KERN_WARNING "EEH: Not recovered\n");
466 goto hard_fail;
467 }
468
469 /* Tell all device drivers that they can resume operations */
470 pci_walk_bus(frozen_bus, eeh_report_resume, NULL);
471
472 return frozen_pdn;
473
474excess_failures:
475 /*
476 * About 90% of all real-life EEH failures in the field
477 * are due to poorly seated PCI cards. Only 10% or so are
478 * due to actual, failed cards.
479 */
480 printk(KERN_ERR
481 "EEH: PCI device at location=%s driver=%s pci addr=%s\n"
482 "has failed %d times in the last hour "
483 "and has been permanently disabled.\n"
484 "Please try reseating this device or replacing it.\n",
485 location, drv_str, pci_str, frozen_pdn->eeh_freeze_count);
486 goto perm_error;
487
488hard_fail:
489 printk(KERN_ERR
490 "EEH: Unable to recover from failure of PCI device "
491 "at location=%s driver=%s pci addr=%s\n"
492 "Please try reseating this device or replacing it.\n",
493 location, drv_str, pci_str);
494
495perm_error:
496 eeh_slot_error_detail(frozen_pdn, EEH_LOG_PERM_FAILURE);
497
498 /* Notify all devices that they're about to go down. */
499 pci_walk_bus(frozen_bus, eeh_report_failure, NULL);
500
501 /* Shut down the device drivers for good. */
502 pcibios_remove_pci_devices(frozen_bus);
503
504 return NULL;
505}
506
507/* ---------- end of file ---------- */