irqchip/sifive-plic: Add support for UltraRISC DP1000 PLIC

Add a new compatible for the plic found in UltraRISC DP1000 with a quirk to
work around a known hardware bug with IRQ claiming in the UR-CP100 cores.

When claiming an interrupt on UR-CP100 cores, all other interrupts must be
disabled before the claim register is accessed to prevent incorrect
handling of the interrupt. This is a hardware bug in the CP100 core
implementation, not specific to the DP1000 SoC.

When the PLIC_QUIRK_CP100_CLAIM_REGISTER_ERRATUM flag is present, a
specialized handler (plic_handle_irq_cp100) disables all interrupts except
for the first pending one before reading the claim register, and then
restores the interrupts before further processing of the claimed interrupt
continues.

This implementation leverages the enable_save optimization, which maintains
the current interrupt enable state in memory, avoiding additional register
reads during the workaround.

The driver matches on "ultrarisc,cp100-plic" to apply the quirk to all
SoCs using UR-CP100 cores, regardless of the specific SoC implementation.
This has no impact on other platforms.

[ tglx: Condensed the code a bit, massaged change log and comments ]

Co-developed-by: Zhang Xincheng <zhangxincheng@ultrarisc.com>
Signed-off-by: Zhang Xincheng <zhangxincheng@ultrarisc.com>
Signed-off-by: Charles Mirabile <cmirabil@redhat.com>
Signed-off-by: Lucas Zampieri <lzampier@redhat.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: Samuel Holland <samuel.holland@sifive.com>
Link: https://patch.msgid.link/20251024083647.475239-5-lzampier@redhat.com

diff --git a/drivers/irqchip/irq-sifive-plic.c b/drivers/irqchip/irq-sifive-plic.c
index d518a8b468742123f7fa30dbd2dd831258ad3ac6..c03340e7117cd9ca6fe03e21bfee98f1c393c4c5 100644 (file)
--- a/drivers/irqchip/irq-sifive-plic.c
+++ b/drivers/irqchip/irq-sifive-plic.c
@@ -49,6 +49,8 @@
 #define CONTEXT_ENABLE_BASE            0x2000
 #define     CONTEXT_ENABLE_SIZE                0x80
 
