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 * irq_in_use - return true if this irq is being used
69 static int irq_in_use(unsigned int irq
)
73 struct irq_desc
*desc
= irq_desc
+ irq
;
75 spin_lock_irqsave(&desc
->lock
, flags
);
78 spin_unlock_irqrestore(&desc
->lock
, flags
);
83 * eeh_disable_irq - disable interrupt for the recovering device
85 static void eeh_disable_irq(struct pci_dev
*dev
)
87 struct device_node
*dn
= pci_device_to_OF_node(dev
);
89 /* Don't disable MSI and MSI-X interrupts. They are
90 * effectively disabled by the DMA Stopped state
91 * when an EEH error occurs.
93 if (dev
->msi_enabled
|| dev
->msix_enabled
)
96 if (!irq_in_use(dev
->irq
))
99 PCI_DN(dn
)->eeh_mode
|= EEH_MODE_IRQ_DISABLED
;
100 disable_irq_nosync(dev
->irq
);
104 * eeh_enable_irq - enable interrupt for the recovering device
106 static void eeh_enable_irq(struct pci_dev
*dev
)
108 struct device_node
*dn
= pci_device_to_OF_node(dev
);
110 if ((PCI_DN(dn
)->eeh_mode
) & EEH_MODE_IRQ_DISABLED
) {
111 PCI_DN(dn
)->eeh_mode
&= ~EEH_MODE_IRQ_DISABLED
;
112 enable_irq(dev
->irq
);
116 /* ------------------------------------------------------- */
118 * eeh_report_error - report pci error to each device driver
120 * Report an EEH error to each device driver, collect up and
121 * merge the device driver responses. Cumulative response
122 * passed back in "userdata".
125 static void eeh_report_error(struct pci_dev
*dev
, void *userdata
)
127 enum pci_ers_result rc
, *res
= userdata
;
128 struct pci_driver
*driver
= dev
->driver
;
130 dev
->error_state
= pci_channel_io_frozen
;
135 eeh_disable_irq(dev
);
137 if (!driver
->err_handler
||
138 !driver
->err_handler
->error_detected
)
141 rc
= driver
->err_handler
->error_detected (dev
, pci_channel_io_frozen
);
143 /* A driver that needs a reset trumps all others */
144 if (rc
== PCI_ERS_RESULT_NEED_RESET
) *res
= rc
;
145 if (*res
== PCI_ERS_RESULT_NONE
) *res
= rc
;
149 * eeh_report_mmio_enabled - tell drivers that MMIO has been enabled
151 * Tells each device driver that IO ports, MMIO and config space I/O
152 * are now enabled. Collects up and merges the device driver responses.
153 * Cumulative response passed back in "userdata".
156 static void eeh_report_mmio_enabled(struct pci_dev
*dev
, void *userdata
)
158 enum pci_ers_result rc
, *res
= userdata
;
159 struct pci_driver
*driver
= dev
->driver
;
162 !driver
->err_handler
||
163 !driver
->err_handler
->mmio_enabled
)
166 rc
= driver
->err_handler
->mmio_enabled (dev
);
168 /* A driver that needs a reset trumps all others */
169 if (rc
== PCI_ERS_RESULT_NEED_RESET
) *res
= rc
;
170 if (*res
== PCI_ERS_RESULT_NONE
) *res
= rc
;
174 * eeh_report_reset - tell device that slot has been reset
177 static void eeh_report_reset(struct pci_dev
*dev
, void *userdata
)
179 enum pci_ers_result rc
, *res
= userdata
;
180 struct pci_driver
*driver
= dev
->driver
;
187 if (!driver
->err_handler
||
188 !driver
->err_handler
->slot_reset
)
191 rc
= driver
->err_handler
->slot_reset(dev
);
192 if ((*res
== PCI_ERS_RESULT_NONE
) ||
193 (*res
== PCI_ERS_RESULT_RECOVERED
)) *res
= rc
;
194 if (*res
== PCI_ERS_RESULT_DISCONNECT
&&
195 rc
== PCI_ERS_RESULT_NEED_RESET
) *res
= rc
;
199 * eeh_report_resume - tell device to resume normal operations
202 static void eeh_report_resume(struct pci_dev
*dev
, void *userdata
)
204 struct pci_driver
*driver
= dev
->driver
;
206 dev
->error_state
= pci_channel_io_normal
;
213 if (!driver
->err_handler
||
214 !driver
->err_handler
->resume
)
217 driver
->err_handler
->resume(dev
);
221 * eeh_report_failure - tell device driver that device is dead.
223 * This informs the device driver that the device is permanently
224 * dead, and that no further recovery attempts will be made on it.
227 static void eeh_report_failure(struct pci_dev
*dev
, void *userdata
)
229 struct pci_driver
*driver
= dev
->driver
;
231 dev
->error_state
= pci_channel_io_perm_failure
;
236 eeh_disable_irq(dev
);
238 if (!driver
->err_handler
||
239 !driver
->err_handler
->error_detected
)
242 driver
->err_handler
->error_detected(dev
, pci_channel_io_perm_failure
);
245 /* ------------------------------------------------------- */
247 * handle_eeh_events -- reset a PCI device after hard lockup.
249 * pSeries systems will isolate a PCI slot if the PCI-Host
250 * bridge detects address or data parity errors, DMA's
251 * occurring to wild addresses (which usually happen due to
252 * bugs in device drivers or in PCI adapter firmware).
253 * Slot isolations also occur if #SERR, #PERR or other misc
254 * PCI-related errors are detected.
256 * Recovery process consists of unplugging the device driver
257 * (which generated hotplug events to userspace), then issuing
258 * a PCI #RST to the device, then reconfiguring the PCI config
259 * space for all bridges & devices under this slot, and then
260 * finally restarting the device drivers (which cause a second
261 * set of hotplug events to go out to userspace).
265 * eeh_reset_device() -- perform actual reset of a pci slot
266 * @bus: pointer to the pci bus structure corresponding
267 * to the isolated slot. A non-null value will
268 * cause all devices under the bus to be removed
270 * @pe_dn: pointer to a "Partionable Endpoint" device node.
271 * This is the top-level structure on which pci
272 * bus resets can be performed.
275 static int eeh_reset_device (struct pci_dn
*pe_dn
, struct pci_bus
*bus
)
277 struct device_node
*dn
;
280 /* pcibios will clear the counter; save the value */
281 cnt
= pe_dn
->eeh_freeze_count
;
284 pcibios_remove_pci_devices(bus
);
286 /* Reset the pci controller. (Asserts RST#; resets config space).
287 * Reconfigure bridges and devices. Don't try to bring the system
288 * up if the reset failed for some reason. */
289 rc
= rtas_set_slot_reset(pe_dn
);
293 /* Walk over all functions on this device. */
295 if (!pcibios_find_pci_bus(dn
) && PCI_DN(dn
->parent
))
296 dn
= dn
->parent
->child
;
299 struct pci_dn
*ppe
= PCI_DN(dn
);
300 /* On Power4, always true because eeh_pe_config_addr=0 */
301 if (pe_dn
->eeh_pe_config_addr
== ppe
->eeh_pe_config_addr
) {
302 rtas_configure_bridge(ppe
);
303 eeh_restore_bars(ppe
);
308 /* Give the system 5 seconds to finish running the user-space
309 * hotplug shutdown scripts, e.g. ifdown for ethernet. Yes,
310 * this is a hack, but if we don't do this, and try to bring
311 * the device up before the scripts have taken it down,
312 * potentially weird things happen.
316 pcibios_add_pci_devices(bus
);
318 pe_dn
->eeh_freeze_count
= cnt
;
323 /* The longest amount of time to wait for a pci device
324 * to come back on line, in seconds.
326 #define MAX_WAIT_FOR_RECOVERY 150
328 struct pci_dn
* handle_eeh_events (struct eeh_event
*event
)
330 struct device_node
*frozen_dn
;
331 struct pci_dn
*frozen_pdn
;
332 struct pci_bus
*frozen_bus
;
334 enum pci_ers_result result
= PCI_ERS_RESULT_NONE
;
335 const char *location
, *pci_str
, *drv_str
;
337 frozen_dn
= find_device_pe(event
->dn
);
340 location
= of_get_property(event
->dn
, "ibm,loc-code", NULL
);
341 location
= location
? location
: "unknown";
342 printk(KERN_ERR
"EEH: Error: Cannot find partition endpoint "
343 "for location=%s pci addr=%s\n",
344 location
, pci_name(event
->dev
));
348 frozen_bus
= pcibios_find_pci_bus(frozen_dn
);
349 location
= of_get_property(frozen_dn
, "ibm,loc-code", NULL
);
350 location
= location
? location
: "unknown";
352 /* There are two different styles for coming up with the PE.
353 * In the old style, it was the highest EEH-capable device
354 * which was always an EADS pci bridge. In the new style,
355 * there might not be any EADS bridges, and even when there are,
356 * the firmware marks them as "EEH incapable". So another
357 * two-step is needed to find the pci bus.. */
359 frozen_bus
= pcibios_find_pci_bus (frozen_dn
->parent
);
362 printk(KERN_ERR
"EEH: Cannot find PCI bus "
363 "for location=%s dn=%s\n",
364 location
, frozen_dn
->full_name
);
368 frozen_pdn
= PCI_DN(frozen_dn
);
369 frozen_pdn
->eeh_freeze_count
++;
371 if (frozen_pdn
->pcidev
) {
372 pci_str
= pci_name (frozen_pdn
->pcidev
);
373 drv_str
= pcid_name (frozen_pdn
->pcidev
);
375 pci_str
= pci_name (event
->dev
);
376 drv_str
= pcid_name (event
->dev
);
379 if (frozen_pdn
->eeh_freeze_count
> EEH_MAX_ALLOWED_FREEZES
)
380 goto excess_failures
;
383 "EEH: This PCI device has failed %d times in the last hour:\n",
384 frozen_pdn
->eeh_freeze_count
);
386 "EEH: location=%s driver=%s pci addr=%s\n",
387 location
, drv_str
, pci_str
);
389 /* Walk the various device drivers attached to this slot through
390 * a reset sequence, giving each an opportunity to do what it needs
391 * to accomplish the reset. Each child gets a report of the
392 * status ... if any child can't handle the reset, then the entire
393 * slot is dlpar removed and added.
395 pci_walk_bus(frozen_bus
, eeh_report_error
, &result
);
397 /* Get the current PCI slot state. This can take a long time,
398 * sometimes over 3 seconds for certain systems. */
399 rc
= eeh_wait_for_slot_status (frozen_pdn
, MAX_WAIT_FOR_RECOVERY
*1000);
401 printk(KERN_WARNING
"EEH: Permanent failure\n");
405 /* Since rtas may enable MMIO when posting the error log,
406 * don't post the error log until after all dev drivers
407 * have been informed.
409 eeh_slot_error_detail(frozen_pdn
, EEH_LOG_TEMP_FAILURE
);
411 /* If all device drivers were EEH-unaware, then shut
412 * down all of the device drivers, and hope they
413 * go down willingly, without panicing the system.
415 if (result
== PCI_ERS_RESULT_NONE
) {
416 rc
= eeh_reset_device(frozen_pdn
, frozen_bus
);
418 printk(KERN_WARNING
"EEH: Unable to reset, rc=%d\n", rc
);
423 /* If all devices reported they can proceed, then re-enable MMIO */
424 if (result
== PCI_ERS_RESULT_CAN_RECOVER
) {
425 rc
= rtas_pci_enable(frozen_pdn
, EEH_THAW_MMIO
);
430 result
= PCI_ERS_RESULT_NEED_RESET
;
432 result
= PCI_ERS_RESULT_NONE
;
433 pci_walk_bus(frozen_bus
, eeh_report_mmio_enabled
, &result
);
437 /* If all devices reported they can proceed, then re-enable DMA */
438 if (result
== PCI_ERS_RESULT_CAN_RECOVER
) {
439 rc
= rtas_pci_enable(frozen_pdn
, EEH_THAW_DMA
);
444 result
= PCI_ERS_RESULT_NEED_RESET
;
446 result
= PCI_ERS_RESULT_RECOVERED
;
449 /* If any device has a hard failure, then shut off everything. */
450 if (result
== PCI_ERS_RESULT_DISCONNECT
) {
451 printk(KERN_WARNING
"EEH: Device driver gave up\n");
455 /* If any device called out for a reset, then reset the slot */
456 if (result
== PCI_ERS_RESULT_NEED_RESET
) {
457 rc
= eeh_reset_device(frozen_pdn
, NULL
);
459 printk(KERN_WARNING
"EEH: Cannot reset, rc=%d\n", rc
);
462 result
= PCI_ERS_RESULT_NONE
;
463 pci_walk_bus(frozen_bus
, eeh_report_reset
, &result
);
466 /* All devices should claim they have recovered by now. */
467 if ((result
!= PCI_ERS_RESULT_RECOVERED
) &&
468 (result
!= PCI_ERS_RESULT_NONE
)) {
469 printk(KERN_WARNING
"EEH: Not recovered\n");
473 /* Tell all device drivers that they can resume operations */
474 pci_walk_bus(frozen_bus
, eeh_report_resume
, NULL
);
480 * About 90% of all real-life EEH failures in the field
481 * are due to poorly seated PCI cards. Only 10% or so are
482 * due to actual, failed cards.
485 "EEH: PCI device at location=%s driver=%s pci addr=%s \n"
486 "has failed %d times in the last hour "
487 "and has been permanently disabled. \n"
488 "Please try reseating this device or replacing it.\n",
489 location
, drv_str
, pci_str
, frozen_pdn
->eeh_freeze_count
);
494 "EEH: Unable to recover from failure of PCI device "
495 "at location=%s driver=%s pci addr=%s \n"
496 "Please try reseating this device or replacing it.\n",
497 location
, drv_str
, pci_str
);
500 eeh_slot_error_detail(frozen_pdn
, EEH_LOG_PERM_FAILURE
);
502 /* Notify all devices that they're about to go down. */
503 pci_walk_bus(frozen_bus
, eeh_report_failure
, NULL
);
505 /* Shut down the device drivers for good. */
506 pcibios_remove_pci_devices(frozen_bus
);
511 /* ---------- end of file ---------- */