Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-23 04:31:50 +00:00
Code Issues Packages Projects Releases Wiki Activity
3b81bf78b7
linux/drivers/irqchip/irq-ixp4xx.c
Mark Rutland 0953fb2637 irq: remove handle_domain_{irq,nmi}() 
Now that entry code handles IRQ entry (including setting the IRQ regs)
before calling irqchip code, irqchip code can safely call
generic_handle_domain_irq(), and there's no functional reason for it to
call handle_domain_irq().

Let's cement this split of responsibility and remove handle_domain_irq()
entirely, updating irqchip drivers to call generic_handle_domain_irq().

For consistency, handle_domain_nmi() is similarly removed and replaced
with a generic_handle_domain_nmi() function which also does not perform
any entry logic.

Previously handle_domain_{irq,nmi}() had a WARN_ON() which would fire
when they were called in an inappropriate context. So that we can
identify similar issues going forward, similar WARN_ON_ONCE() logic is
added to the generic_handle_*() functions, and comments are updated for
clarity and consistency.

Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Reviewed-by: Marc Zyngier <maz@kernel.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
2021-10-26 10:13:31 +01:00

404 lines
10 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0
/*
* irqchip for the IXP4xx interrupt controller
* Copyright (C) 2019 Linus Walleij <linus.walleij@linaro.org>
*
* Based on arch/arm/mach-ixp4xx/common.c
* Copyright 2002 (C) Intel Corporation
* Copyright 2003-2004 (C) MontaVista, Software, Inc.
* Copyright (C) Deepak Saxena <dsaxena@plexity.net>
*/
#include <linux/bitops.h>
#include <linux/gpio/driver.h>
#include <linux/irq.h>
#include <linux/io.h>
#include <linux/irqchip.h>
#include <linux/irqchip/irq-ixp4xx.h>
#include <linux/irqdomain.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>
#include <linux/cpu.h>
#include <asm/exception.h>
#include <asm/mach/irq.h>
#define IXP4XX_ICPR 0x00 /* Interrupt Status */
#define IXP4XX_ICMR 0x04 /* Interrupt Enable */
#define IXP4XX_ICLR 0x08 /* Interrupt IRQ/FIQ Select */
#define IXP4XX_ICIP 0x0C /* IRQ Status */
#define IXP4XX_ICFP 0x10 /* FIQ Status */
#define IXP4XX_ICHR 0x14 /* Interrupt Priority */
#define IXP4XX_ICIH 0x18 /* IRQ Highest Pri Int */
#define IXP4XX_ICFH 0x1C /* FIQ Highest Pri Int */
/* IXP43x and IXP46x-only */
#define IXP4XX_ICPR2 0x20 /* Interrupt Status 2 */
#define IXP4XX_ICMR2 0x24 /* Interrupt Enable 2 */
#define IXP4XX_ICLR2 0x28 /* Interrupt IRQ/FIQ Select 2 */
#define IXP4XX_ICIP2 0x2C /* IRQ Status */
#define IXP4XX_ICFP2 0x30 /* FIQ Status */
#define IXP4XX_ICEEN 0x34 /* Error High Pri Enable */
/**
* struct ixp4xx_irq - state container for the Faraday IRQ controller
* @irqbase: IRQ controller memory base in virtual memory
* @is_356: if this is an IXP43x, IXP45x or IX46x SoC (with 64 IRQs)
* @irqchip: irqchip for this instance
* @domain: IRQ domain for this instance
*/
struct ixp4xx_irq {
void __iomem *irqbase;
bool is_356;
struct irq_chip irqchip;
struct irq_domain *domain;
};
/* Local static state container */
static struct ixp4xx_irq ixirq;
/* GPIO Clocks */
#define IXP4XX_GPIO_CLK_0 14
#define IXP4XX_GPIO_CLK_1 15
static int ixp4xx_set_irq_type(struct irq_data *d, unsigned int type)
{
/* All are level active high (asserted) here */
if (type != IRQ_TYPE_LEVEL_HIGH)
return -EINVAL;
return 0;
}
static void ixp4xx_irq_mask(struct irq_data *d)
{
struct ixp4xx_irq *ixi = irq_data_get_irq_chip_data(d);
u32 val;
if (ixi->is_356 && d->hwirq >= 32) {
val = __raw_readl(ixi->irqbase + IXP4XX_ICMR2);
val &= ~BIT(d->hwirq - 32);
__raw_writel(val, ixi->irqbase + IXP4XX_ICMR2);
} else {
val = __raw_readl(ixi->irqbase + IXP4XX_ICMR);
val &= ~BIT(d->hwirq);
__raw_writel(val, ixi->irqbase + IXP4XX_ICMR);
}
}
/*
* Level triggered interrupts on GPIO lines can only be cleared when the
* interrupt condition disappears.
*/
static void ixp4xx_irq_unmask(struct irq_data *d)
{
struct ixp4xx_irq *ixi = irq_data_get_irq_chip_data(d);
u32 val;
if (ixi->is_356 && d->hwirq >= 32) {
val = __raw_readl(ixi->irqbase + IXP4XX_ICMR2);
val |= BIT(d->hwirq - 32);
__raw_writel(val, ixi->irqbase + IXP4XX_ICMR2);
} else {
val = __raw_readl(ixi->irqbase + IXP4XX_ICMR);
val |= BIT(d->hwirq);
__raw_writel(val, ixi->irqbase + IXP4XX_ICMR);
}
}
asmlinkage void __exception_irq_entry ixp4xx_handle_irq(struct pt_regs *regs)
{
struct ixp4xx_irq *ixi = &ixirq;
unsigned long status;
int i;
status = __raw_readl(ixi->irqbase + IXP4XX_ICIP);
for_each_set_bit(i, &status, 32)
generic_handle_domain_irq(ixi->domain, i);
/*
* IXP465/IXP435 has an upper IRQ status register
*/
if (ixi->is_356) {
status = __raw_readl(ixi->irqbase + IXP4XX_ICIP2);
for_each_set_bit(i, &status, 32)
generic_handle_domain_irq(ixi->domain, i + 32);
}
}
static int ixp4xx_irq_domain_translate(struct irq_domain *domain,
struct irq_fwspec *fwspec,
unsigned long *hwirq,
unsigned int *type)
{
/* We support standard DT translation */
if (is_of_node(fwspec->fwnode) && fwspec->param_count == 2) {
*hwirq = fwspec->param[0];
*type = fwspec->param[1];
return 0;
}
if (is_fwnode_irqchip(fwspec->fwnode)) {
if (fwspec->param_count != 2)
return -EINVAL;
*hwirq = fwspec->param[0];
*type = fwspec->param[1];
WARN_ON(*type == IRQ_TYPE_NONE);
return 0;
}
return -EINVAL;
}
static int ixp4xx_irq_domain_alloc(struct irq_domain *d,
unsigned int irq, unsigned int nr_irqs,
void *data)
{
struct ixp4xx_irq *ixi = d->host_data;
irq_hw_number_t hwirq;
unsigned int type = IRQ_TYPE_NONE;
struct irq_fwspec *fwspec = data;
int ret;
int i;
ret = ixp4xx_irq_domain_translate(d, fwspec, &hwirq, &type);
if (ret)
return ret;
for (i = 0; i < nr_irqs; i++) {
/*
* TODO: after converting IXP4xx to only device tree, set
* handle_bad_irq as default handler and assume all consumers
* call .set_type() as this is provided in the second cell in
* the device tree phandle.
*/
irq_domain_set_info(d,
irq + i,
hwirq + i,
&ixi->irqchip,
ixi,
handle_level_irq,
NULL, NULL);
irq_set_probe(irq + i);
}
return 0;
}
/*
* This needs to be a hierarchical irqdomain to work well with the
* GPIO irqchip (which is lower in the hierarchy)
*/
static const struct irq_domain_ops ixp4xx_irqdomain_ops = {
.translate = ixp4xx_irq_domain_translate,
.alloc = ixp4xx_irq_domain_alloc,
.free = irq_domain_free_irqs_common,
};
/**
* ixp4xx_get_irq_domain() - retrieve the ixp4xx irq domain
*
* This function will go away when we transition to DT probing.
*/
struct irq_domain *ixp4xx_get_irq_domain(void)
{
struct ixp4xx_irq *ixi = &ixirq;
return ixi->domain;
}
EXPORT_SYMBOL_GPL(ixp4xx_get_irq_domain);
/*
* This is the Linux IRQ to hwirq mapping table. This goes away when
* we have DT support as all IRQ resources are defined in the device
* tree. It will register all the IRQs that are not used by the hierarchical
* GPIO IRQ chip. The "holes" inbetween these IRQs will be requested by
* the GPIO driver using . This is a step-gap solution.
*/
struct ixp4xx_irq_chunk {
int irq;
int hwirq;
int nr_irqs;
};
static const struct ixp4xx_irq_chunk ixp4xx_irq_chunks[] = {
{
.irq = 16,
.hwirq = 0,
.nr_irqs = 6,
},
{
.irq = 24,
.hwirq = 8,
.nr_irqs = 11,
},
{
.irq = 46,
.hwirq = 30,
.nr_irqs = 2,
},
/* Only on the 436 variants */
{
.irq = 48,
.hwirq = 32,
.nr_irqs = 10,
},
};
/**
* ixp4x_irq_setup() - Common setup code for the IXP4xx interrupt controller
* @ixi: State container
* @irqbase: Virtual memory base for the interrupt controller
* @fwnode: Corresponding fwnode abstraction for this controller
* @is_356: if this is an IXP43x, IXP45x or IXP46x SoC variant
*/
static int __init ixp4xx_irq_setup(struct ixp4xx_irq *ixi,
void __iomem *irqbase,
struct fwnode_handle *fwnode,
bool is_356)
{
int nr_irqs;
ixi->irqbase = irqbase;
ixi->is_356 = is_356;
/* Route all sources to IRQ instead of FIQ */
__raw_writel(0x0, ixi->irqbase + IXP4XX_ICLR);
/* Disable all interrupts */
__raw_writel(0x0, ixi->irqbase + IXP4XX_ICMR);
if (is_356) {
/* Route upper 32 sources to IRQ instead of FIQ */
__raw_writel(0x0, ixi->irqbase + IXP4XX_ICLR2);
/* Disable upper 32 interrupts */
__raw_writel(0x0, ixi->irqbase + IXP4XX_ICMR2);
nr_irqs = 64;
} else {
nr_irqs = 32;
}
ixi->irqchip.name = "IXP4xx";
ixi->irqchip.irq_mask = ixp4xx_irq_mask;
ixi->irqchip.irq_unmask = ixp4xx_irq_unmask;
ixi->irqchip.irq_set_type = ixp4xx_set_irq_type;
ixi->domain = irq_domain_create_linear(fwnode, nr_irqs,
&ixp4xx_irqdomain_ops,
ixi);
if (!ixi->domain) {
pr_crit("IXP4XX: can not add primary irqdomain\n");
return -ENODEV;
}
set_handle_irq(ixp4xx_handle_irq);
return 0;
}
/**
* ixp4xx_irq_init() - Function to initialize the irqchip from boardfiles
* @irqbase: physical base for the irq controller
* @is_356: if this is an IXP43x, IXP45x or IXP46x SoC variant
*/
void __init ixp4xx_irq_init(resource_size_t irqbase,
bool is_356)
{
struct ixp4xx_irq *ixi = &ixirq;
void __iomem *base;
struct fwnode_handle *fwnode;
struct irq_fwspec fwspec;
int nr_chunks;
int ret;
int i;
base = ioremap(irqbase, 0x100);
if (!base) {
pr_crit("IXP4XX: could not ioremap interrupt controller\n");
return;
}
fwnode = irq_domain_alloc_fwnode(&irqbase);
if (!fwnode) {
pr_crit("IXP4XX: no domain handle\n");
return;
}
ret = ixp4xx_irq_setup(ixi, base, fwnode, is_356);
if (ret) {
pr_crit("IXP4XX: failed to set up irqchip\n");
irq_domain_free_fwnode(fwnode);
}
nr_chunks = ARRAY_SIZE(ixp4xx_irq_chunks);
if (!is_356)
nr_chunks--;
/*
* After adding OF support, this is no longer needed: irqs
* will be allocated for the respective fwnodes.
*/
for (i = 0; i < nr_chunks; i++) {
const struct ixp4xx_irq_chunk *chunk = &ixp4xx_irq_chunks[i];
pr_info("Allocate Linux IRQs %d..%d HW IRQs %d..%d\n",
chunk->irq, chunk->irq + chunk->nr_irqs - 1,
chunk->hwirq, chunk->hwirq + chunk->nr_irqs - 1);
fwspec.fwnode = fwnode;
fwspec.param[0] = chunk->hwirq;
fwspec.param[1] = IRQ_TYPE_LEVEL_HIGH;
fwspec.param_count = 2;
ret = __irq_domain_alloc_irqs(ixi->domain,
chunk->irq,
chunk->nr_irqs,
NUMA_NO_NODE,
&fwspec,
false,
NULL);
if (ret < 0) {
pr_crit("IXP4XX: can not allocate irqs in hierarchy %d\n",
ret);
return;
}
}
}
EXPORT_SYMBOL_GPL(ixp4xx_irq_init);
#ifdef CONFIG_OF
int __init ixp4xx_of_init_irq(struct device_node *np,
struct device_node *parent)
{
struct ixp4xx_irq *ixi = &ixirq;
void __iomem *base;
struct fwnode_handle *fwnode;
bool is_356;
int ret;
base = of_iomap(np, 0);
if (!base) {
pr_crit("IXP4XX: could not ioremap interrupt controller\n");
return -ENODEV;
}
fwnode = of_node_to_fwnode(np);
/* These chip variants have 64 interrupts */
is_356 = of_device_is_compatible(np, "intel,ixp43x-interrupt") ||
of_device_is_compatible(np, "intel,ixp45x-interrupt") ||
of_device_is_compatible(np, "intel,ixp46x-interrupt");
ret = ixp4xx_irq_setup(ixi, base, fwnode, is_356);
if (ret)
pr_crit("IXP4XX: failed to set up irqchip\n");
return ret;
}
IRQCHIP_DECLARE(ixp42x, "intel,ixp42x-interrupt",
ixp4xx_of_init_irq);
IRQCHIP_DECLARE(ixp43x, "intel,ixp43x-interrupt",
ixp4xx_of_init_irq);
IRQCHIP_DECLARE(ixp45x, "intel,ixp45x-interrupt",
ixp4xx_of_init_irq);
IRQCHIP_DECLARE(ixp46x, "intel,ixp46x-interrupt",
ixp4xx_of_init_irq);
#endif
Reference in New Issue View Git Blame Copy Permalink