2 * The file intends to implement the functions needed by EEH, which is
3 * built on IODA compliant chip. Actually, lots of functions related
4 * to EEH would be built based on the OPAL APIs.
6 * Copyright Benjamin Herrenschmidt & Gavin Shan, IBM Corporation 2013.
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
11 * (at your option) any later version.
14 #include <linux/debugfs.h>
15 #include <linux/delay.h>
17 #include <linux/irq.h>
18 #include <linux/kernel.h>
19 #include <linux/msi.h>
20 #include <linux/notifier.h>
21 #include <linux/pci.h>
22 #include <linux/string.h>
25 #include <asm/eeh_event.h>
27 #include <asm/iommu.h>
28 #include <asm/msi_bitmap.h>
30 #include <asm/pci-bridge.h>
31 #include <asm/ppc-pci.h>
37 static int ioda_eeh_nb_init
= 0;
39 static int ioda_eeh_event(struct notifier_block
*nb
,
40 unsigned long events
, void *change
)
42 uint64_t changed_evts
= (uint64_t)change
;
45 * We simply send special EEH event if EEH has
46 * been enabled, or clear pending events in
47 * case that we enable EEH soon
49 if (!(changed_evts
& OPAL_EVENT_PCI_ERROR
) ||
50 !(events
& OPAL_EVENT_PCI_ERROR
))
54 eeh_send_failure_event(NULL
);
56 opal_notifier_update_evt(OPAL_EVENT_PCI_ERROR
, 0x0ul
);
61 static struct notifier_block ioda_eeh_nb
= {
62 .notifier_call
= ioda_eeh_event
,
67 #ifdef CONFIG_DEBUG_FS
68 static ssize_t
ioda_eeh_ei_write(struct file
*filp
,
69 const char __user
*user_buf
,
70 size_t count
, loff_t
*ppos
)
72 struct pci_controller
*hose
= filp
->private_data
;
73 struct pnv_phb
*phb
= hose
->private_data
;
76 int pe_no
, type
, func
;
77 unsigned long addr
, mask
;
81 if (!phb
->eeh_ops
|| !phb
->eeh_ops
->err_inject
)
84 ret
= simple_write_to_buffer(buf
, sizeof(buf
), ppos
, user_buf
, count
);
88 /* Retrieve parameters */
89 ret
= sscanf(buf
, "%x:%x:%x:%lx:%lx",
90 &pe_no
, &type
, &func
, &addr
, &mask
);
95 edev
= kzalloc(sizeof(*edev
), GFP_KERNEL
);
99 edev
->pe_config_addr
= pe_no
;
100 pe
= eeh_pe_get(edev
);
105 /* Do error injection */
106 ret
= phb
->eeh_ops
->err_inject(pe
, type
, func
, addr
, mask
);
107 return ret
< 0 ? ret
: count
;
110 static const struct file_operations ioda_eeh_ei_fops
= {
113 .write
= ioda_eeh_ei_write
,
116 static int ioda_eeh_dbgfs_set(void *data
, int offset
, u64 val
)
118 struct pci_controller
*hose
= data
;
119 struct pnv_phb
*phb
= hose
->private_data
;
121 out_be64(phb
->regs
+ offset
, val
);
125 static int ioda_eeh_dbgfs_get(void *data
, int offset
, u64
*val
)
127 struct pci_controller
*hose
= data
;
128 struct pnv_phb
*phb
= hose
->private_data
;
130 *val
= in_be64(phb
->regs
+ offset
);
134 static int ioda_eeh_outb_dbgfs_set(void *data
, u64 val
)
136 return ioda_eeh_dbgfs_set(data
, 0xD10, val
);
139 static int ioda_eeh_outb_dbgfs_get(void *data
, u64
*val
)
141 return ioda_eeh_dbgfs_get(data
, 0xD10, val
);
144 static int ioda_eeh_inbA_dbgfs_set(void *data
, u64 val
)
146 return ioda_eeh_dbgfs_set(data
, 0xD90, val
);
149 static int ioda_eeh_inbA_dbgfs_get(void *data
, u64
*val
)
151 return ioda_eeh_dbgfs_get(data
, 0xD90, val
);
154 static int ioda_eeh_inbB_dbgfs_set(void *data
, u64 val
)
156 return ioda_eeh_dbgfs_set(data
, 0xE10, val
);
159 static int ioda_eeh_inbB_dbgfs_get(void *data
, u64
*val
)
161 return ioda_eeh_dbgfs_get(data
, 0xE10, val
);
164 DEFINE_SIMPLE_ATTRIBUTE(ioda_eeh_outb_dbgfs_ops
, ioda_eeh_outb_dbgfs_get
,
165 ioda_eeh_outb_dbgfs_set
, "0x%llx\n");
166 DEFINE_SIMPLE_ATTRIBUTE(ioda_eeh_inbA_dbgfs_ops
, ioda_eeh_inbA_dbgfs_get
,
167 ioda_eeh_inbA_dbgfs_set
, "0x%llx\n");
168 DEFINE_SIMPLE_ATTRIBUTE(ioda_eeh_inbB_dbgfs_ops
, ioda_eeh_inbB_dbgfs_get
,
169 ioda_eeh_inbB_dbgfs_set
, "0x%llx\n");
170 #endif /* CONFIG_DEBUG_FS */
174 * ioda_eeh_post_init - Chip dependent post initialization
175 * @hose: PCI controller
177 * The function will be called after eeh PEs and devices
178 * have been built. That means the EEH is ready to supply
179 * service with I/O cache.
181 static int ioda_eeh_post_init(struct pci_controller
*hose
)
183 struct pnv_phb
*phb
= hose
->private_data
;
186 /* Register OPAL event notifier */
187 if (!ioda_eeh_nb_init
) {
188 ret
= opal_notifier_register(&ioda_eeh_nb
);
190 pr_err("%s: Can't register OPAL event notifier (%d)\n",
195 ioda_eeh_nb_init
= 1;
198 #ifdef CONFIG_DEBUG_FS
199 if (!phb
->has_dbgfs
&& phb
->dbgfs
) {
202 debugfs_create_file("err_injct", 0200,
206 debugfs_create_file("err_injct_outbound", 0600,
208 &ioda_eeh_outb_dbgfs_ops
);
209 debugfs_create_file("err_injct_inboundA", 0600,
211 &ioda_eeh_inbA_dbgfs_ops
);
212 debugfs_create_file("err_injct_inboundB", 0600,
214 &ioda_eeh_inbB_dbgfs_ops
);
218 /* If EEH is enabled, we're going to rely on that.
219 * Otherwise, we restore to conventional mechanism
220 * to clear frozen PE during PCI config access.
223 phb
->flags
|= PNV_PHB_FLAG_EEH
;
225 phb
->flags
&= ~PNV_PHB_FLAG_EEH
;
231 * ioda_eeh_set_option - Set EEH operation or I/O setting
235 * Enable or disable EEH option for the indicated PE. The
236 * function also can be used to enable I/O or DMA for the
239 static int ioda_eeh_set_option(struct eeh_pe
*pe
, int option
)
241 struct pci_controller
*hose
= pe
->phb
;
242 struct pnv_phb
*phb
= hose
->private_data
;
243 bool freeze_pe
= false;
247 /* Check on PE number */
248 if (pe
->addr
< 0 || pe
->addr
>= phb
->ioda
.total_pe
) {
249 pr_err("%s: PE address %x out of range [0, %x] "
251 __func__
, pe
->addr
, phb
->ioda
.total_pe
,
252 hose
->global_number
);
257 case EEH_OPT_DISABLE
:
261 case EEH_OPT_THAW_MMIO
:
262 enable
= OPAL_EEH_ACTION_CLEAR_FREEZE_MMIO
;
264 case EEH_OPT_THAW_DMA
:
265 enable
= OPAL_EEH_ACTION_CLEAR_FREEZE_DMA
;
267 case EEH_OPT_FREEZE_PE
:
269 enable
= OPAL_EEH_ACTION_SET_FREEZE_ALL
;
272 pr_warn("%s: Invalid option %d\n",
277 /* If PHB supports compound PE, to handle it */
279 if (phb
->freeze_pe
) {
280 phb
->freeze_pe(phb
, pe
->addr
);
282 rc
= opal_pci_eeh_freeze_set(phb
->opal_id
,
285 if (rc
!= OPAL_SUCCESS
) {
286 pr_warn("%s: Failure %lld freezing "
289 phb
->hose
->global_number
, pe
->addr
);
294 if (phb
->unfreeze_pe
) {
295 ret
= phb
->unfreeze_pe(phb
, pe
->addr
, enable
);
297 rc
= opal_pci_eeh_freeze_clear(phb
->opal_id
,
300 if (rc
!= OPAL_SUCCESS
) {
301 pr_warn("%s: Failure %lld enable %d "
302 "for PHB#%x-PE#%x\n",
303 __func__
, rc
, option
,
304 phb
->hose
->global_number
, pe
->addr
);
313 static void ioda_eeh_phb_diag(struct eeh_pe
*pe
)
315 struct pnv_phb
*phb
= pe
->phb
->private_data
;
318 rc
= opal_pci_get_phb_diag_data2(phb
->opal_id
, pe
->data
,
319 PNV_PCI_DIAG_BUF_SIZE
);
320 if (rc
!= OPAL_SUCCESS
)
321 pr_warn("%s: Failed to get diag-data for PHB#%x (%ld)\n",
322 __func__
, pe
->phb
->global_number
, rc
);
325 static int ioda_eeh_get_phb_state(struct eeh_pe
*pe
)
327 struct pnv_phb
*phb
= pe
->phb
->private_data
;
333 rc
= opal_pci_eeh_freeze_status(phb
->opal_id
,
338 if (rc
!= OPAL_SUCCESS
) {
339 pr_warn("%s: Failure %lld getting PHB#%x state\n",
340 __func__
, rc
, phb
->hose
->global_number
);
341 return EEH_STATE_NOT_SUPPORT
;
345 * Check PHB state. If the PHB is frozen for the
346 * first time, to dump the PHB diag-data.
348 if (be16_to_cpu(pcierr
) != OPAL_EEH_PHB_ERROR
) {
349 result
= (EEH_STATE_MMIO_ACTIVE
|
350 EEH_STATE_DMA_ACTIVE
|
351 EEH_STATE_MMIO_ENABLED
|
352 EEH_STATE_DMA_ENABLED
);
353 } else if (!(pe
->state
& EEH_PE_ISOLATED
)) {
354 eeh_pe_state_mark(pe
, EEH_PE_ISOLATED
);
355 ioda_eeh_phb_diag(pe
);
361 static int ioda_eeh_get_pe_state(struct eeh_pe
*pe
)
363 struct pnv_phb
*phb
= pe
->phb
->private_data
;
370 * We don't clobber hardware frozen state until PE
371 * reset is completed. In order to keep EEH core
372 * moving forward, we have to return operational
373 * state during PE reset.
375 if (pe
->state
& EEH_PE_RESET
) {
376 result
= (EEH_STATE_MMIO_ACTIVE
|
377 EEH_STATE_DMA_ACTIVE
|
378 EEH_STATE_MMIO_ENABLED
|
379 EEH_STATE_DMA_ENABLED
);
384 * Fetch PE state from hardware. If the PHB
385 * supports compound PE, let it handle that.
387 if (phb
->get_pe_state
) {
388 fstate
= phb
->get_pe_state(phb
, pe
->addr
);
390 rc
= opal_pci_eeh_freeze_status(phb
->opal_id
,
395 if (rc
!= OPAL_SUCCESS
) {
396 pr_warn("%s: Failure %lld getting PHB#%x-PE%x state\n",
397 __func__
, rc
, phb
->hose
->global_number
, pe
->addr
);
398 return EEH_STATE_NOT_SUPPORT
;
402 /* Figure out state */
404 case OPAL_EEH_STOPPED_NOT_FROZEN
:
405 result
= (EEH_STATE_MMIO_ACTIVE
|
406 EEH_STATE_DMA_ACTIVE
|
407 EEH_STATE_MMIO_ENABLED
|
408 EEH_STATE_DMA_ENABLED
);
410 case OPAL_EEH_STOPPED_MMIO_FREEZE
:
411 result
= (EEH_STATE_DMA_ACTIVE
|
412 EEH_STATE_DMA_ENABLED
);
414 case OPAL_EEH_STOPPED_DMA_FREEZE
:
415 result
= (EEH_STATE_MMIO_ACTIVE
|
416 EEH_STATE_MMIO_ENABLED
);
418 case OPAL_EEH_STOPPED_MMIO_DMA_FREEZE
:
421 case OPAL_EEH_STOPPED_RESET
:
422 result
= EEH_STATE_RESET_ACTIVE
;
424 case OPAL_EEH_STOPPED_TEMP_UNAVAIL
:
425 result
= EEH_STATE_UNAVAILABLE
;
427 case OPAL_EEH_STOPPED_PERM_UNAVAIL
:
428 result
= EEH_STATE_NOT_SUPPORT
;
431 result
= EEH_STATE_NOT_SUPPORT
;
432 pr_warn("%s: Invalid PHB#%x-PE#%x state %x\n",
433 __func__
, phb
->hose
->global_number
,
438 * If PHB supports compound PE, to freeze all
439 * slave PEs for consistency.
441 * If the PE is switching to frozen state for the
442 * first time, to dump the PHB diag-data.
444 if (!(result
& EEH_STATE_NOT_SUPPORT
) &&
445 !(result
& EEH_STATE_UNAVAILABLE
) &&
446 !(result
& EEH_STATE_MMIO_ACTIVE
) &&
447 !(result
& EEH_STATE_DMA_ACTIVE
) &&
448 !(pe
->state
& EEH_PE_ISOLATED
)) {
450 phb
->freeze_pe(phb
, pe
->addr
);
452 eeh_pe_state_mark(pe
, EEH_PE_ISOLATED
);
453 ioda_eeh_phb_diag(pe
);
460 * ioda_eeh_get_state - Retrieve the state of PE
463 * The PE's state should be retrieved from the PEEV, PEST
464 * IODA tables. Since the OPAL has exported the function
465 * to do it, it'd better to use that.
467 static int ioda_eeh_get_state(struct eeh_pe
*pe
)
469 struct pnv_phb
*phb
= pe
->phb
->private_data
;
471 /* Sanity check on PE number. PHB PE should have 0 */
473 pe
->addr
>= phb
->ioda
.total_pe
) {
474 pr_warn("%s: PHB#%x-PE#%x out of range [0, %x]\n",
475 __func__
, phb
->hose
->global_number
,
476 pe
->addr
, phb
->ioda
.total_pe
);
477 return EEH_STATE_NOT_SUPPORT
;
480 if (pe
->type
& EEH_PE_PHB
)
481 return ioda_eeh_get_phb_state(pe
);
483 return ioda_eeh_get_pe_state(pe
);
486 static s64
ioda_eeh_phb_poll(struct pnv_phb
*phb
)
488 s64 rc
= OPAL_HARDWARE
;
491 rc
= opal_pci_poll(phb
->opal_id
);
495 if (system_state
< SYSTEM_RUNNING
)
504 int ioda_eeh_phb_reset(struct pci_controller
*hose
, int option
)
506 struct pnv_phb
*phb
= hose
->private_data
;
507 s64 rc
= OPAL_HARDWARE
;
509 pr_debug("%s: Reset PHB#%x, option=%d\n",
510 __func__
, hose
->global_number
, option
);
512 /* Issue PHB complete reset request */
513 if (option
== EEH_RESET_FUNDAMENTAL
||
514 option
== EEH_RESET_HOT
)
515 rc
= opal_pci_reset(phb
->opal_id
,
516 OPAL_RESET_PHB_COMPLETE
,
518 else if (option
== EEH_RESET_DEACTIVATE
)
519 rc
= opal_pci_reset(phb
->opal_id
,
520 OPAL_RESET_PHB_COMPLETE
,
521 OPAL_DEASSERT_RESET
);
526 * Poll state of the PHB until the request is done
527 * successfully. The PHB reset is usually PHB complete
528 * reset followed by hot reset on root bus. So we also
529 * need the PCI bus settlement delay.
531 rc
= ioda_eeh_phb_poll(phb
);
532 if (option
== EEH_RESET_DEACTIVATE
) {
533 if (system_state
< SYSTEM_RUNNING
)
534 udelay(1000 * EEH_PE_RST_SETTLE_TIME
);
536 msleep(EEH_PE_RST_SETTLE_TIME
);
539 if (rc
!= OPAL_SUCCESS
)
545 static int ioda_eeh_root_reset(struct pci_controller
*hose
, int option
)
547 struct pnv_phb
*phb
= hose
->private_data
;
548 s64 rc
= OPAL_SUCCESS
;
550 pr_debug("%s: Reset PHB#%x, option=%d\n",
551 __func__
, hose
->global_number
, option
);
554 * During the reset deassert time, we needn't care
555 * the reset scope because the firmware does nothing
556 * for fundamental or hot reset during deassert phase.
558 if (option
== EEH_RESET_FUNDAMENTAL
)
559 rc
= opal_pci_reset(phb
->opal_id
,
560 OPAL_RESET_PCI_FUNDAMENTAL
,
562 else if (option
== EEH_RESET_HOT
)
563 rc
= opal_pci_reset(phb
->opal_id
,
566 else if (option
== EEH_RESET_DEACTIVATE
)
567 rc
= opal_pci_reset(phb
->opal_id
,
569 OPAL_DEASSERT_RESET
);
573 /* Poll state of the PHB until the request is done */
574 rc
= ioda_eeh_phb_poll(phb
);
575 if (option
== EEH_RESET_DEACTIVATE
)
576 msleep(EEH_PE_RST_SETTLE_TIME
);
578 if (rc
!= OPAL_SUCCESS
)
584 static int ioda_eeh_bridge_reset(struct pci_dev
*dev
, int option
)
587 struct device_node
*dn
= pci_device_to_OF_node(dev
);
588 struct eeh_dev
*edev
= of_node_to_eeh_dev(dn
);
589 int aer
= edev
? edev
->aer_cap
: 0;
592 pr_debug("%s: Reset PCI bus %04x:%02x with option %d\n",
593 __func__
, pci_domain_nr(dev
->bus
),
594 dev
->bus
->number
, option
);
597 case EEH_RESET_FUNDAMENTAL
:
599 /* Don't report linkDown event */
601 eeh_ops
->read_config(dn
, aer
+ PCI_ERR_UNCOR_MASK
,
603 ctrl
|= PCI_ERR_UNC_SURPDN
;
604 eeh_ops
->write_config(dn
, aer
+ PCI_ERR_UNCOR_MASK
,
608 eeh_ops
->read_config(dn
, PCI_BRIDGE_CONTROL
, 2, &ctrl
);
609 ctrl
|= PCI_BRIDGE_CTL_BUS_RESET
;
610 eeh_ops
->write_config(dn
, PCI_BRIDGE_CONTROL
, 2, ctrl
);
611 msleep(EEH_PE_RST_HOLD_TIME
);
614 case EEH_RESET_DEACTIVATE
:
615 eeh_ops
->read_config(dn
, PCI_BRIDGE_CONTROL
, 2, &ctrl
);
616 ctrl
&= ~PCI_BRIDGE_CTL_BUS_RESET
;
617 eeh_ops
->write_config(dn
, PCI_BRIDGE_CONTROL
, 2, ctrl
);
618 msleep(EEH_PE_RST_SETTLE_TIME
);
620 /* Continue reporting linkDown event */
622 eeh_ops
->read_config(dn
, aer
+ PCI_ERR_UNCOR_MASK
,
624 ctrl
&= ~PCI_ERR_UNC_SURPDN
;
625 eeh_ops
->write_config(dn
, aer
+ PCI_ERR_UNCOR_MASK
,
635 void pnv_pci_reset_secondary_bus(struct pci_dev
*dev
)
637 struct pci_controller
*hose
;
639 if (pci_is_root_bus(dev
->bus
)) {
640 hose
= pci_bus_to_host(dev
->bus
);
641 ioda_eeh_root_reset(hose
, EEH_RESET_HOT
);
642 ioda_eeh_root_reset(hose
, EEH_RESET_DEACTIVATE
);
644 ioda_eeh_bridge_reset(dev
, EEH_RESET_HOT
);
645 ioda_eeh_bridge_reset(dev
, EEH_RESET_DEACTIVATE
);
650 * ioda_eeh_reset - Reset the indicated PE
652 * @option: reset option
654 * Do reset on the indicated PE. For PCI bus sensitive PE,
655 * we need to reset the parent p2p bridge. The PHB has to
656 * be reinitialized if the p2p bridge is root bridge. For
657 * PCI device sensitive PE, we will try to reset the device
658 * through FLR. For now, we don't have OPAL APIs to do HARD
659 * reset yet, so all reset would be SOFT (HOT) reset.
661 static int ioda_eeh_reset(struct eeh_pe
*pe
, int option
)
663 struct pci_controller
*hose
= pe
->phb
;
668 * For PHB reset, we always have complete reset. For those PEs whose
669 * primary bus derived from root complex (root bus) or root port
670 * (usually bus#1), we apply hot or fundamental reset on the root port.
671 * For other PEs, we always have hot reset on the PE primary bus.
673 * Here, we have different design to pHyp, which always clear the
674 * frozen state during PE reset. However, the good idea here from
675 * benh is to keep frozen state before we get PE reset done completely
676 * (until BAR restore). With the frozen state, HW drops illegal IO
677 * or MMIO access, which can incur recrusive frozen PE during PE
678 * reset. The side effect is that EEH core has to clear the frozen
679 * state explicitly after BAR restore.
681 if (pe
->type
& EEH_PE_PHB
) {
682 ret
= ioda_eeh_phb_reset(hose
, option
);
688 * The frozen PE might be caused by PAPR error injection
689 * registers, which are expected to be cleared after hitting
690 * frozen PE as stated in the hardware spec. Unfortunately,
691 * that's not true on P7IOC. So we have to clear it manually
692 * to avoid recursive EEH errors during recovery.
694 phb
= hose
->private_data
;
695 if (phb
->model
== PNV_PHB_MODEL_P7IOC
&&
696 (option
== EEH_RESET_HOT
||
697 option
== EEH_RESET_FUNDAMENTAL
)) {
698 rc
= opal_pci_reset(phb
->opal_id
,
699 OPAL_RESET_PHB_ERROR
,
701 if (rc
!= OPAL_SUCCESS
) {
702 pr_warn("%s: Failure %lld clearing "
703 "error injection registers\n",
709 bus
= eeh_pe_bus_get(pe
);
710 if (pci_is_root_bus(bus
) ||
711 pci_is_root_bus(bus
->parent
))
712 ret
= ioda_eeh_root_reset(hose
, option
);
714 ret
= ioda_eeh_bridge_reset(bus
->self
, option
);
721 * ioda_eeh_get_log - Retrieve error log
723 * @severity: permanent or temporary error
724 * @drv_log: device driver log
725 * @len: length of device driver log
727 * Retrieve error log, which contains log from device driver
730 static int ioda_eeh_get_log(struct eeh_pe
*pe
, int severity
,
731 char *drv_log
, unsigned long len
)
733 pnv_pci_dump_phb_diag_data(pe
->phb
, pe
->data
);
739 * ioda_eeh_configure_bridge - Configure the PCI bridges for the indicated PE
742 * For particular PE, it might have included PCI bridges. In order
743 * to make the PE work properly, those PCI bridges should be configured
744 * correctly. However, we need do nothing on P7IOC since the reset
745 * function will do everything that should be covered by the function.
747 static int ioda_eeh_configure_bridge(struct eeh_pe
*pe
)
752 static int ioda_eeh_err_inject(struct eeh_pe
*pe
, int type
, int func
,
753 unsigned long addr
, unsigned long mask
)
755 struct pci_controller
*hose
= pe
->phb
;
756 struct pnv_phb
*phb
= hose
->private_data
;
759 /* Sanity check on error type */
760 if (type
!= OPAL_ERR_INJECT_TYPE_IOA_BUS_ERR
&&
761 type
!= OPAL_ERR_INJECT_TYPE_IOA_BUS_ERR64
) {
762 pr_warn("%s: Invalid error type %d\n",
767 if (func
< OPAL_ERR_INJECT_FUNC_IOA_LD_MEM_ADDR
||
768 func
> OPAL_ERR_INJECT_FUNC_IOA_DMA_WR_TARGET
) {
769 pr_warn("%s: Invalid error function %d\n",
774 /* Firmware supports error injection ? */
775 if (!opal_check_token(OPAL_PCI_ERR_INJECT
)) {
776 pr_warn("%s: Firmware doesn't support error injection\n",
781 /* Do error injection */
782 ret
= opal_pci_err_inject(phb
->opal_id
, pe
->addr
,
783 type
, func
, addr
, mask
);
784 if (ret
!= OPAL_SUCCESS
) {
785 pr_warn("%s: Failure %lld injecting error "
786 "%d-%d to PHB#%x-PE#%x\n",
787 __func__
, ret
, type
, func
,
788 hose
->global_number
, pe
->addr
);
795 static void ioda_eeh_hub_diag_common(struct OpalIoP7IOCErrorData
*data
)
798 if (data
->gemXfir
|| data
->gemRfir
||
799 data
->gemRirqfir
|| data
->gemMask
|| data
->gemRwof
)
800 pr_info(" GEM: %016llx %016llx %016llx %016llx %016llx\n",
801 be64_to_cpu(data
->gemXfir
),
802 be64_to_cpu(data
->gemRfir
),
803 be64_to_cpu(data
->gemRirqfir
),
804 be64_to_cpu(data
->gemMask
),
805 be64_to_cpu(data
->gemRwof
));
808 if (data
->lemFir
|| data
->lemErrMask
||
809 data
->lemAction0
|| data
->lemAction1
|| data
->lemWof
)
810 pr_info(" LEM: %016llx %016llx %016llx %016llx %016llx\n",
811 be64_to_cpu(data
->lemFir
),
812 be64_to_cpu(data
->lemErrMask
),
813 be64_to_cpu(data
->lemAction0
),
814 be64_to_cpu(data
->lemAction1
),
815 be64_to_cpu(data
->lemWof
));
818 static void ioda_eeh_hub_diag(struct pci_controller
*hose
)
820 struct pnv_phb
*phb
= hose
->private_data
;
821 struct OpalIoP7IOCErrorData
*data
= &phb
->diag
.hub_diag
;
824 rc
= opal_pci_get_hub_diag_data(phb
->hub_id
, data
, sizeof(*data
));
825 if (rc
!= OPAL_SUCCESS
) {
826 pr_warn("%s: Failed to get HUB#%llx diag-data (%ld)\n",
827 __func__
, phb
->hub_id
, rc
);
831 switch (data
->type
) {
832 case OPAL_P7IOC_DIAG_TYPE_RGC
:
833 pr_info("P7IOC diag-data for RGC\n\n");
834 ioda_eeh_hub_diag_common(data
);
835 if (data
->rgc
.rgcStatus
|| data
->rgc
.rgcLdcp
)
836 pr_info(" RGC: %016llx %016llx\n",
837 be64_to_cpu(data
->rgc
.rgcStatus
),
838 be64_to_cpu(data
->rgc
.rgcLdcp
));
840 case OPAL_P7IOC_DIAG_TYPE_BI
:
841 pr_info("P7IOC diag-data for BI %s\n\n",
842 data
->bi
.biDownbound
? "Downbound" : "Upbound");
843 ioda_eeh_hub_diag_common(data
);
844 if (data
->bi
.biLdcp0
|| data
->bi
.biLdcp1
||
845 data
->bi
.biLdcp2
|| data
->bi
.biFenceStatus
)
846 pr_info(" BI: %016llx %016llx %016llx %016llx\n",
847 be64_to_cpu(data
->bi
.biLdcp0
),
848 be64_to_cpu(data
->bi
.biLdcp1
),
849 be64_to_cpu(data
->bi
.biLdcp2
),
850 be64_to_cpu(data
->bi
.biFenceStatus
));
852 case OPAL_P7IOC_DIAG_TYPE_CI
:
853 pr_info("P7IOC diag-data for CI Port %d\n\n",
855 ioda_eeh_hub_diag_common(data
);
856 if (data
->ci
.ciPortStatus
|| data
->ci
.ciPortLdcp
)
857 pr_info(" CI: %016llx %016llx\n",
858 be64_to_cpu(data
->ci
.ciPortStatus
),
859 be64_to_cpu(data
->ci
.ciPortLdcp
));
861 case OPAL_P7IOC_DIAG_TYPE_MISC
:
862 pr_info("P7IOC diag-data for MISC\n\n");
863 ioda_eeh_hub_diag_common(data
);
865 case OPAL_P7IOC_DIAG_TYPE_I2C
:
866 pr_info("P7IOC diag-data for I2C\n\n");
867 ioda_eeh_hub_diag_common(data
);
870 pr_warn("%s: Invalid type of HUB#%llx diag-data (%d)\n",
871 __func__
, phb
->hub_id
, data
->type
);
875 static int ioda_eeh_get_pe(struct pci_controller
*hose
,
876 u16 pe_no
, struct eeh_pe
**pe
)
878 struct pnv_phb
*phb
= hose
->private_data
;
879 struct pnv_ioda_pe
*pnv_pe
;
880 struct eeh_pe
*dev_pe
;
884 * If PHB supports compound PE, to fetch
885 * the master PE because slave PE is invisible
888 pnv_pe
= &phb
->ioda
.pe_array
[pe_no
];
889 if (pnv_pe
->flags
& PNV_IODA_PE_SLAVE
) {
890 pnv_pe
= pnv_pe
->master
;
892 !(pnv_pe
->flags
& PNV_IODA_PE_MASTER
));
893 pe_no
= pnv_pe
->pe_number
;
896 /* Find the PE according to PE# */
897 memset(&edev
, 0, sizeof(struct eeh_dev
));
899 edev
.pe_config_addr
= pe_no
;
900 dev_pe
= eeh_pe_get(&edev
);
904 /* Freeze the (compound) PE */
906 if (!(dev_pe
->state
& EEH_PE_ISOLATED
))
907 phb
->freeze_pe(phb
, pe_no
);
910 * At this point, we're sure the (compound) PE should
911 * have been frozen. However, we still need poke until
912 * hitting the frozen PE on top level.
914 dev_pe
= dev_pe
->parent
;
915 while (dev_pe
&& !(dev_pe
->type
& EEH_PE_PHB
)) {
917 int active_flags
= (EEH_STATE_MMIO_ACTIVE
|
918 EEH_STATE_DMA_ACTIVE
);
920 ret
= eeh_ops
->get_state(dev_pe
, NULL
);
921 if (ret
<= 0 || (ret
& active_flags
) == active_flags
) {
922 dev_pe
= dev_pe
->parent
;
926 /* Frozen parent PE */
928 if (!(dev_pe
->state
& EEH_PE_ISOLATED
))
929 phb
->freeze_pe(phb
, dev_pe
->addr
);
932 dev_pe
= dev_pe
->parent
;
939 * ioda_eeh_next_error - Retrieve next error for EEH core to handle
940 * @pe: The affected PE
942 * The function is expected to be called by EEH core while it gets
943 * special EEH event (without binding PE). The function calls to
944 * OPAL APIs for next error to handle. The informational error is
945 * handled internally by platform. However, the dead IOC, dead PHB,
946 * fenced PHB and frozen PE should be handled by EEH core eventually.
948 static int ioda_eeh_next_error(struct eeh_pe
**pe
)
950 struct pci_controller
*hose
;
952 struct eeh_pe
*phb_pe
, *parent_pe
;
954 __be16 err_type
, severity
;
955 int active_flags
= (EEH_STATE_MMIO_ACTIVE
| EEH_STATE_DMA_ACTIVE
);
957 int state
, ret
= EEH_NEXT_ERR_NONE
;
960 * While running here, it's safe to purge the event queue.
961 * And we should keep the cached OPAL notifier event sychronized
962 * between the kernel and firmware.
964 eeh_remove_event(NULL
, false);
965 opal_notifier_update_evt(OPAL_EVENT_PCI_ERROR
, 0x0ul
);
967 list_for_each_entry(hose
, &hose_list
, list_node
) {
969 * If the subordinate PCI buses of the PHB has been
970 * removed or is exactly under error recovery, we
971 * needn't take care of it any more.
973 phb
= hose
->private_data
;
974 phb_pe
= eeh_phb_pe_get(hose
);
975 if (!phb_pe
|| (phb_pe
->state
& EEH_PE_ISOLATED
))
978 rc
= opal_pci_next_error(phb
->opal_id
,
979 &frozen_pe_no
, &err_type
, &severity
);
981 /* If OPAL API returns error, we needn't proceed */
982 if (rc
!= OPAL_SUCCESS
) {
983 pr_devel("%s: Invalid return value on "
984 "PHB#%x (0x%lx) from opal_pci_next_error",
985 __func__
, hose
->global_number
, rc
);
989 /* If the PHB doesn't have error, stop processing */
990 if (be16_to_cpu(err_type
) == OPAL_EEH_NO_ERROR
||
991 be16_to_cpu(severity
) == OPAL_EEH_SEV_NO_ERROR
) {
992 pr_devel("%s: No error found on PHB#%x\n",
993 __func__
, hose
->global_number
);
998 * Processing the error. We're expecting the error with
999 * highest priority reported upon multiple errors on the
1002 pr_devel("%s: Error (%d, %d, %llu) on PHB#%x\n",
1003 __func__
, be16_to_cpu(err_type
), be16_to_cpu(severity
),
1004 be64_to_cpu(frozen_pe_no
), hose
->global_number
);
1005 switch (be16_to_cpu(err_type
)) {
1006 case OPAL_EEH_IOC_ERROR
:
1007 if (be16_to_cpu(severity
) == OPAL_EEH_SEV_IOC_DEAD
) {
1008 pr_err("EEH: dead IOC detected\n");
1009 ret
= EEH_NEXT_ERR_DEAD_IOC
;
1010 } else if (be16_to_cpu(severity
) == OPAL_EEH_SEV_INF
) {
1011 pr_info("EEH: IOC informative error "
1013 ioda_eeh_hub_diag(hose
);
1014 ret
= EEH_NEXT_ERR_NONE
;
1018 case OPAL_EEH_PHB_ERROR
:
1019 if (be16_to_cpu(severity
) == OPAL_EEH_SEV_PHB_DEAD
) {
1021 pr_err("EEH: dead PHB#%x detected, "
1023 hose
->global_number
,
1024 eeh_pe_loc_get(phb_pe
));
1025 ret
= EEH_NEXT_ERR_DEAD_PHB
;
1026 } else if (be16_to_cpu(severity
) ==
1027 OPAL_EEH_SEV_PHB_FENCED
) {
1029 pr_err("EEH: Fenced PHB#%x detected, "
1031 hose
->global_number
,
1032 eeh_pe_loc_get(phb_pe
));
1033 ret
= EEH_NEXT_ERR_FENCED_PHB
;
1034 } else if (be16_to_cpu(severity
) == OPAL_EEH_SEV_INF
) {
1035 pr_info("EEH: PHB#%x informative error "
1036 "detected, location: %s\n",
1037 hose
->global_number
,
1038 eeh_pe_loc_get(phb_pe
));
1039 ioda_eeh_phb_diag(phb_pe
);
1040 pnv_pci_dump_phb_diag_data(hose
, phb_pe
->data
);
1041 ret
= EEH_NEXT_ERR_NONE
;
1045 case OPAL_EEH_PE_ERROR
:
1047 * If we can't find the corresponding PE, we
1048 * just try to unfreeze.
1050 if (ioda_eeh_get_pe(hose
,
1051 be64_to_cpu(frozen_pe_no
), pe
)) {
1052 /* Try best to clear it */
1053 pr_info("EEH: Clear non-existing PHB#%x-PE#%llx\n",
1054 hose
->global_number
, frozen_pe_no
);
1055 pr_info("EEH: PHB location: %s\n",
1056 eeh_pe_loc_get(phb_pe
));
1057 opal_pci_eeh_freeze_clear(phb
->opal_id
, frozen_pe_no
,
1058 OPAL_EEH_ACTION_CLEAR_FREEZE_ALL
);
1059 ret
= EEH_NEXT_ERR_NONE
;
1060 } else if ((*pe
)->state
& EEH_PE_ISOLATED
||
1061 eeh_pe_passed(*pe
)) {
1062 ret
= EEH_NEXT_ERR_NONE
;
1064 pr_err("EEH: Frozen PE#%x on PHB#%x detected\n",
1065 (*pe
)->addr
, (*pe
)->phb
->global_number
);
1066 pr_err("EEH: PE location: %s, PHB location: %s\n",
1067 eeh_pe_loc_get(*pe
), eeh_pe_loc_get(phb_pe
));
1068 ret
= EEH_NEXT_ERR_FROZEN_PE
;
1073 pr_warn("%s: Unexpected error type %d\n",
1074 __func__
, be16_to_cpu(err_type
));
1078 * EEH core will try recover from fenced PHB or
1079 * frozen PE. In the time for frozen PE, EEH core
1080 * enable IO path for that before collecting logs,
1081 * but it ruins the site. So we have to dump the
1082 * log in advance here.
1084 if ((ret
== EEH_NEXT_ERR_FROZEN_PE
||
1085 ret
== EEH_NEXT_ERR_FENCED_PHB
) &&
1086 !((*pe
)->state
& EEH_PE_ISOLATED
)) {
1087 eeh_pe_state_mark(*pe
, EEH_PE_ISOLATED
);
1088 ioda_eeh_phb_diag(*pe
);
1092 * We probably have the frozen parent PE out there and
1093 * we need have to handle frozen parent PE firstly.
1095 if (ret
== EEH_NEXT_ERR_FROZEN_PE
) {
1096 parent_pe
= (*pe
)->parent
;
1098 /* Hit the ceiling ? */
1099 if (parent_pe
->type
& EEH_PE_PHB
)
1102 /* Frozen parent PE ? */
1103 state
= ioda_eeh_get_state(parent_pe
);
1105 (state
& active_flags
) != active_flags
)
1108 /* Next parent level */
1109 parent_pe
= parent_pe
->parent
;
1112 /* We possibly migrate to another PE */
1113 eeh_pe_state_mark(*pe
, EEH_PE_ISOLATED
);
1117 * If we have no errors on the specific PHB or only
1118 * informative error there, we continue poking it.
1119 * Otherwise, we need actions to be taken by upper
1122 if (ret
> EEH_NEXT_ERR_INF
)
1129 struct pnv_eeh_ops ioda_eeh_ops
= {
1130 .post_init
= ioda_eeh_post_init
,
1131 .set_option
= ioda_eeh_set_option
,
1132 .get_state
= ioda_eeh_get_state
,
1133 .reset
= ioda_eeh_reset
,
1134 .get_log
= ioda_eeh_get_log
,
1135 .configure_bridge
= ioda_eeh_configure_bridge
,
1136 .err_inject
= ioda_eeh_err_inject
,
1137 .next_error
= ioda_eeh_next_error