From patchwork Wed Oct 19 10:08:21 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerome Brunet X-Patchwork-Id: 9383767 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 280E660487 for ; Wed, 19 Oct 2016 10:11:05 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 16E5328B69 for ; Wed, 19 Oct 2016 10:11:05 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 0AFDD29908; Wed, 19 Oct 2016 10:11:05 +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=-4.1 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_MED, T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.9]) (using TLSv1.2 with cipher AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 3F65228B69 for ; Wed, 19 Oct 2016 10:11:04 +0000 (UTC) Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.85_2 #1 (Red Hat Linux)) id 1bwnoN-0005P0-Cy; Wed, 19 Oct 2016 10:09:27 +0000 Received: from mail-wm0-x230.google.com ([2a00:1450:400c:c09::230]) by bombadil.infradead.org with esmtps (Exim 4.85_2 #1 (Red Hat Linux)) id 1bwno7-0005H5-G0 for linux-arm-kernel@lists.infradead.org; Wed, 19 Oct 2016 10:09:16 +0000 Received: by mail-wm0-x230.google.com with SMTP id c78so42034634wme.0 for ; Wed, 19 Oct 2016 03:08:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=5TWKA73n6my02LAG/Z4qfDxoIpSvMvptu413rKcFwis=; b=u0NGEUOd9sxy1r1lTzlf5veXas0qLo9karuqSPlsJw5phdfVl1vQPG09FTCKcTNUGS 9fO8mbARZ91ZlviNo9Y7tWU9CYZDW7vteXU/llnkoRairu5gSvsfYujr0c6WZP74j1z2 6XwU+NNoEslNPjjaGVNfgZgpRIviT+9rOHGJpLnjqH/NoCjr9bCIGEz7kaSZA+yGcF7F 6W6/ApmBLZRYhTaCClJpvmyzvaxT+NmRPsgEYC7aVOKX5V5U7ADE1pIbSxwy5MD/c8dX NEP/gNj1ZUj95S+URJ7BtKXcGGEeWXQn1YFia2eDL4OETJzjF1jZUI4MWGeKTi9o9XVY uMSg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=5TWKA73n6my02LAG/Z4qfDxoIpSvMvptu413rKcFwis=; b=ZCv/kMR1rn822q+kWeSAfoVFQAZHsqjjwSgePRiqlmdyJKQ+m0yzzeT1v8rT/s6kpV l8fKDNeBiOJV5Z3rBKKFUWW4IDJbPOFBRlhjjXnWvm/4qPL0CHn63lhZuaDsNVcyTtGG mdmnzt0HkWoJh6/1JFuJrNytBhxweP7HxPr/K3bzT/lU+uUxthBaNfwnS9JFW+awoR6W gxzLIN9NfHRnge/cUFFsmKTu1VBNJY8RntUK9aoq4POGCLHv7Ioafq87E47zx9eHqeJK fvGPaEP4wJUPHUVJNyR3sW7hvlK0T6GKTyQlNwYZo6B80uMs+RQyLutqDdcnsANvTEng QXmA== X-Gm-Message-State: AA6/9Rk6jpXNu+SLs8LfWRdP2ARu3DR+n3vmbBzhMoKIN3KQRgnOvalj9P/wP6hvNfQ8NoQ0 X-Received: by 10.194.176.162 with SMTP id cj2mr3711488wjc.25.1476871732492; Wed, 19 Oct 2016 03:08:52 -0700 (PDT) Received: from boomer.baylibre.com ([90.63.244.31]) by smtp.googlemail.com with ESMTPSA id l15sm4199066wmd.7.2016.10.19.03.08.51 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 19 Oct 2016 03:08:51 -0700 (PDT) From: Jerome Brunet To: Carlo Caione , Kevin Hilman , Thomas Gleixner , Jason Cooper , Marc Zyngier Subject: [PATCH 1/9] irqchip: meson: add support for gpio interrupt controller Date: Wed, 19 Oct 2016 12:08:21 +0200 Message-Id: <1476871709-8359-2-git-send-email-jbrunet@baylibre.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1476871709-8359-1-git-send-email-jbrunet@baylibre.com> References: <1476871709-8359-1-git-send-email-jbrunet@baylibre.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20161019_030911_971272_22924847 X-CRM114-Status: GOOD ( 26.51 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, Catalin Marinas , Linus Walleij , Will Deacon , linux-kernel@vger.kernel.org, Russell King , linux-gpio@vger.kernel.org, Rob Herring , linux-amlogic@lists.infradead.org, linux-arm-kernel@lists.infradead.org, Jerome Brunet MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP Add support for the interrupt gpio controller found on Amlogic's meson SoC family. Unlike what the IP name suggest, it is not directly linked to the gpio subsystem. It is actually an independent IP that is able to spy on the SoC pad. For that purpose, it can mux and filter (edge or level and polarity) any single SoC pad to one of the 8 GIC's interrupts it owns. Signed-off-by: Jerome Brunet --- drivers/irqchip/Kconfig | 9 + drivers/irqchip/Makefile | 1 + drivers/irqchip/irq-meson-gpio.c | 423 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 433 insertions(+) create mode 100644 drivers/irqchip/irq-meson-gpio.c diff --git a/drivers/irqchip/Kconfig b/drivers/irqchip/Kconfig index 82b0b5daf3f5..168837263e80 100644 --- a/drivers/irqchip/Kconfig +++ b/drivers/irqchip/Kconfig @@ -279,3 +279,12 @@ config EZNPS_GIC config STM32_EXTI bool select IRQ_DOMAIN + +config MESON_GPIO_IRQ + bool "Meson GPIO Interrupt Multiplexer" + depends on ARCH_MESON || COMPILE_TEST + select IRQ_DOMAIN + select IRQ_DOMAIN_HIERARCHY + help + Support Meson SoC Family GPIO Interrupt Multiplexer + diff --git a/drivers/irqchip/Makefile b/drivers/irqchip/Makefile index e4dbfc85abdb..33f913d037d0 100644 --- a/drivers/irqchip/Makefile +++ b/drivers/irqchip/Makefile @@ -74,3 +74,4 @@ obj-$(CONFIG_LS_SCFG_MSI) += irq-ls-scfg-msi.o obj-$(CONFIG_EZNPS_GIC) += irq-eznps.o obj-$(CONFIG_ARCH_ASPEED) += irq-aspeed-vic.o obj-$(CONFIG_STM32_EXTI) += irq-stm32-exti.o +obj-$(CONFIG_MESON_GPIO_IRQ) += irq-meson-gpio.o diff --git a/drivers/irqchip/irq-meson-gpio.c b/drivers/irqchip/irq-meson-gpio.c new file mode 100644 index 000000000000..869b4df8c483 --- /dev/null +++ b/drivers/irqchip/irq-meson-gpio.c @@ -0,0 +1,423 @@ +/* + * Copyright (c) 2015 Endless Mobile, Inc. + * Author: Carlo Caione + * Copyright (c) 2016 BayLibre, SAS. + * Author: Jerome Brunet + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * The full GNU General Public License is included in this distribution + * in the file called COPYING. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include +#include +#include +#include + +#define IRQ_FREE (-1) + +#define REG_EDGE_POL 0x00 +#define REG_PIN_03_SEL 0x04 +#define REG_PIN_47_SEL 0x08 +#define REG_FILTER_SEL 0x0c + +#define REG_EDGE_POL_MASK(x) (BIT(x) | BIT(16 + (x))) +#define REG_EDGE_POL_EDGE(x) BIT(x) +#define REG_EDGE_POL_LOW(x) BIT(16 + (x)) +#define REG_PIN_SEL_SHIFT(x) (((x) % 4) * 8) +#define REG_FILTER_SEL_SHIFT(x) ((x) * 4) + +struct meson_gpio_irq_params { + unsigned int nhwirq; + irq_hw_number_t *source; + int nsource; +}; + +struct meson_gpio_irq_domain { + void __iomem *base; + int *map; + const struct meson_gpio_irq_params *params; +}; + +struct meson_gpio_irq_chip_data { + void __iomem *base; + int index; +}; + +static irq_hw_number_t meson_parent_hwirqs[] = { + 64, 65, 66, 67, 68, 69, 70, 71, +}; + +static const struct meson_gpio_irq_params meson8_params = { + .nhwirq = 134, + .source = meson_parent_hwirqs, + .nsource = ARRAY_SIZE(meson_parent_hwirqs), +}; + +static const struct meson_gpio_irq_params meson8b_params = { + .nhwirq = 119, + .source = meson_parent_hwirqs, + .nsource = ARRAY_SIZE(meson_parent_hwirqs), +}; + +static const struct meson_gpio_irq_params meson_gxbb_params = { + .nhwirq = 133, + .source = meson_parent_hwirqs, + .nsource = ARRAY_SIZE(meson_parent_hwirqs), +}; + +static const struct of_device_id meson_irq_gpio_matches[] = { + { + .compatible = "amlogic,meson8-gpio-intc", + .data = &meson8_params + }, + { + .compatible = "amlogic,meson8b-gpio-intc", + .data = &meson8b_params + }, + { + .compatible = "amlogic,meson-gxbb-gpio-intc", + .data = &meson_gxbb_params + }, + {} +}; + +static void meson_gpio_irq_update_bits(void __iomem *base, unsigned int reg, + u32 mask, u32 val) +{ + u32 tmp; + + tmp = readl(base + reg); + tmp &= ~mask; + tmp |= val; + + writel(tmp, base + reg); +} + +static int meson_gpio_irq_get_index(struct meson_gpio_irq_domain *domain_data, + int hwirq) +{ + int i; + + for (i = 0; i < domain_data->params->nsource; i++) { + if (domain_data->map[i] == hwirq) + return i; + } + + return -1; +} + +static int mesion_gpio_irq_map_source(struct meson_gpio_irq_domain *domain_data, + irq_hw_number_t hwirq, + irq_hw_number_t *source) +{ + int index; + unsigned int reg; + + index = meson_gpio_irq_get_index(domain_data, IRQ_FREE); + if (index < 0) { + pr_err("No irq available\n"); + return -ENOSPC; + } + + domain_data->map[index] = hwirq; + + reg = (index < 4) ? REG_PIN_03_SEL : REG_PIN_47_SEL; + meson_gpio_irq_update_bits(domain_data->base, reg, + 0xff << REG_PIN_SEL_SHIFT(index), + hwirq << REG_PIN_SEL_SHIFT(index)); + + *source = domain_data->params->source[index]; + + pr_debug("hwirq %lu assigned to channel %d - source %lu\n", + hwirq, index, *source); + + return index; +} + +static int meson_gpio_irq_type_setup(unsigned int type, void __iomem *base, + int index) +{ + u32 val = 0; + + type &= IRQ_TYPE_SENSE_MASK; + + if (type == IRQ_TYPE_EDGE_BOTH) + return -EINVAL; + + if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING)) + val |= REG_EDGE_POL_EDGE(index); + + if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_EDGE_FALLING)) + val |= REG_EDGE_POL_LOW(index); + + meson_gpio_irq_update_bits(base, REG_EDGE_POL, + REG_EDGE_POL_MASK(index), val); + + return 0; +} + +static unsigned int meson_gpio_irq_type_output(unsigned int type) +{ + unsigned int sense = type & IRQ_TYPE_SENSE_MASK; + + type &= ~IRQ_TYPE_SENSE_MASK; + + /* + * If the polarity of interrupt is low, the controller will + * invert the signal for gic + */ + if (sense & (IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW)) + type |= IRQ_TYPE_LEVEL_HIGH; + else if (sense & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING)) + type |= IRQ_TYPE_EDGE_RISING; + + return type; +} + +static int meson_gpio_irq_set_type(struct irq_data *data, unsigned int type) +{ + struct meson_gpio_irq_chip_data *cd = irq_data_get_irq_chip_data(data); + int ret; + + pr_debug("set type of hwirq %lu to %u\n", data->hwirq, type); + + ret = meson_gpio_irq_type_setup(type, cd->base, cd->index); + if (ret) + return ret; + + return irq_chip_set_type_parent(data, + meson_gpio_irq_type_output(type)); +} + +static struct irq_chip meson_gpio_irq_chip = { + .name = "meson-gpio-irqchip", + .irq_mask = irq_chip_mask_parent, + .irq_unmask = irq_chip_unmask_parent, + .irq_eoi = irq_chip_eoi_parent, + .irq_set_type = meson_gpio_irq_set_type, + .irq_retrigger = irq_chip_retrigger_hierarchy, +#ifdef CONFIG_SMP + .irq_set_affinity = irq_chip_set_affinity_parent, +#endif +}; + +static int meson_gpio_irq_domain_translate(struct irq_domain *domain, + struct irq_fwspec *fwspec, + unsigned long *hwirq, + unsigned int *type) +{ + if (is_of_node(fwspec->fwnode)) { + if (fwspec->param_count != 2) + return -EINVAL; + + *hwirq = fwspec->param[0]; + *type = fwspec->param[1]; + + return 0; + } + + return -EINVAL; +} + +static int meson_gpio_irq_allocate_gic_irq(struct irq_domain *domain, + unsigned int virq, + irq_hw_number_t source, + unsigned int type) +{ + struct irq_fwspec fwspec; + + if (!irq_domain_get_of_node(domain->parent)) + return -EINVAL; + + fwspec.fwnode = domain->parent->fwnode; + fwspec.param_count = 3; + fwspec.param[0] = 0; /* SPI */ + fwspec.param[1] = source; + fwspec.param[2] = meson_gpio_irq_type_output(type); + + return irq_domain_alloc_irqs_parent(domain, virq, 1, &fwspec); +} + +static int meson_gpio_irq_domain_alloc(struct irq_domain *domain, + unsigned int virq, + unsigned int nr_irqs, + void *data) +{ + struct irq_fwspec *fwspec = data; + struct meson_gpio_irq_domain *domain_data = domain->host_data; + struct meson_gpio_irq_chip_data *cd; + unsigned long hwirq, source; + unsigned int type; + int i, index, ret; + + ret = meson_gpio_irq_domain_translate(domain, fwspec, &hwirq, &type); + if (ret) + return ret; + + pr_debug("irq %d, nr_irqs %d, hwirqs %lu\n", virq, nr_irqs, hwirq); + + for (i = 0; i < nr_irqs; i++) { + index = mesion_gpio_irq_map_source(domain_data, hwirq + i, + &source); + if (index < 0) + return index; + + ret = meson_gpio_irq_type_setup(type, domain_data->base, + index); + if (ret) + return ret; + + cd = kzalloc(sizeof(*cd), GFP_KERNEL); + if (!cd) + return -ENOMEM; + + cd->base = domain_data->base; + cd->index = index; + + irq_domain_set_hwirq_and_chip(domain, virq + i, hwirq + i, + &meson_gpio_irq_chip, cd); + + ret = meson_gpio_irq_allocate_gic_irq(domain, virq + i, + source, type); + if (ret < 0) + return ret; + } + + return 0; +} + +static void meson_gpio_irq_domain_free(struct irq_domain *domain, + unsigned int virq, + unsigned int nr_irqs) +{ + struct meson_gpio_irq_domain *domain_data = domain->host_data; + struct meson_gpio_irq_chip_data *cd; + struct irq_data *irq_data; + int i; + + for (i = 0; i < nr_irqs; i++) { + irq_data = irq_domain_get_irq_data(domain, virq + i); + cd = irq_data_get_irq_chip_data(irq_data); + + domain_data->map[cd->index] = IRQ_FREE; + kfree(cd); + } + + irq_domain_free_irqs_parent(domain, virq, nr_irqs); + +} + +static const struct irq_domain_ops meson_gpio_irq_domain_ops = { + .alloc = meson_gpio_irq_domain_alloc, + .free = meson_gpio_irq_domain_free, + .translate = meson_gpio_irq_domain_translate, +}; + +static int __init +meson_gpio_irq_init_domain(struct device_node *node, + struct meson_gpio_irq_domain *domain_data, + const struct meson_gpio_irq_params *params) +{ + int i; + int nsource = params->nsource; + int *map; + + map = kcalloc(nsource, sizeof(*map), GFP_KERNEL); + if (!map) + return -ENOMEM; + + for (i = 0; i < nsource; i++) + map[i] = IRQ_FREE; + + domain_data->map = map; + domain_data->params = params; + + return 0; +} + +static int __init meson_gpio_irq_of_init(struct device_node *node, + struct device_node *parent) +{ + struct irq_domain *domain, *parent_domain; + const struct of_device_id *match; + const struct meson_gpio_irq_params *params; + struct meson_gpio_irq_domain *domain_data; + int ret; + + match = of_match_node(meson_irq_gpio_matches, node); + if (!match) + return -ENODEV; + params = match->data; + + if (!parent) { + pr_err("missing parent interrupt node\n"); + return -ENODEV; + } + + parent_domain = irq_find_host(parent); + if (!parent_domain) { + pr_err("unable to obtain parent domain\n"); + return -ENXIO; + } + + domain_data = kzalloc(sizeof(*domain_data), GFP_KERNEL); + if (!domain_data) + return -ENOMEM; + + domain_data->base = of_iomap(node, 0); + if (!domain_data->base) { + ret = -ENOMEM; + goto out_free_dev; + } + + ret = meson_gpio_irq_init_domain(node, domain_data, params); + if (ret < 0) + goto out_free_dev_content; + + domain = irq_domain_add_hierarchy(parent_domain, 0, params->nhwirq, + node, &meson_gpio_irq_domain_ops, + domain_data); + + if (!domain) { + pr_err("failed to allocated domain\n"); + ret = -ENOMEM; + goto out_free_dev_content; + } + + pr_info("%d to %d gpio interrupt mux initialized\n", + params->nhwirq, params->nsource); + + return 0; + +out_free_dev_content: + kfree(domain_data->map); + iounmap(domain_data->base); + +out_free_dev: + kfree(domain_data); + + return ret; +} + +IRQCHIP_DECLARE(meson8_gpio_intc, "amlogic,meson8-gpio-intc", + meson_gpio_irq_of_init); +IRQCHIP_DECLARE(meson8b_gpio_intc, "amlogic,meson8b-gpio-intc", + meson_gpio_irq_of_init); +IRQCHIP_DECLARE(gxbb_gpio_intc, "amlogic,meson-gxbb-gpio-intc", + meson_gpio_irq_of_init);