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
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.
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
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.
23 * Send comments and feedback to Linas Vepstas <linas@austin.ibm.com>
25 #include <linux/delay.h>
26 #include <linux/interrupt.h>
27 #include <linux/irq.h>
28 #include <linux/pci.h>
30 #include <asm/eeh_event.h>
31 #include <asm/ppc-pci.h>
32 #include <asm/pci-bridge.h>
37 static inline const char * pcid_name (struct pci_dev
*pdev
)
39 if (pdev
&& pdev
->dev
.driver
)
40 return pdev
->dev
.driver
->name
;
45 static void print_device_node_tree(struct pci_dn
*pdn
, int dent
)
48 struct device_node
*pc
;
52 for (i
= 0; i
< dent
; i
++)
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
);
58 pc
= pdn
->node
->child
;
60 print_device_node_tree(PCI_DN(pc
), dent
);
67 * eeh_disable_irq - disable interrupt for the recovering device
69 static void eeh_disable_irq(struct pci_dev
*dev
)
71 struct device_node
*dn
= pci_device_to_OF_node(dev
);
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.
77 if (dev
->msi_enabled
|| dev
->msix_enabled
)
80 if (!irq_has_action(dev
->irq
))
83 PCI_DN(dn
)->eeh_mode
|= EEH_MODE_IRQ_DISABLED
;
84 disable_irq_nosync(dev
->irq
);
88 * eeh_enable_irq - enable interrupt for the recovering device
90 static void eeh_enable_irq(struct pci_dev
*dev
)
92 struct device_node
*dn
= pci_device_to_OF_node(dev
);
94 if ((PCI_DN(dn
)->eeh_mode
) & EEH_MODE_IRQ_DISABLED
) {
95 PCI_DN(dn
)->eeh_mode
&= ~EEH_MODE_IRQ_DISABLED
;
100 /* ------------------------------------------------------- */
102 * eeh_report_error - report pci error to each device driver
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".
109 static int eeh_report_error(struct pci_dev
*dev
, void *userdata
)
111 enum pci_ers_result rc
, *res
= userdata
;
112 struct pci_driver
*driver
= dev
->driver
;
114 dev
->error_state
= pci_channel_io_frozen
;
119 eeh_disable_irq(dev
);
121 if (!driver
->err_handler
||
122 !driver
->err_handler
->error_detected
)
125 rc
= driver
->err_handler
->error_detected (dev
, pci_channel_io_frozen
);
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
;
135 * eeh_report_mmio_enabled - tell drivers that MMIO has been enabled
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".
142 static int eeh_report_mmio_enabled(struct pci_dev
*dev
, void *userdata
)
144 enum pci_ers_result rc
, *res
= userdata
;
145 struct pci_driver
*driver
= dev
->driver
;
148 !driver
->err_handler
||
149 !driver
->err_handler
->mmio_enabled
)
152 rc
= driver
->err_handler
->mmio_enabled (dev
);
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
;
162 * eeh_report_reset - tell device that slot has been reset
165 static int eeh_report_reset(struct pci_dev
*dev
, void *userdata
)
167 enum pci_ers_result rc
, *res
= userdata
;
168 struct pci_driver
*driver
= dev
->driver
;
173 dev
->error_state
= pci_channel_io_normal
;
177 if (!driver
->err_handler
||
178 !driver
->err_handler
->slot_reset
)
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
;
191 * eeh_report_resume - tell device to resume normal operations
194 static int eeh_report_resume(struct pci_dev
*dev
, void *userdata
)
196 struct pci_driver
*driver
= dev
->driver
;
198 dev
->error_state
= pci_channel_io_normal
;
205 if (!driver
->err_handler
||
206 !driver
->err_handler
->resume
)
209 driver
->err_handler
->resume(dev
);
215 * eeh_report_failure - tell device driver that device is dead.
217 * This informs the device driver that the device is permanently
218 * dead, and that no further recovery attempts will be made on it.
221 static int eeh_report_failure(struct pci_dev
*dev
, void *userdata
)
223 struct pci_driver
*driver
= dev
->driver
;
225 dev
->error_state
= pci_channel_io_perm_failure
;
230 eeh_disable_irq(dev
);
232 if (!driver
->err_handler
||
233 !driver
->err_handler
->error_detected
)
236 driver
->err_handler
->error_detected(dev
, pci_channel_io_perm_failure
);
241 /* ------------------------------------------------------- */
243 * handle_eeh_events -- reset a PCI device after hard lockup.
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.
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).
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
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.
271 static int eeh_reset_device (struct pci_dn
*pe_dn
, struct pci_bus
*bus
)
273 struct device_node
*dn
;
276 /* pcibios will clear the counter; save the value */
277 cnt
= pe_dn
->eeh_freeze_count
;
280 pcibios_remove_pci_devices(bus
);
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
);
289 /* Walk over all functions on this device. */
291 if (!pcibios_find_pci_bus(dn
) && PCI_DN(dn
->parent
))
292 dn
= dn
->parent
->child
;
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
);
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.
312 pcibios_add_pci_devices(bus
);
314 pe_dn
->eeh_freeze_count
= cnt
;
319 /* The longest amount of time to wait for a pci device
320 * to come back on line, in seconds.
322 #define MAX_WAIT_FOR_RECOVERY 150
324 struct pci_dn
* handle_eeh_events (struct eeh_event
*event
)
326 struct device_node
*frozen_dn
;
327 struct pci_dn
*frozen_pdn
;
328 struct pci_bus
*frozen_bus
;
330 enum pci_ers_result result
= PCI_ERS_RESULT_NONE
;
331 const char *location
, *pci_str
, *drv_str
;
333 frozen_dn
= find_device_pe(event
->dn
);
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
));
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";
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.. */
355 frozen_bus
= pcibios_find_pci_bus (frozen_dn
->parent
);
358 printk(KERN_ERR
"EEH: Cannot find PCI bus "
359 "for location=%s dn=%s\n",
360 location
, frozen_dn
->full_name
);
364 frozen_pdn
= PCI_DN(frozen_dn
);
365 frozen_pdn
->eeh_freeze_count
++;
367 if (frozen_pdn
->pcidev
) {
368 pci_str
= pci_name (frozen_pdn
->pcidev
);
369 drv_str
= pcid_name (frozen_pdn
->pcidev
);
371 pci_str
= eeh_pci_name(event
->dev
);
372 drv_str
= pcid_name (event
->dev
);
375 if (frozen_pdn
->eeh_freeze_count
> EEH_MAX_ALLOWED_FREEZES
)
376 goto excess_failures
;
379 "EEH: This PCI device has failed %d times in the last hour:\n",
380 frozen_pdn
->eeh_freeze_count
);
382 "EEH: location=%s driver=%s pci addr=%s\n",
383 location
, drv_str
, pci_str
);
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.
391 pci_walk_bus(frozen_bus
, eeh_report_error
, &result
);
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);
397 printk(KERN_WARNING
"EEH: Permanent failure\n");
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.
405 eeh_slot_error_detail(frozen_pdn
, EEH_LOG_TEMP_FAILURE
);
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.
411 if (result
== PCI_ERS_RESULT_NONE
) {
412 rc
= eeh_reset_device(frozen_pdn
, frozen_bus
);
414 printk(KERN_WARNING
"EEH: Unable to reset, rc=%d\n", rc
);
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
);
426 result
= PCI_ERS_RESULT_NEED_RESET
;
428 result
= PCI_ERS_RESULT_NONE
;
429 pci_walk_bus(frozen_bus
, eeh_report_mmio_enabled
, &result
);
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
);
440 result
= PCI_ERS_RESULT_NEED_RESET
;
442 result
= PCI_ERS_RESULT_RECOVERED
;
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");
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
);
455 printk(KERN_WARNING
"EEH: Cannot reset, rc=%d\n", rc
);
458 result
= PCI_ERS_RESULT_NONE
;
459 pci_walk_bus(frozen_bus
, eeh_report_reset
, &result
);
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");
469 /* Tell all device drivers that they can resume operations */
470 pci_walk_bus(frozen_bus
, eeh_report_resume
, NULL
);
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.
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
);
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
);
496 eeh_slot_error_detail(frozen_pdn
, EEH_LOG_PERM_FAILURE
);
498 /* Notify all devices that they're about to go down. */
499 pci_walk_bus(frozen_bus
, eeh_report_failure
, NULL
);
501 /* Shut down the device drivers for good. */
502 pcibios_remove_pci_devices(frozen_bus
);
507 /* ---------- end of file ---------- */