+#define PENDING_BASE                   0x1000
+
 /*
  * Each hart context has a set of control registers associated with it.  Right
  * now there's only two: a source priority threshold over which the hart will
@@ -63,6 +65,7 @@
 #define        PLIC_ENABLE_THRESHOLD           0
 
 #define PLIC_QUIRK_EDGE_INTERRUPT      0
+#define PLIC_QUIRK_CP100_CLAIM_REGISTER_ERRATUM        1
 
 struct plic_priv {
        struct fwnode_handle *fwnode;
@@ -388,6 +391,98 @@ static void plic_handle_irq(struct irq_desc *desc)
        chained_irq_exit(chip, desc);
 }
 
+static u32 cp100_isolate_pending_irq(int nr_irq_groups, struct plic_handler *handler)
+{
+       u32 __iomem *pending = handler->priv->regs + PENDING_BASE;
+       u32 __iomem *enable = handler->enable_base;
+       u32 pending_irqs = 0;
+       int i, j;
+
+       /* Look for first pending interrupt */
+       for (i = 0; i < nr_irq_groups; i++) {
+               /* Any pending interrupts would be annihilated, so skip checking them */
+               if (!handler->enable_save[i])
+                       continue;
+
+               pending_irqs = handler->enable_save[i] & readl_relaxed(pending + i);
+               if (pending_irqs)
+                       break;
+       }
+
+       if (!pending_irqs)
+               return 0;
+
+       /* Isolate lowest set bit */
+       pending_irqs &= -pending_irqs;
+
+       /* Disable all interrupts but the first pending one */
+       for (j = 0; j < nr_irq_groups; j++) {
+               u32 new_mask = j == i ? pending_irqs : 0;
+
+               if (new_mask != handler->enable_save[j])
+                       writel_relaxed(new_mask, enable + j);
+       }
+       return pending_irqs;
+}
+
+static irq_hw_number_t cp100_get_hwirq(struct plic_handler *handler, void __iomem *claim)
+{
+       int nr_irq_groups = DIV_ROUND_UP(handler->priv->nr_irqs, 32);
+       u32 __iomem *enable = handler->enable_base;
+       irq_hw_number_t hwirq = 0;
+       u32 iso_mask;
+       int i;
+
+       guard(raw_spinlock)(&handler->enable_lock);
+
+       /* Existing enable state is already cached in enable_save */
+       iso_mask = cp100_isolate_pending_irq(nr_irq_groups, handler);
+       if (!iso_mask)
+               return 0;
+
+       /*
+        * Interrupts delievered to hardware still become pending, but only
+        * interrupts that are both pending and enabled can be claimed.
+        * Clearing the enable bit for all interrupts but the first pending
+        * one avoids a hardware bug that occurs during read from the claim
+        * register with more than one eligible interrupt.
+        */
+       hwirq = readl(claim);
+
+       /* Restore previous state */
+       for (i = 0; i < nr_irq_groups; i++) {
+               u32 written = i == hwirq / 32 ? iso_mask : 0;
+               u32 stored = handler->enable_save[i];
+
+               if (stored != written)
+                       writel_relaxed(stored, enable + i);
+       }
+       return hwirq;
+}
+
+static void plic_handle_irq_cp100(struct irq_desc *desc)
+{
+       struct plic_handler *handler = this_cpu_ptr(&plic_handlers);
+       struct irq_chip *chip = irq_desc_get_chip(desc);
+       void __iomem *claim = handler->hart_base + CONTEXT_CLAIM;
+       irq_hw_number_t hwirq;
+
+       WARN_ON_ONCE(!handler->present);
+
+       chained_irq_enter(chip, desc);
+
+       while ((hwirq = cp100_get_hwirq(handler, claim))) {
+               int err = generic_handle_domain_irq(handler->priv->irqdomain, hwirq);
+
+               if (unlikely(err)) {
+                       pr_warn_ratelimited("%pfwP: can't find mapping for hwirq %lu\n",
+                                           handler->priv->fwnode, hwirq);
+               }
+       }
+
+       chained_irq_exit(chip, desc);
+}
+
 static void plic_set_threshold(struct plic_handler *handler, u32 threshold)
 {
        /* priority must be > threshold to trigger an interrupt */
@@ -424,6 +519,8 @@ static const struct of_device_id plic_match[] = {
          .data = (const void *)BIT(PLIC_QUIRK_EDGE_INTERRUPT) },
        { .compatible = "thead,c900-plic",
          .data = (const void *)BIT(PLIC_QUIRK_EDGE_INTERRUPT) },
+       { .compatible = "ultrarisc,cp100-plic",
+         .data = (const void *)BIT(PLIC_QUIRK_CP100_CLAIM_REGISTER_ERRATUM) },
        {}
 };
 
@@ -658,12 +755,17 @@ done:
                }
 
                if (global_setup) {
+                       void (*handler_fn)(struct irq_desc *) = plic_handle_irq;
+
+                       if (test_bit(PLIC_QUIRK_CP100_CLAIM_REGISTER_ERRATUM, &handler->priv->plic_quirks))
+                               handler_fn = plic_handle_irq_cp100;
+
                        /* Find parent domain and register chained handler */
                        domain = irq_find_matching_fwnode(riscv_get_intc_hwnode(), DOMAIN_BUS_ANY);
                        if (domain)
                                plic_parent_irq = irq_create_mapping(domain, RV_IRQ_EXT);
                        if (plic_parent_irq)
-                               irq_set_chained_handler(plic_parent_irq, plic_handle_irq);
+                               irq_set_chained_handler(plic_parent_irq, handler_fn);
 
                        cpuhp_setup_state(CPUHP_AP_IRQ_SIFIVE_PLIC_STARTING,
                                          "irqchip/sifive/plic:starting",