From nobody Sun Feb 8 23:25:45 2026 Received: from mail-wm1-f43.google.com (mail-wm1-f43.google.com [209.85.128.43]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9BD872C859 for ; Tue, 13 Jan 2026 16:15:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768320932; cv=none; b=uT22/ZXYPnjMOfq81ZTX9Y7KffpC/KeUjeKXcCmxihHLGnYkg9lRZvFtWXonLN8d9dZpOCW+1/n0IpCFmHlmh2Q5z0H7H0+ANEbaMWBaBijct7cGdQ6Ix1kt7MXfl/lXKVQGyXYUGCUBJ4fjXoSZwo8kYQtghs1hzREnyEdSs8g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768320932; c=relaxed/simple; bh=Upo/KeJ1tydzhEX3FEnB2Lq6CdSMUiNT1LlycW0K1NM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=FFbR2TxznC3pHCq8t2mfe0dUaploiYvC+lICsxo+Vr7bglGT8Q+QmWYyIJU51p6Ws6Nr3w022L9u8LEPHAzZfrY2+UOQy7U99I+pHxKYZG0UyuI/P+2fyv9PgG4/y3XErSWmG/2IP7sEZWKy5p19rN9KbgNHgqhKm2xWWhgvg5g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=fQ//JyQy; arc=none smtp.client-ip=209.85.128.43 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="fQ//JyQy" Received: by mail-wm1-f43.google.com with SMTP id 5b1f17b1804b1-477bf34f5f5so62471075e9.0 for ; Tue, 13 Jan 2026 08:15:30 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1768320925; x=1768925725; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=VFXHMGeoomdbZOLp3ce3D0yDHo0q4hSajO4R4fHl4CQ=; b=fQ//JyQyUIHGRfPyqTagnrhK/DKLTuhvB07e7n05qtUhSzDKIsDLJJqLyPQS3XxaAQ qWWs2UrAW5Zh+YuLeGXt07YkZPOpqI+u8kDM9rB8W62ksUS+38pm734rbMdeapRJSdKz GlXxy6LIP/bSpBEG1ZgrHJ6ZieusMZ94+5i9YiUtHWvynwa/j2Zx8VpLvmB4bL7RoMSU zcRcKqhouU1wji5mtg+ybcZl60KHAUqFhXHMTfcFAP7EkdGcc5svElF7dEaDOq5+Tr4k j0ZXG+16SyNSe0gD8v7CuXf37UjdRmatcVonJLGnzmy7uxSUMpNYa/+CYOI5jZws/mME aWGA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1768320925; x=1768925725; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=VFXHMGeoomdbZOLp3ce3D0yDHo0q4hSajO4R4fHl4CQ=; b=OdwSn8sCrhbL0nf7ysmdGWT6cXT7E7zcAiDgT1GHJfDFwva56PQmLP0lcWzhyYuwxL V+AySroLAIHfMsJt/T+vkLgstb+8U9urGaJL0qTGZ8z5cFMbFxfyUvClGLxPY03JzBl2 1M1Oe0E9x1dJq5cyNdOJ/5re2TIkbKgCr2DyhGUfAflWb/a9WWkrI0nETZVCT4iYo0Bc 02++h4uJlKMi4rlzl6ICKofYNJgxcmSroyF9EW+oUIKSNgmPELszfrGClY7nZ0f0eWUx bP1zPeV5yUc4h3aoTMZnh1IDu0u0VapQdZFFVOyCRRz8bdpdJvfIgk38N29TsQKPoFfx ZLCg== X-Gm-Message-State: AOJu0YzoOrIXzZmS8QknH+wB4o6a1kJUki8a31x7sA8YhblJfqANPgUS CxYRPk3oNjY6W0LRiGFaM5+LT8dh9kEXL+ML5q2nVJ96yq4etXuCmmQac1Va+A== X-Gm-Gg: AY/fxX4Wzohw3lFV2XyKGluKXM4fAkpPwRluMhm/4vJEYFTu0GD939KJr/+STGiQ5r2 VLaK19FuLaXvknq2O9JoT8zZPbRz6yuNvoiIt9DkSGpH++AT3FZItqQE7lwnlEpDaG1YF0AqfdS WYADfRGsoXiwajetcXdoSI89U9b/cktWM+MriXha6TrOzl8AboPorE9g9sDZFr97/6qy+YghKyY 7Pq/Gj0RZdriqkCCkjXuzeWt19RlaYpUG0eoQmkyg/y29yHY8khR4ZB6YfosKxmiTRZOWW2fQwN Gtmn4iYyEzdqDHxB8aSu8ZVAjAzGtZ1DYZfwXnUyaj7LsdNorM+NAxyzASSizQ2DWktFcjR9OGQ iZkzI6WXLVX9AZCUpxPCP2aCGB2oe/C0kXvZ4SYCvTKaa5DWxwrBAf3I9kCEj5ai3MazOO3RS3F tZ9iLm1cDUHVQEj2SFUtuG1DZSlVhDKUppAYHAtiKvAAdd2IW1EdNNrR3xCKLIyTEU X-Google-Smtp-Source: AGHT+IFNlvwrKp+KJG2284DCa8NpoGDbY3vjhJ6xtVEGbHn019G4ljpezxVBqkiUcpZVaYK+N7/Z1A== X-Received: by 2002:a05:600c:1393:b0:477:55ce:f3bc with SMTP id 5b1f17b1804b1-47d84b3bad4mr246429825e9.19.1768320924653; Tue, 13 Jan 2026 08:15:24 -0800 (PST) Received: from localhost (brnt-04-b2-v4wan-170138-cust2432.vm7.cable.virginm.net. [94.175.9.129]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47d7f4184e1sm403945455e9.4.2026.01.13.08.15.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 13 Jan 2026 08:15:23 -0800 (PST) From: Stafford Horne To: LKML Cc: Linux OpenRISC , devicetree , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Stafford Horne , Jonas Bonn , Stefan Kristiansson , Thomas Gleixner Subject: [PATCH v4 4/6] openrisc: Fix IPIs on simple multicore systems Date: Tue, 13 Jan 2026 16:11:37 +0000 Message-ID: <20260113161152.3688309-5-shorne@gmail.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20260113161152.3688309-1-shorne@gmail.com> References: <20260113161152.3688309-1-shorne@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Commit c05671846451 ("openrisc: sleep instead of spin on secondary wait") fixed OpenRISC SMP Linux for QEMU. However, stability was never achieved on FPGA development boards. This is because the above patch has a step to unmask IPIs on non-boot cpu's but on hardware without power management, IPIs remain masked. This meant that IPI's were never actually working on the simple SMP systems we run on development boards. The systems booted but stability was very suspect. Add the ability to unmask IPI's on the non-boot cores. This is done by making the OMPIC IRQs proper percpu IRQs. We can then use the enabled_percpu_irq() to unmask IRQ on the non-boot cpus. Update the or1k PIC driver to use a flow handler that can switch between percpu and the configured level or edge flow handlers at runtime. This mechanism is inspired by that done in the J-Core AIC driver. Signed-off-by: Stafford Horne Acked-by: Thomas Gleixner --- arch/openrisc/include/asm/smp.h | 3 ++- arch/openrisc/kernel/smp.c | 22 +++++++++++++++++++++- drivers/irqchip/irq-ompic.c | 15 +++++++++++---- drivers/irqchip/irq-or1k-pic.c | 27 ++++++++++++++++++++++++++- 4 files changed, 60 insertions(+), 7 deletions(-) diff --git a/arch/openrisc/include/asm/smp.h b/arch/openrisc/include/asm/sm= p.h index e21d2f12b5b6..007296f160ef 100644 --- a/arch/openrisc/include/asm/smp.h +++ b/arch/openrisc/include/asm/smp.h @@ -20,7 +20,8 @@ extern void smp_init_cpus(void); extern void arch_send_call_function_single_ipi(int cpu); extern void arch_send_call_function_ipi_mask(const struct cpumask *mask); =20 -extern void set_smp_cross_call(void (*)(const struct cpumask *, unsigned i= nt)); +extern void set_smp_cross_call(void (*)(const struct cpumask *, unsigned i= nt), + unsigned int irq); extern void handle_IPI(unsigned int ipi_msg); =20 #endif /* __ASM_OPENRISC_SMP_H */ diff --git a/arch/openrisc/kernel/smp.c b/arch/openrisc/kernel/smp.c index 86da4bc5ee0b..040ca201b692 100644 --- a/arch/openrisc/kernel/smp.c +++ b/arch/openrisc/kernel/smp.c @@ -13,6 +13,7 @@ =20 #include #include +#include #include #include #include @@ -25,6 +26,7 @@ =20 asmlinkage __init void secondary_start_kernel(void); =20 +static unsigned int ipi_irq __ro_after_init; static void (*smp_cross_call)(const struct cpumask *, unsigned int); =20 unsigned long secondary_release =3D -1; @@ -39,6 +41,14 @@ enum ipi_msg_type { =20 static DEFINE_SPINLOCK(boot_lock); =20 +static void or1k_ipi_enable(void) +{ + if (WARN_ON_ONCE(!ipi_irq)) + return; + + enable_percpu_irq(ipi_irq, 0); +} + static void boot_secondary(unsigned int cpu, struct task_struct *idle) { /* @@ -136,6 +146,7 @@ asmlinkage __init void secondary_start_kernel(void) complete(&cpu_running); =20 synchronise_count_slave(cpu); + or1k_ipi_enable(); set_cpu_online(cpu, true); =20 local_irq_enable(); @@ -195,9 +206,18 @@ void smp_send_stop(void) smp_call_function(stop_this_cpu, NULL, 0); } =20 -void __init set_smp_cross_call(void (*fn)(const struct cpumask *, unsigned= int)) +void __init set_smp_cross_call(void (*fn)(const struct cpumask *, unsigned= int), + unsigned int irq) { + if (WARN_ON(ipi_irq)) + return; + smp_cross_call =3D fn; + + ipi_irq =3D irq; + + /* Enabled IPIs for boot CPU immediately */ + or1k_ipi_enable(); } =20 void arch_send_call_function_single_ipi(int cpu) diff --git a/drivers/irqchip/irq-ompic.c b/drivers/irqchip/irq-ompic.c index e66ef4373b1e..f0e0b435bb1d 100644 --- a/drivers/irqchip/irq-ompic.c +++ b/drivers/irqchip/irq-ompic.c @@ -84,6 +84,8 @@ DEFINE_PER_CPU(unsigned long, ops); =20 static void __iomem *ompic_base; =20 +static DEFINE_PER_CPU_READ_MOSTLY(int, ipi_dummy_dev); + static inline u32 ompic_readreg(void __iomem *base, loff_t offset) { return ioread32be(base + offset); @@ -183,12 +185,17 @@ static int __init ompic_of_init(struct device_node *n= ode, goto out_unmap; } =20 - ret =3D request_irq(irq, ompic_ipi_handler, IRQF_PERCPU, - "ompic_ipi", NULL); - if (ret) + irq_set_percpu_devid(irq); + ret =3D request_percpu_irq(irq, ompic_ipi_handler, "ompic_ipi", + &ipi_dummy_dev); + + if (ret) { + pr_err("ompic: failed to request irq %d, error: %d", + irq, ret); goto out_irq_disp; + } =20 - set_smp_cross_call(ompic_raise_softirq); + set_smp_cross_call(ompic_raise_softirq, irq); =20 return 0; =20 diff --git a/drivers/irqchip/irq-or1k-pic.c b/drivers/irqchip/irq-or1k-pic.c index 48126067c54b..73dc99c71d40 100644 --- a/drivers/irqchip/irq-or1k-pic.c +++ b/drivers/irqchip/irq-or1k-pic.c @@ -118,11 +118,36 @@ static void or1k_pic_handle_irq(struct pt_regs *regs) generic_handle_domain_irq(root_domain, irq); } =20 +/* + * The OR1K PIC is a cpu-local interrupt controller and does not distingui= sh or + * use distinct irq number ranges for per-cpu event interrupts (IPI). Since + * information to determine whether a particular irq number should be trea= ted as + * per-cpu is not available at mapping time, we use a wrapper handler func= tion + * which chooses the right handler at runtime based on whether IRQF_PERCPU= was + * used when requesting the irq. Borrowed from J-Core AIC. + */ +static void or1k_irq_flow_handler(struct irq_desc *desc) +{ +#ifdef CONFIG_SMP + struct irq_data *data =3D irq_desc_get_irq_data(desc); + struct or1k_pic_dev *pic =3D data->domain->host_data; + + if (irqd_is_per_cpu(data)) + handle_percpu_devid_irq(desc); + else + pic->handle(desc); +#endif +} + static int or1k_map(struct irq_domain *d, unsigned int irq, irq_hw_number_= t hw) { struct or1k_pic_dev *pic =3D d->host_data; =20 - irq_set_chip_and_handler(irq, &pic->chip, pic->handle); + if (IS_ENABLED(CONFIG_SMP)) + irq_set_chip_and_handler(irq, &pic->chip, or1k_irq_flow_handler); + else + irq_set_chip_and_handler(irq, &pic->chip, pic->handle); + irq_set_status_flags(irq, pic->flags); =20 return 0; --=20 2.51.0