PCI: brcmstb: Add panic/die handler to driver

Most PCIe HW returns 0xffffffff for failed reads on PCIe, but by default
Broadcom's STB PCIe controller effects an abort.  Some SoCs -- 7216 and its
descendants -- have new HW that identifies error details.

Add a simple handler to print diagnostic info in case the PCIe controller
was the cause of the abort.  Unfortunately, an abort still occurs.

Read the error registers only when the PCIe bridge is active and the PCIe
registers are accessible.  Otherwise, a "die" event caused by something
other than PCIe could cause an abort if the PCIe "die" handler tried to
access registers when the bridge is off.

Example error output:
  brcm-pcie 8b20000.pcie: Error: Mem Acc: 32bit, read, @0x38000000
  brcm-pcie 8b20000.pcie:  Type: TO=0 Abt=0 UnspReq=1 AccDsble=0 BadAddr=0

Signed-off-by: Jim Quinlan <james.quinlan@broadcom.com>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
Reviewed-by: Florian Fainelli <florian.fainelli@broadcom.com>
Link: https://patch.msgid.link/20251029193616.3670003-3-james.quinlan@broadcom.com

diff --git a/drivers/pci/controller/pcie-brcmstb.c b/drivers/pci/controller/pcie-brcmstb.c
index 53434f09ac3d33284664b9ddf139b7b60d1b5998..062f556900127ce8a186978d902d41e39567a660 100644 (file)
--- a/drivers/pci/controller/pcie-brcmstb.c
+++ b/drivers/pci/controller/pcie-brcmstb.c
@@ -14,15 +14,18 @@
 #include <linux/irqchip/chained_irq.h>
 #include <linux/irqchip/irq-msi-lib.h>
 #include <linux/irqdomain.h>
+#include <linux/kdebug.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/log2.h>
 #include <linux/module.h>
 #include <linux/msi.h>
+#include <linux/notifier.h>
 #include <linux/of_address.h>
 #include <linux/of_irq.h>
 #include <linux/of_pci.h>
 #include <linux/of_platform.h>
+#include <linux/panic_notifier.h>
 #include <linux/pci.h>
 #include <linux/pci-ecam.h>
 #include <linux/printk.h>
@@ -32,6 +35,7 @@
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/string.h>
+#include <linux/string_choices.h>
 #include <linux/types.h>
 
 #include "../pci.h"
@@ -155,8 +159,40 @@
 #define  MSI_INT_MASK_SET              0x10
 #define  MSI_INT_MASK_CLR              0x14
 
+/* Error report registers */
+#define PCIE_OUTB_ERR_TREAT                            0x6000
+#define  PCIE_OUTB_ERR_TREAT_CONFIG            0x1
+#define  PCIE_OUTB_ERR_TREAT_MEM                       0x2
+#define PCIE_OUTB_ERR_VALID                            0x6004
+#define PCIE_OUTB_ERR_CLEAR                            0x6008
+#define PCIE_OUTB_ERR_ACC_INFO                         0x600c
+#define  PCIE_OUTB_ERR_ACC_INFO_CFG_ERR                        BIT(0)
+#define  PCIE_OUTB_ERR_ACC_INFO_MEM_ERR                        BIT(1)
+#define  PCIE_OUTB_ERR_ACC_INFO_TYPE_64                        BIT(2)
+#define  PCIE_OUTB_ERR_ACC_INFO_DIR_WRITE              BIT(4)
+#define  PCIE_OUTB_ERR_ACC_INFO_BYTE_LANES             0xff00
+#define PCIE_OUTB_ERR_ACC_ADDR                         0x6010
+#define PCIE_OUTB_ERR_ACC_ADDR_BUS                     0xff00000
+#define PCIE_OUTB_ERR_ACC_ADDR_DEV                     0xf8000
+#define PCIE_OUTB_ERR_ACC_ADDR_FUNC                    0x7000
+#define PCIE_OUTB_ERR_ACC_ADDR_REG                     0xfff
+#define PCIE_OUTB_ERR_CFG_CAUSE                                0x6014
+#define  PCIE_OUTB_ERR_CFG_CAUSE_TIMEOUT               BIT(6)
+#define  PCIE_OUTB_ERR_CFG_CAUSE_ABORT                 BIT(5)
+#define  PCIE_OUTB_ERR_CFG_CAUSE_UNSUPP_REQ            BIT(4)
+#define  PCIE_OUTB_ERR_CFG_CAUSE_ACC_TIMEOUT           BIT(2)
+#define  PCIE_OUTB_ERR_CFG_CAUSE_ACC_DISABLED          BIT(1)
+#define  PCIE_OUTB_ERR_CFG_CAUSE_ACC_64BIT             BIT(0)
+#define PCIE_OUTB_ERR_MEM_ADDR_LO                      0x6018
+#define PCIE_OUTB_ERR_MEM_ADDR_HI                      0x601c
+#define PCIE_OUTB_ERR_MEM_CAUSE                                0x6020
+#define  PCIE_OUTB_ERR_MEM_CAUSE_TIMEOUT               BIT(6)
+#define  PCIE_OUTB_ERR_MEM_CAUSE_ABORT                 BIT(5)
+#define  PCIE_OUTB_ERR_MEM_CAUSE_UNSUPP_REQ            BIT(4)
+#define  PCIE_OUTB_ERR_MEM_CAUSE_ACC_DISABLED          BIT(1)
+#define  PCIE_OUTB_ERR_MEM_CAUSE_BAD_ADDR              BIT(0)
+
 #define  PCIE_RGR1_SW_INIT_1_PERST_MASK                        0x1
