From patchwork Tue Sep 12 21:57:04 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Palmer Dabbelt X-Patchwork-Id: 9950225 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 542666038F for ; Tue, 12 Sep 2017 21:59:56 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 4483628C60 for ; Tue, 12 Sep 2017 21:59:56 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 3830228CCA; Tue, 12 Sep 2017 21:59:56 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.3 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_HI, RCVD_IN_SORBS_SPAM, T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 86F7328C60 for ; Tue, 12 Sep 2017 21:59:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751660AbdILV6E (ORCPT ); Tue, 12 Sep 2017 17:58:04 -0400 Received: from mail-pg0-f66.google.com ([74.125.83.66]:34945 "EHLO mail-pg0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751529AbdILV5x (ORCPT ); Tue, 12 Sep 2017 17:57:53 -0400 Received: by mail-pg0-f66.google.com with SMTP id j16so3646514pga.2 for ; Tue, 12 Sep 2017 14:57:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=dabbelt-com.20150623.gappssmtp.com; s=20150623; h=subject:date:message-id:in-reply-to:references:cc:from:to; bh=1zZorsZzqNDJMn1H9o5m5f3GoLQbPoENkEtH4c6/SPg=; b=oxhf3xLg2uF6OK3InvWEhr/sb56u1UxCoWVZEsR8KErJ/FHJ4PXyjPZKg9KFpqK2HF 8HgaqNf4D89gk3mDRLYMZQf6el2N5fxVP2hKUyPRkYVASENA06plzQqlx32dITj5HXgy cGDmY8HPWv+Q4DsiCoEebFQVsO1ej4ZBGN7cK7THs/jB7lJch7swZ5aUZav76RyDz3gt oYGR0MJee9iCHm6qacprGfQTcazj5nOoEv1my5QVEXSajkmVmLHtRwA5HtO5vH/fGwUZ Zg7yji29vkBi5Ot+MuseUaQaCg3t3EBdK413EQwqC5RuRWGFdxb6C5+dxrnxaHdH3hqy o46Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:date:message-id:in-reply-to:references :cc:from:to; bh=1zZorsZzqNDJMn1H9o5m5f3GoLQbPoENkEtH4c6/SPg=; b=k1Oo+Ji2Ym8qx4rcOvxp6R9mNWnhYsAFIMoUHNp+5SUj02MvIiq2LbB3yHH3Ldhch3 yl0J5Z8sVnCHAynmL3FqpugV+UPQ/ai+yI1GRCxh5fnHbX4j8eRmqv4RHCAOCr2BoI2K tGBP4Wg4RSI3zy8GhKq1Xl1ViIGfQVXDiEnxU9F5yIwXGYNAFU4ExVjsaiCYvJ5JpviQ WaP/hxBIvpYZU976SR8ctuB6C5/5J+P80QYgl/lJ5fD1tnTpP1j11XzOBFgldv2LoYiV EPLHwnJg8+4soNCAP5l94sKTNan0LaXCP2qiO+DgsTt08gF2aGg2loTPESyYPh68pKZ8 gNjA== X-Gm-Message-State: AHPjjUjVh/MB+MsUWgsFKsGS06CcINtI0rZSatRFMmIkhurkab2G+bSz 9eNxv0KlbBe/2w+L X-Google-Smtp-Source: ADKCNb4gVPuvmXC5dgjlVMgK+uymStpn9Ht59BRwLMsxqYAlEnDITG7j6zdZy9+f532ttyUtkyoFfw== X-Received: by 10.98.33.134 with SMTP id o6mr16159025pfj.91.1505253472727; Tue, 12 Sep 2017 14:57:52 -0700 (PDT) Received: from localhost ([12.206.222.5]) by smtp.gmail.com with ESMTPSA id l74sm24036457pfi.9.2017.09.12.14.57.51 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 12 Sep 2017 14:57:52 -0700 (PDT) Subject: [PATCH v8 07/18] irqchip: RISC-V Local Interrupt Controller Driver Date: Tue, 12 Sep 2017 14:57:04 -0700 Message-Id: <20170912215715.4186-8-palmer@dabbelt.com> X-Mailer: git-send-email 2.13.5 In-Reply-To: <20170912215715.4186-1-palmer@dabbelt.com> References: <20170912215715.4186-1-palmer@dabbelt.com> Cc: yamada.masahiro@socionext.com, mmarek@suse.com, albert@sifive.com, will.deacon@arm.com, boqun.feng@gmail.com, oleg@redhat.com, mingo@redhat.com, daniel.lezcano@linaro.org, gregkh@linuxfoundation.org, jslaby@suse.com, davem@davemloft.net, mchehab@kernel.org, hverkuil@xs4all.nl, rdunlap@infradead.org, viro@zeniv.linux.org.uk, mhiramat@kernel.org, fweisbec@gmail.com, mcgrof@kernel.org, dledford@redhat.com, bart.vanassche@sandisk.com, sstabellini@kernel.org, mpe@ellerman.id.au, rmk+kernel@armlinux.org.uk, paul.gortmaker@windriver.com, nicolas.dichtel@6wind.com, linux@roeck-us.net, heiko.carstens@de.ibm.com, schwidefsky@de.ibm.com, geert@linux-m68k.org, akpm@linux-foundation.org, andriy.shevchenko@linux.intel.com, jiri@mellanox.com, vgupta@synopsys.com, airlied@redhat.com, jk@ozlabs.org, chris@chris-wilson.co.uk, Jason@zx2c4.com, paulmck@linux.vnet.ibm.com, ncardwell@google.com, linux-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, patches@groups.riscv.org, Palmer Dabbelt From: Palmer Dabbelt To: peterz@infradead.org, tglx@linutronix.de, jason@lakedaemon.net, marc.zyngier@arm.com, Arnd Bergmann , dmitriy@oss-tech.org Sender: linux-kbuild-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kbuild@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP This patch adds a driver that manages the local interrupts on each RISC-V hart, as specifiec by the RISC-V supervisor level ISA manual. The local interrupt controller manages software interrupts, timer interrupts, and hardware interrupts (which are routed via the platform level interrupt controller). Per-hart local interrupt controllers are found on all RISC-V systems. Signed-off-by: Palmer Dabbelt --- drivers/irqchip/Kconfig | 14 +++ drivers/irqchip/Makefile | 1 + drivers/irqchip/irq-riscv-intc.c | 210 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 225 insertions(+) create mode 100644 drivers/irqchip/irq-riscv-intc.c diff --git a/drivers/irqchip/Kconfig b/drivers/irqchip/Kconfig index f1fd5f44d1d4..7923d3fa8fae 100644 --- a/drivers/irqchip/Kconfig +++ b/drivers/irqchip/Kconfig @@ -306,3 +306,17 @@ config QCOM_IRQ_COMBINER help Say yes here to add support for the IRQ combiner devices embedded in Qualcomm Technologies chips. + +config RISCV_INTC + def_bool y if RISCV + #bool "RISC-V Interrupt Controller" + depends on RISCV + default y + help + This enables support for the local interrupt controller found in + standard RISC-V systems. The local interrupt controller handles + timer interrupts, software interrupts, and hardware interrupts. + Without a local interrupt controller the system will be unable to + handle any interrupts, including those passed via the PLIC. + + If you don't know what to do here, say Y. diff --git a/drivers/irqchip/Makefile b/drivers/irqchip/Makefile index e88d856cc09c..b1aa9114afc4 100644 --- a/drivers/irqchip/Makefile +++ b/drivers/irqchip/Makefile @@ -78,3 +78,4 @@ obj-$(CONFIG_EZNPS_GIC) += irq-eznps.o obj-$(CONFIG_ARCH_ASPEED) += irq-aspeed-vic.o irq-aspeed-i2c-ic.o obj-$(CONFIG_STM32_EXTI) += irq-stm32-exti.o obj-$(CONFIG_QCOM_IRQ_COMBINER) += qcom-irq-combiner.o +obj-$(CONFIG_RISCV_INTC) += irq-riscv-intc.o diff --git a/drivers/irqchip/irq-riscv-intc.c b/drivers/irqchip/irq-riscv-intc.c new file mode 100644 index 000000000000..d019bd3a4ae3 --- /dev/null +++ b/drivers/irqchip/irq-riscv-intc.c @@ -0,0 +1,210 @@ +/* + * Copyright (C) 2012 Regents of the University of California + * Copyright (C) 2017 SiFive + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, version 2. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#define PTR_BITS (8 * sizeof(uintptr_t)) + +struct riscv_irq_data { + struct irq_chip chip; + struct irq_domain *domain; + int hart; + char name[20]; +}; +DEFINE_PER_CPU(struct riscv_irq_data, riscv_irq_data); + +static void riscv_software_interrupt(void) +{ +#ifdef CONFIG_SMP + irqreturn_t ret; + + ret = handle_ipi(); + + WARN_ON(ret == IRQ_NONE); +#else + /* + * We currently only use software interrupts to pass inter-processor + * interrupts, so if a non-SMP system gets a software interrupt then we + * don't know what to do. + */ + pr_warning("Software Interrupt without CONFIG_SMP\n"); +#endif +} + +asmlinkage void __irq_entry do_IRQ(unsigned int cause, struct pt_regs *regs) +{ + struct pt_regs *old_regs = set_irq_regs(regs); + struct irq_domain *domain; + + irq_enter(); + + /* + * There are three classes of interrupt: timer, software, and + * external devices. We dispatch between them here. External + * device interrupts use the generic IRQ mechanisms. + */ + switch (cause) { + case INTERRUPT_CAUSE_TIMER: + riscv_timer_interrupt(); + break; + case INTERRUPT_CAUSE_SOFTWARE: + riscv_software_interrupt(); + break; + default: + domain = per_cpu(riscv_irq_data, smp_processor_id()).domain; + generic_handle_irq(irq_find_mapping(domain, cause)); + break; + } + + irq_exit(); + set_irq_regs(old_regs); +} + +static int riscv_irqdomain_map(struct irq_domain *d, unsigned int irq, + irq_hw_number_t hwirq) +{ + struct riscv_irq_data *data = d->host_data; + + irq_set_chip_and_handler(irq, &data->chip, handle_simple_irq); + irq_set_chip_data(irq, data); + irq_set_noprobe(irq); + irq_set_affinity(irq, cpumask_of(data->hart)); + + return 0; +} + +static const struct irq_domain_ops riscv_irqdomain_ops = { + .map = riscv_irqdomain_map, + .xlate = irq_domain_xlate_onecell, +}; + +/* + * On RISC-V systems local interrupts are masked or unmasked by writing the SIE + * (Supervisor Interrupt Enable) CSR. As CSRs can only be written on the local + * hart, these functions can only be called on the hart that corresponds to the + * IRQ chip. They are only called internally to this module, so they BUG_ON if + * this condition is violated rather than attempting to handle the error by + * forwarding to the target hart, as that's already expected to have been done. + */ +static void riscv_irq_mask(struct irq_data *d) +{ + struct riscv_irq_data *data = irq_data_get_irq_chip_data(d); + + BUG_ON(smp_processor_id() != data->hart); + csr_clear(sie, 1 << (long)d->hwirq); +} + +static void riscv_irq_unmask(struct irq_data *d) +{ + struct riscv_irq_data *data = irq_data_get_irq_chip_data(d); + + BUG_ON(smp_processor_id() != data->hart); + csr_set(sie, 1 << (long)d->hwirq); +} + +/* Callbacks for twiddling SIE on another hart. */ +static void riscv_irq_enable_helper(void *d) +{ + riscv_irq_unmask(d); +} + +static void riscv_irq_disable_helper(void *d) +{ + riscv_irq_mask(d); +} + +static void riscv_remote_ctrl(unsigned int cpu, void (*fn)(void *d), + struct irq_data *data) +{ + smp_call_function_single(cpu, fn, data, true); +} + +static void riscv_irq_enable(struct irq_data *d) +{ + struct riscv_irq_data *data = irq_data_get_irq_chip_data(d); + + /* + * It's only possible to write SIE on the current hart. This jumps + * over to the target hart if it's not the current one. It's invalid + * to write SIE on a hart that's not currently running. + */ + if (data->hart == smp_processor_id()) + riscv_irq_unmask(d); + else if (cpu_online(data->hart)) + riscv_remote_ctrl(data->hart, riscv_irq_enable_helper, d); + else + WARN_ON_ONCE(1); +} + +static void riscv_irq_disable(struct irq_data *d) +{ + struct riscv_irq_data *data = irq_data_get_irq_chip_data(d); + + /* + * It's only possible to write SIE on the current hart. This jumps + * over to the target hart if it's not the current one. It's invalid + * to write SIE on a hart that's not currently running. + */ + if (data->hart == smp_processor_id()) + riscv_irq_mask(d); + else if (cpu_online(data->hart)) + riscv_remote_ctrl(data->hart, riscv_irq_disable_helper, d); + else + WARN_ON_ONCE(1); +} + +static int riscv_intc_init(struct device_node *node, struct device_node *parent) +{ + int hart; + struct riscv_irq_data *data; + + if (parent) + return 0; + + hart = riscv_of_processor_hart(node->parent); + if (hart < 0) + return -EIO; + + data = &per_cpu(riscv_irq_data, hart); + snprintf(data->name, sizeof(data->name), "riscv,cpu_intc,%d", hart); + data->hart = hart; + data->chip.name = data->name; + data->chip.irq_mask = riscv_irq_mask; + data->chip.irq_unmask = riscv_irq_unmask; + data->chip.irq_enable = riscv_irq_enable; + data->chip.irq_disable = riscv_irq_disable; + data->domain = irq_domain_add_linear(node, PTR_BITS, + &riscv_irqdomain_ops, data); + if (!data->domain) + goto error_add_linear; + pr_info("%s: %d local interrupts mapped\n", data->name, PTR_BITS); + return 0; + +error_add_linear: + pr_warning("%s: unable to add IRQ domain\n", + data->name); + return -ENXIO; +} + +IRQCHIP_DECLARE(riscv, "riscv,cpu-intc", riscv_intc_init);