-#define  PCIE_RGR1_SW_INIT_1_PERST_SHIFT               0x0
 
 #define RGR1_SW_INIT_1_INIT_GENERIC_MASK               0x2
 #define RGR1_SW_INIT_1_INIT_GENERIC_SHIFT              0x1
@@ -305,6 +341,8 @@ struct brcm_pcie {
        bool                    ep_wakeup_capable;
        const struct pcie_cfg_data      *cfg;
        bool                    bridge_in_reset;
+       struct notifier_block   die_notifier;
+       struct notifier_block   panic_notifier;
        spinlock_t              bridge_lock;
 };
 
@@ -1727,6 +1765,119 @@ static int brcm_pcie_resume_noirq(struct device *dev)
        return ret;
 }
 
+/* Dump out PCIe errors on die or panic */
+static int brcm_pcie_dump_err(struct brcm_pcie *pcie,
+                              const char *type)
+{
+       void __iomem *base = pcie->base;
+       int i, is_cfg_err, is_mem_err, lanes;
+       const char *width_str, *direction_str;
+       u32 info, cfg_addr, cfg_cause, mem_cause, lo, hi;
+       struct pci_host_bridge *bridge = pci_host_bridge_from_priv(pcie);
+       unsigned long flags;
+       char lanes_str[9];
+
+       spin_lock_irqsave(&pcie->bridge_lock, flags);
+       /* Don't access registers when the bridge is off */
+       if (pcie->bridge_in_reset || readl(base + PCIE_OUTB_ERR_VALID) == 0) {
+               spin_unlock_irqrestore(&pcie->bridge_lock, flags);
+               return NOTIFY_DONE;
+       }
+
+       /* Read all necessary registers so we can release the spinlock ASAP */
+       info = readl(base + PCIE_OUTB_ERR_ACC_INFO);
+       is_cfg_err = !!(info & PCIE_OUTB_ERR_ACC_INFO_CFG_ERR);
+       is_mem_err = !!(info & PCIE_OUTB_ERR_ACC_INFO_MEM_ERR);
+       if (is_cfg_err) {
+               cfg_addr = readl(base + PCIE_OUTB_ERR_ACC_ADDR);
+               cfg_cause = readl(base + PCIE_OUTB_ERR_CFG_CAUSE);
+       }
+       if (is_mem_err) {
+               mem_cause = readl(base + PCIE_OUTB_ERR_MEM_CAUSE);
+               lo = readl(base + PCIE_OUTB_ERR_MEM_ADDR_LO);
+               hi = readl(base + PCIE_OUTB_ERR_MEM_ADDR_HI);
+       }
+       /* We've got all of the info, clear the error */
+       writel(1, base + PCIE_OUTB_ERR_CLEAR);
+       spin_unlock_irqrestore(&pcie->bridge_lock, flags);
+
+       dev_err(pcie->dev, "reporting PCIe info which may be related to %s error\n",
+               type);
+       width_str = (info & PCIE_OUTB_ERR_ACC_INFO_TYPE_64) ? "64bit" : "32bit";
+       direction_str = str_read_write(!(info & PCIE_OUTB_ERR_ACC_INFO_DIR_WRITE));
+       lanes = FIELD_GET(PCIE_OUTB_ERR_ACC_INFO_BYTE_LANES, info);
+       for (i = 0, lanes_str[8] = 0; i < 8; i++)
+               lanes_str[i] = (lanes & (1 << i)) ? '1' : '0';
+
+       if (is_cfg_err) {
+               int bus = FIELD_GET(PCIE_OUTB_ERR_ACC_ADDR_BUS, cfg_addr);
+               int dev = FIELD_GET(PCIE_OUTB_ERR_ACC_ADDR_DEV, cfg_addr);
+               int func = FIELD_GET(PCIE_OUTB_ERR_ACC_ADDR_FUNC, cfg_addr);
+               int reg = FIELD_GET(PCIE_OUTB_ERR_ACC_ADDR_REG, cfg_addr);
+
+               dev_err(pcie->dev, "Error: CFG Acc, %s, %s (%04x:%02x:%02x.%d) reg=0x%x, lanes=%s\n",
+                       width_str, direction_str, bridge->domain_nr, bus, dev,
+                       func, reg, lanes_str);
+               dev_err(pcie->dev, " Type: TO=%d Abt=%d UnsupReq=%d AccTO=%d AccDsbld=%d Acc64bit=%d\n",
+                       !!(cfg_cause & PCIE_OUTB_ERR_CFG_CAUSE_TIMEOUT),
+                       !!(cfg_cause & PCIE_OUTB_ERR_CFG_CAUSE_ABORT),
+                       !!(cfg_cause & PCIE_OUTB_ERR_CFG_CAUSE_UNSUPP_REQ),
+                       !!(cfg_cause & PCIE_OUTB_ERR_CFG_CAUSE_ACC_TIMEOUT),
+                       !!(cfg_cause & PCIE_OUTB_ERR_CFG_CAUSE_ACC_DISABLED),
+                       !!(cfg_cause & PCIE_OUTB_ERR_CFG_CAUSE_ACC_64BIT));
+       }
+
+       if (is_mem_err) {
+               u64 addr = ((u64)hi << 32) | (u64)lo;
+
+               dev_err(pcie->dev, "Error: Mem Acc, %s, %s, @0x%llx, lanes=%s\n",
+                       width_str, direction_str, addr, lanes_str);
+               dev_err(pcie->dev, " Type: TO=%d Abt=%d UnsupReq=%d AccDsble=%d BadAddr=%d\n",
+                       !!(mem_cause & PCIE_OUTB_ERR_MEM_CAUSE_TIMEOUT),
+                       !!(mem_cause & PCIE_OUTB_ERR_MEM_CAUSE_ABORT),
+                       !!(mem_cause & PCIE_OUTB_ERR_MEM_CAUSE_UNSUPP_REQ),
+                       !!(mem_cause & PCIE_OUTB_ERR_MEM_CAUSE_ACC_DISABLED),
+                       !!(mem_cause & PCIE_OUTB_ERR_MEM_CAUSE_BAD_ADDR));
+       }
+
+       return NOTIFY_DONE;
+}
+
+static int brcm_pcie_die_notify_cb(struct notifier_block *self,
+                                  unsigned long v, void *p)
+{
+       struct brcm_pcie *pcie =
+               container_of(self, struct brcm_pcie, die_notifier);
+
+       return brcm_pcie_dump_err(pcie, "Die");
+}
+
+static int brcm_pcie_panic_notify_cb(struct notifier_block *self,
+                                    unsigned long v, void *p)
+{
+       struct brcm_pcie *pcie =
+               container_of(self, struct brcm_pcie, panic_notifier);
+
+       return brcm_pcie_dump_err(pcie, "Panic");
+}
+
+static void brcm_register_die_notifiers(struct brcm_pcie *pcie)
+{
+       pcie->panic_notifier.notifier_call = brcm_pcie_panic_notify_cb;
+       atomic_notifier_chain_register(&panic_notifier_list,
+                                      &pcie->panic_notifier);
+
+       pcie->die_notifier.notifier_call = brcm_pcie_die_notify_cb;
+       register_die_notifier(&pcie->die_notifier);
+}
+
+static void brcm_unregister_die_notifiers(struct brcm_pcie *pcie)
+{
+       unregister_die_notifier(&pcie->die_notifier);
+       atomic_notifier_chain_unregister(&panic_notifier_list,
+                                        &pcie->panic_notifier);
+}
+
 static void __brcm_pcie_remove(struct brcm_pcie *pcie)
 {
        brcm_msi_remove(pcie);
@@ -1745,6 +1896,9 @@ static void brcm_pcie_remove(struct platform_device *pdev)
 
        pci_stop_root_bus(bridge->bus);
        pci_remove_root_bus(bridge->bus);
+       if (pcie->cfg->has_err_report)
+               brcm_unregister_die_notifiers(pcie);
+
        __brcm_pcie_remove(pcie);
 }
 
@@ -1845,6 +1999,7 @@ static const struct pcie_cfg_data bcm7216_cfg = {
        .bridge_sw_init_set = brcm_pcie_bridge_sw_init_set_7278,
        .has_phy        = true,
        .num_inbound_wins = 3,
+       .has_err_report = true,
 };
 
 static const struct pcie_cfg_data bcm7712_cfg = {
@@ -2019,8 +2174,10 @@ static int brcm_pcie_probe(struct platform_device *pdev)
                return ret;
        }
 
-       if (pcie->cfg->has_err_report)
+       if (pcie->cfg->has_err_report) {
                spin_lock_init(&pcie->bridge_lock);
+               brcm_register_die_notifiers(pcie);
+       }
 
        return 0;