2012-05-19 14:11:47 +08:00
|
|
|
#define pr_fmt(fmt) "irq: " fmt
|
|
|
|
|
|
2012-02-16 16:37:49 +08:00
|
|
|
#include <linux/debugfs.h>
|
|
|
|
|
#include <linux/hardirq.h>
|
|
|
|
|
#include <linux/interrupt.h>
|
2011-07-26 17:19:06 +08:00
|
|
|
#include <linux/irq.h>
|
2012-02-16 16:37:49 +08:00
|
|
|
#include <linux/irqdesc.h>
|
2011-07-26 17:19:06 +08:00
|
|
|
#include <linux/irqdomain.h>
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
|
#include <linux/of.h>
|
2011-07-26 17:19:06 +08:00
|
|
|
#include <linux/of_address.h>
|
2012-06-04 13:04:34 +08:00
|
|
|
#include <linux/topology.h>
|
2012-02-16 16:37:49 +08:00
|
|
|
#include <linux/seq_file.h>
|
2011-07-26 17:19:06 +08:00
|
|
|
#include <linux/slab.h>
|
2012-02-16 16:37:49 +08:00
|
|
|
#include <linux/smp.h>
|
|
|
|
|
#include <linux/fs.h>
|
2011-07-26 17:19:06 +08:00
|
|
|
|
|
|
|
|
static LIST_HEAD(irq_domain_list);
|
|
|
|
|
static DEFINE_MUTEX(irq_domain_mutex);
|
|
|
|
|
|
2012-02-16 16:37:49 +08:00
|
|
|
static DEFINE_MUTEX(revmap_trees_mutex);
|
2012-02-15 05:06:53 +08:00
|
|
|
static struct irq_domain *irq_default_domain;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
/**
|
2013-06-08 19:57:40 +08:00
|
|
|
* __irq_domain_add() - Allocate a new irq_domain data structure
|
2012-02-16 16:37:49 +08:00
|
|
|
* @of_node: optional device-tree node of the interrupt controller
|
2013-06-08 19:57:40 +08:00
|
|
|
* @size: Size of linear map; 0 for radix mapping only
|
|
|
|
|
* @direct_max: Maximum value of direct maps; Use ~0 for no limit; 0 for no
|
|
|
|
|
* direct mapping
|
2012-02-15 05:06:53 +08:00
|
|
|
* @ops: map/unmap domain callbacks
|
2012-02-15 05:06:54 +08:00
|
|
|
* @host_data: Controller private data pointer
|
2012-02-16 16:37:49 +08:00
|
|
|
*
|
2012-02-15 05:06:54 +08:00
|
|
|
* Allocates and initialize and irq_domain structure. Caller is expected to
|
|
|
|
|
* register allocated irq_domain with irq_domain_register(). Returns pointer
|
|
|
|
|
* to IRQ domain, or NULL on failure.
|
2012-02-16 16:37:49 +08:00
|
|
|
*/
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
struct irq_domain *__irq_domain_add(struct device_node *of_node, int size,
|
|
|
|
|
irq_hw_number_t hwirq_max, int direct_max,
|
2013-06-08 19:57:40 +08:00
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
|
void *host_data)
|
2012-02-16 16:37:49 +08:00
|
|
|
{
|
2012-02-15 05:06:54 +08:00
|
|
|
struct irq_domain *domain;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-07-12 00:24:31 +08:00
|
|
|
domain = kzalloc_node(sizeof(*domain) + (sizeof(unsigned int) * size),
|
|
|
|
|
GFP_KERNEL, of_node_to_nid(of_node));
|
2012-02-15 05:06:54 +08:00
|
|
|
if (WARN_ON(!domain))
|
2012-02-16 16:37:49 +08:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
/* Fill structure */
|
2013-06-08 19:03:59 +08:00
|
|
|
INIT_RADIX_TREE(&domain->revmap_tree, GFP_KERNEL);
|
2012-02-15 05:06:53 +08:00
|
|
|
domain->ops = ops;
|
2012-02-15 05:06:54 +08:00
|
|
|
domain->host_data = host_data;
|
2012-02-15 05:06:53 +08:00
|
|
|
domain->of_node = of_node_get(of_node);
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
domain->hwirq_max = hwirq_max;
|
2013-06-08 19:03:59 +08:00
|
|
|
domain->revmap_size = size;
|
2013-06-08 19:57:40 +08:00
|
|
|
domain->revmap_direct_max_irq = direct_max;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-02-15 05:06:54 +08:00
|
|
|
mutex_lock(&irq_domain_mutex);
|
|
|
|
|
list_add(&domain->link, &irq_domain_list);
|
|
|
|
|
mutex_unlock(&irq_domain_mutex);
|
2013-06-08 19:57:40 +08:00
|
|
|
|
2013-06-08 19:03:59 +08:00
|
|
|
pr_debug("Added domain %s\n", domain->name);
|
2013-06-08 19:57:40 +08:00
|
|
|
return domain;
|
2012-02-15 05:06:54 +08:00
|
|
|
}
|
2013-06-08 19:57:40 +08:00
|
|
|
EXPORT_SYMBOL_GPL(__irq_domain_add);
|
2012-02-15 05:06:54 +08:00
|
|
|
|
2012-05-19 14:11:41 +08:00
|
|
|
/**
|
|
|
|
|
* irq_domain_remove() - Remove an irq domain.
|
|
|
|
|
* @domain: domain to remove
|
|
|
|
|
*
|
|
|
|
|
* This routine is used to remove an irq domain. The caller must ensure
|
|
|
|
|
* that all mappings within the domain have been disposed of prior to
|
|
|
|
|
* use, depending on the revmap type.
|
|
|
|
|
*/
|
|
|
|
|
void irq_domain_remove(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
mutex_lock(&irq_domain_mutex);
|
|
|
|
|
|
2012-07-12 00:24:31 +08:00
|
|
|
/*
|
|
|
|
|
* radix_tree_delete() takes care of destroying the root
|
|
|
|
|
* node when all entries are removed. Shout if there are
|
|
|
|
|
* any mappings left.
|
|
|
|
|
*/
|
2013-06-08 19:03:59 +08:00
|
|
|
WARN_ON(domain->revmap_tree.height);
|
2012-05-19 14:11:41 +08:00
|
|
|
|
|
|
|
|
list_del(&domain->link);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If the going away domain is the default one, reset it.
|
|
|
|
|
*/
|
|
|
|
|
if (unlikely(irq_default_domain == domain))
|
|
|
|
|
irq_set_default_host(NULL);
|
|
|
|
|
|
|
|
|
|
mutex_unlock(&irq_domain_mutex);
|
|
|
|
|
|
2013-06-08 19:03:59 +08:00
|
|
|
pr_debug("Removed domain %s\n", domain->name);
|
2012-05-19 14:11:41 +08:00
|
|
|
|
2013-06-08 19:57:40 +08:00
|
|
|
of_node_put(domain->of_node);
|
|
|
|
|
kfree(domain);
|
2012-05-19 14:11:41 +08:00
|
|
|
}
|
2012-05-19 14:11:42 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_domain_remove);
|
2012-05-19 14:11:41 +08:00
|
|
|
|
2012-07-05 19:19:19 +08:00
|
|
|
/**
|
2013-06-08 19:57:40 +08:00
|
|
|
* irq_domain_add_simple() - Register an irq_domain and optionally map a range of irqs
|
2012-07-05 19:19:19 +08:00
|
|
|
* @of_node: pointer to interrupt controller's device tree node.
|
|
|
|
|
* @size: total number of irqs in mapping
|
2013-06-06 19:10:23 +08:00
|
|
|
* @first_irq: first number of irq block assigned to the domain,
|
2013-06-08 19:57:40 +08:00
|
|
|
* pass zero to assign irqs on-the-fly. If first_irq is non-zero, then
|
|
|
|
|
* pre-map all of the irqs in the domain to virqs starting at first_irq.
|
2012-07-05 19:19:19 +08:00
|
|
|
* @ops: map/unmap domain callbacks
|
|
|
|
|
* @host_data: Controller private data pointer
|
|
|
|
|
*
|
2013-06-08 19:57:40 +08:00
|
|
|
* Allocates an irq_domain, and optionally if first_irq is positive then also
|
|
|
|
|
* allocate irq_descs and map all of the hwirqs to virqs starting at first_irq.
|
2012-07-05 19:19:19 +08:00
|
|
|
*
|
|
|
|
|
* This is intended to implement the expected behaviour for most
|
2013-06-08 19:57:40 +08:00
|
|
|
* interrupt controllers. If device tree is used, then first_irq will be 0 and
|
|
|
|
|
* irqs get mapped dynamically on the fly. However, if the controller requires
|
|
|
|
|
* static virq assignments (non-DT boot) then it will set that up correctly.
|
2012-07-05 19:19:19 +08:00
|
|
|
*/
|
|
|
|
|
struct irq_domain *irq_domain_add_simple(struct device_node *of_node,
|
|
|
|
|
unsigned int size,
|
|
|
|
|
unsigned int first_irq,
|
|
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
|
void *host_data)
|
|
|
|
|
{
|
2013-06-08 19:57:40 +08:00
|
|
|
struct irq_domain *domain;
|
|
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
domain = __irq_domain_add(of_node, size, size, 0, ops, host_data);
|
2013-06-08 19:57:40 +08:00
|
|
|
if (!domain)
|
|
|
|
|
return NULL;
|
2012-09-27 20:59:39 +08:00
|
|
|
|
2013-06-08 19:57:40 +08:00
|
|
|
if (first_irq > 0) {
|
2012-09-27 20:59:39 +08:00
|
|
|
if (IS_ENABLED(CONFIG_SPARSE_IRQ)) {
|
2013-06-08 19:57:40 +08:00
|
|
|
/* attempt to allocated irq_descs */
|
|
|
|
|
int rc = irq_alloc_descs(first_irq, first_irq, size,
|
|
|
|
|
of_node_to_nid(of_node));
|
|
|
|
|
if (rc < 0)
|
2012-11-27 08:20:32 +08:00
|
|
|
pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
|
|
|
|
|
first_irq);
|
2013-06-08 19:57:40 +08:00
|
|
|
}
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
irq_domain_associate_many(domain, first_irq, 0, size);
|
2012-09-27 20:59:39 +08:00
|
|
|
}
|
|
|
|
|
|
2013-06-08 19:57:40 +08:00
|
|
|
return domain;
|
2012-07-05 19:19:19 +08:00
|
|
|
}
|
2013-04-26 01:28:54 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_domain_add_simple);
|
2012-07-05 19:19:19 +08:00
|
|
|
|
2012-02-15 05:06:54 +08:00
|
|
|
/**
|
|
|
|
|
* irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
|
|
|
|
|
* @of_node: pointer to interrupt controller's device tree node.
|
2012-02-15 05:06:55 +08:00
|
|
|
* @size: total number of irqs in legacy mapping
|
|
|
|
|
* @first_irq: first number of irq block assigned to the domain
|
|
|
|
|
* @first_hwirq: first hwirq number to use for the translation. Should normally
|
|
|
|
|
* be '0', but a positive integer can be used if the effective
|
|
|
|
|
* hwirqs numbering does not begin at zero.
|
2012-02-15 05:06:54 +08:00
|
|
|
* @ops: map/unmap domain callbacks
|
|
|
|
|
* @host_data: Controller private data pointer
|
|
|
|
|
*
|
|
|
|
|
* Note: the map() callback will be called before this function returns
|
|
|
|
|
* for all legacy interrupts except 0 (which is always the invalid irq for
|
|
|
|
|
* a legacy controller).
|
|
|
|
|
*/
|
|
|
|
|
struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
|
2012-02-15 05:06:55 +08:00
|
|
|
unsigned int size,
|
|
|
|
|
unsigned int first_irq,
|
|
|
|
|
irq_hw_number_t first_hwirq,
|
2012-01-27 03:12:14 +08:00
|
|
|
const struct irq_domain_ops *ops,
|
2012-02-15 05:06:54 +08:00
|
|
|
void *host_data)
|
|
|
|
|
{
|
2012-02-15 05:06:55 +08:00
|
|
|
struct irq_domain *domain;
|
2012-02-15 05:06:54 +08:00
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
domain = __irq_domain_add(of_node, first_hwirq + size,
|
|
|
|
|
first_hwirq + size, 0, ops, host_data);
|
2012-02-15 05:06:54 +08:00
|
|
|
if (!domain)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
irq_domain_associate_many(domain, first_irq, first_hwirq, size);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-02-15 05:06:54 +08:00
|
|
|
return domain;
|
|
|
|
|
}
|
2012-05-19 14:11:42 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_domain_add_legacy);
|
2012-02-15 05:06:54 +08:00
|
|
|
|
2012-02-16 16:37:49 +08:00
|
|
|
/**
|
|
|
|
|
* irq_find_host() - Locates a domain for a given device node
|
|
|
|
|
* @node: device-tree node of the interrupt controller
|
|
|
|
|
*/
|
|
|
|
|
struct irq_domain *irq_find_host(struct device_node *node)
|
|
|
|
|
{
|
|
|
|
|
struct irq_domain *h, *found = NULL;
|
2012-01-27 03:12:14 +08:00
|
|
|
int rc;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
/* We might want to match the legacy controller last since
|
|
|
|
|
* it might potentially be set to match all interrupts in
|
|
|
|
|
* the absence of a device node. This isn't a problem so far
|
|
|
|
|
* yet though...
|
|
|
|
|
*/
|
|
|
|
|
mutex_lock(&irq_domain_mutex);
|
2012-01-27 03:12:14 +08:00
|
|
|
list_for_each_entry(h, &irq_domain_list, link) {
|
|
|
|
|
if (h->ops->match)
|
|
|
|
|
rc = h->ops->match(h, node);
|
|
|
|
|
else
|
|
|
|
|
rc = (h->of_node != NULL) && (h->of_node == node);
|
|
|
|
|
|
|
|
|
|
if (rc) {
|
2012-02-16 16:37:49 +08:00
|
|
|
found = h;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-01-27 03:12:14 +08:00
|
|
|
}
|
2012-02-16 16:37:49 +08:00
|
|
|
mutex_unlock(&irq_domain_mutex);
|
|
|
|
|
return found;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(irq_find_host);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irq_set_default_host() - Set a "default" irq domain
|
2012-02-15 05:06:53 +08:00
|
|
|
* @domain: default domain pointer
|
2012-02-16 16:37:49 +08:00
|
|
|
*
|
|
|
|
|
* For convenience, it's possible to set a "default" domain that will be used
|
|
|
|
|
* whenever NULL is passed to irq_create_mapping(). It makes life easier for
|
|
|
|
|
* platforms that want to manipulate a few hard coded interrupt numbers that
|
|
|
|
|
* aren't properly represented in the device-tree.
|
|
|
|
|
*/
|
2012-02-15 05:06:53 +08:00
|
|
|
void irq_set_default_host(struct irq_domain *domain)
|
2012-02-16 16:37:49 +08:00
|
|
|
{
|
2012-05-19 14:11:47 +08:00
|
|
|
pr_debug("Default domain set to @0x%p\n", domain);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-02-15 05:06:53 +08:00
|
|
|
irq_default_domain = domain;
|
2012-02-16 16:37:49 +08:00
|
|
|
}
|
2012-05-19 14:11:42 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_set_default_host);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
static void irq_domain_disassociate(struct irq_domain *domain, unsigned int irq)
|
2012-06-04 13:04:35 +08:00
|
|
|
{
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
struct irq_data *irq_data = irq_get_irq_data(irq);
|
|
|
|
|
irq_hw_number_t hwirq;
|
|
|
|
|
|
|
|
|
|
if (WARN(!irq_data || irq_data->domain != domain,
|
|
|
|
|
"virq%i doesn't exist; cannot disassociate\n", irq))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
hwirq = irq_data->hwirq;
|
|
|
|
|
irq_set_status_flags(irq, IRQ_NOREQUEST);
|
|
|
|
|
|
|
|
|
|
/* remove chip and handler */
|
|
|
|
|
irq_set_chip_and_handler(irq, NULL, NULL);
|
|
|
|
|
|
|
|
|
|
/* Make sure it's completed */
|
|
|
|
|
synchronize_irq(irq);
|
|
|
|
|
|
|
|
|
|
/* Tell the PIC about it */
|
|
|
|
|
if (domain->ops->unmap)
|
|
|
|
|
domain->ops->unmap(domain, irq);
|
|
|
|
|
smp_mb();
|
|
|
|
|
|
|
|
|
|
irq_data->domain = NULL;
|
|
|
|
|
irq_data->hwirq = 0;
|
|
|
|
|
|
|
|
|
|
/* Clear reverse map for this hwirq */
|
|
|
|
|
if (hwirq < domain->revmap_size) {
|
|
|
|
|
domain->linear_revmap[hwirq] = 0;
|
|
|
|
|
} else {
|
|
|
|
|
mutex_lock(&revmap_trees_mutex);
|
|
|
|
|
radix_tree_delete(&domain->revmap_tree, hwirq);
|
|
|
|
|
mutex_unlock(&revmap_trees_mutex);
|
2012-06-04 13:04:35 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
int irq_domain_associate(struct irq_domain *domain, unsigned int virq,
|
|
|
|
|
irq_hw_number_t hwirq)
|
2012-02-16 16:37:49 +08:00
|
|
|
{
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
struct irq_data *irq_data = irq_get_irq_data(virq);
|
|
|
|
|
int ret;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
if (WARN(hwirq >= domain->hwirq_max,
|
|
|
|
|
"error: hwirq 0x%x is too large for %s\n", (int)hwirq, domain->name))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (WARN(!irq_data, "error: virq%i is not allocated", virq))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (WARN(irq_data->domain, "error: virq%i is already associated", virq))
|
|
|
|
|
return -EINVAL;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
mutex_lock(&irq_domain_mutex);
|
|
|
|
|
irq_data->hwirq = hwirq;
|
|
|
|
|
irq_data->domain = domain;
|
|
|
|
|
if (domain->ops->map) {
|
|
|
|
|
ret = domain->ops->map(domain, virq, hwirq);
|
|
|
|
|
if (ret != 0) {
|
|
|
|
|
/*
|
|
|
|
|
* If map() returns -EPERM, this interrupt is protected
|
|
|
|
|
* by the firmware or some other service and shall not
|
|
|
|
|
* be mapped. Don't bother telling the user about it.
|
|
|
|
|
*/
|
|
|
|
|
if (ret != -EPERM) {
|
|
|
|
|
pr_info("%s didn't like hwirq-0x%lx to VIRQ%i mapping (rc=%d)\n",
|
|
|
|
|
domain->name, hwirq, virq, ret);
|
2012-07-20 17:33:19 +08:00
|
|
|
}
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
irq_data->domain = NULL;
|
|
|
|
|
irq_data->hwirq = 0;
|
|
|
|
|
mutex_unlock(&irq_domain_mutex);
|
|
|
|
|
return ret;
|
2012-06-18 06:17:04 +08:00
|
|
|
}
|
|
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
/* If not already assigned, give the domain the chip's name */
|
|
|
|
|
if (!domain->name && irq_data->chip)
|
|
|
|
|
domain->name = irq_data->chip->name;
|
|
|
|
|
}
|
2012-06-04 13:04:36 +08:00
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
if (hwirq < domain->revmap_size) {
|
|
|
|
|
domain->linear_revmap[hwirq] = virq;
|
|
|
|
|
} else {
|
|
|
|
|
mutex_lock(&revmap_trees_mutex);
|
|
|
|
|
radix_tree_insert(&domain->revmap_tree, hwirq, irq_data);
|
|
|
|
|
mutex_unlock(&revmap_trees_mutex);
|
2012-06-18 06:17:04 +08:00
|
|
|
}
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
mutex_unlock(&irq_domain_mutex);
|
|
|
|
|
|
|
|
|
|
irq_clear_status_flags(virq, IRQ_NOREQUEST);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_domain_associate);
|
|
|
|
|
|
|
|
|
|
void irq_domain_associate_many(struct irq_domain *domain, unsigned int irq_base,
|
|
|
|
|
irq_hw_number_t hwirq_base, int count)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
pr_debug("%s(%s, irqbase=%i, hwbase=%i, count=%i)\n", __func__,
|
|
|
|
|
of_node_full_name(domain->of_node), irq_base, (int)hwirq_base, count);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
|
irq_domain_associate(domain, irq_base + i, hwirq_base + i);
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-06-18 06:17:04 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_domain_associate_many);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irq_create_direct_mapping() - Allocate an irq for direct mapping
|
2012-02-15 05:06:53 +08:00
|
|
|
* @domain: domain to allocate the irq for or NULL for default domain
|
2012-02-16 16:37:49 +08:00
|
|
|
*
|
|
|
|
|
* This routine is used for irq controllers which can choose the hardware
|
|
|
|
|
* interrupt numbers they generate. In such a case it's simplest to use
|
2013-06-08 19:03:59 +08:00
|
|
|
* the linux irq as the hardware interrupt number. It still uses the linear
|
|
|
|
|
* or radix tree to store the mapping, but the irq controller can optimize
|
|
|
|
|
* the revmap path by using the hwirq directly.
|
2012-02-16 16:37:49 +08:00
|
|
|
*/
|
2012-02-15 05:06:53 +08:00
|
|
|
unsigned int irq_create_direct_mapping(struct irq_domain *domain)
|
2012-02-16 16:37:49 +08:00
|
|
|
{
|
|
|
|
|
unsigned int virq;
|
|
|
|
|
|
2012-02-15 05:06:53 +08:00
|
|
|
if (domain == NULL)
|
|
|
|
|
domain = irq_default_domain;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-06-04 13:04:34 +08:00
|
|
|
virq = irq_alloc_desc_from(1, of_node_to_nid(domain->of_node));
|
2012-02-15 05:06:52 +08:00
|
|
|
if (!virq) {
|
2012-05-19 14:11:47 +08:00
|
|
|
pr_debug("create_direct virq allocation failed\n");
|
2012-02-15 05:06:52 +08:00
|
|
|
return 0;
|
2012-02-16 16:37:49 +08:00
|
|
|
}
|
2013-06-08 19:03:59 +08:00
|
|
|
if (virq >= domain->revmap_direct_max_irq) {
|
2012-02-16 16:37:49 +08:00
|
|
|
pr_err("ERROR: no free irqs available below %i maximum\n",
|
2013-06-08 19:03:59 +08:00
|
|
|
domain->revmap_direct_max_irq);
|
2012-02-16 16:37:49 +08:00
|
|
|
irq_free_desc(virq);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2012-05-19 14:11:47 +08:00
|
|
|
pr_debug("create_direct obtained virq %d\n", virq);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-06-18 06:17:04 +08:00
|
|
|
if (irq_domain_associate(domain, virq, virq)) {
|
2012-02-16 16:37:49 +08:00
|
|
|
irq_free_desc(virq);
|
2012-02-15 05:06:52 +08:00
|
|
|
return 0;
|
2012-02-16 16:37:49 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return virq;
|
|
|
|
|
}
|
2012-05-19 14:11:42 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_create_direct_mapping);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irq_create_mapping() - Map a hardware interrupt into linux irq space
|
2012-02-15 05:06:53 +08:00
|
|
|
* @domain: domain owning this hardware interrupt or NULL for default domain
|
|
|
|
|
* @hwirq: hardware irq number in that domain space
|
2012-02-16 16:37:49 +08:00
|
|
|
*
|
|
|
|
|
* Only one mapping per hardware interrupt is permitted. Returns a linux
|
|
|
|
|
* irq number.
|
|
|
|
|
* If the sense/trigger is to be specified, set_irq_type() should be called
|
|
|
|
|
* on the number returned from that call.
|
|
|
|
|
*/
|
2012-02-15 05:06:53 +08:00
|
|
|
unsigned int irq_create_mapping(struct irq_domain *domain,
|
2012-02-16 16:37:49 +08:00
|
|
|
irq_hw_number_t hwirq)
|
|
|
|
|
{
|
2012-04-06 07:52:13 +08:00
|
|
|
unsigned int hint;
|
|
|
|
|
int virq;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-05-19 14:11:47 +08:00
|
|
|
pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain, hwirq);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-02-15 05:06:53 +08:00
|
|
|
/* Look for default domain if nececssary */
|
|
|
|
|
if (domain == NULL)
|
|
|
|
|
domain = irq_default_domain;
|
|
|
|
|
if (domain == NULL) {
|
2013-06-06 19:20:27 +08:00
|
|
|
WARN(1, "%s(, %lx) called with NULL domain\n", __func__, hwirq);
|
2012-02-15 05:06:52 +08:00
|
|
|
return 0;
|
2012-02-16 16:37:49 +08:00
|
|
|
}
|
2012-05-19 14:11:47 +08:00
|
|
|
pr_debug("-> using domain @%p\n", domain);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
/* Check if mapping already exists */
|
2012-02-15 05:06:53 +08:00
|
|
|
virq = irq_find_mapping(domain, hwirq);
|
2012-02-15 05:06:52 +08:00
|
|
|
if (virq) {
|
2012-05-19 14:11:47 +08:00
|
|
|
pr_debug("-> existing mapping on virq %d\n", virq);
|
2012-02-16 16:37:49 +08:00
|
|
|
return virq;
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-15 05:06:55 +08:00
|
|
|
/* Allocate a virtual interrupt number */
|
2012-02-16 06:06:08 +08:00
|
|
|
hint = hwirq % nr_irqs;
|
2012-02-15 05:06:55 +08:00
|
|
|
if (hint == 0)
|
|
|
|
|
hint++;
|
2012-06-04 13:04:34 +08:00
|
|
|
virq = irq_alloc_desc_from(hint, of_node_to_nid(domain->of_node));
|
2012-04-06 07:52:13 +08:00
|
|
|
if (virq <= 0)
|
2012-06-04 13:04:34 +08:00
|
|
|
virq = irq_alloc_desc_from(1, of_node_to_nid(domain->of_node));
|
2012-04-06 07:52:13 +08:00
|
|
|
if (virq <= 0) {
|
2012-05-19 14:11:47 +08:00
|
|
|
pr_debug("-> virq allocation failed\n");
|
2012-02-15 05:06:55 +08:00
|
|
|
return 0;
|
2012-02-16 16:37:49 +08:00
|
|
|
}
|
|
|
|
|
|
2012-06-18 06:17:04 +08:00
|
|
|
if (irq_domain_associate(domain, virq, hwirq)) {
|
2012-06-04 13:04:35 +08:00
|
|
|
irq_free_desc(virq);
|
2012-02-15 05:06:52 +08:00
|
|
|
return 0;
|
2012-02-16 16:37:49 +08:00
|
|
|
}
|
|
|
|
|
|
2012-05-19 14:11:47 +08:00
|
|
|
pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
|
2012-06-04 13:04:33 +08:00
|
|
|
hwirq, of_node_full_name(domain->of_node), virq);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
return virq;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(irq_create_mapping);
|
|
|
|
|
|
2012-06-18 06:17:04 +08:00
|
|
|
/**
|
|
|
|
|
* irq_create_strict_mappings() - Map a range of hw irqs to fixed linux irqs
|
|
|
|
|
* @domain: domain owning the interrupt range
|
|
|
|
|
* @irq_base: beginning of linux IRQ range
|
|
|
|
|
* @hwirq_base: beginning of hardware IRQ range
|
|
|
|
|
* @count: Number of interrupts to map
|
|
|
|
|
*
|
|
|
|
|
* This routine is used for allocating and mapping a range of hardware
|
|
|
|
|
* irqs to linux irqs where the linux irq numbers are at pre-defined
|
|
|
|
|
* locations. For use by controllers that already have static mappings
|
|
|
|
|
* to insert in to the domain.
|
|
|
|
|
*
|
|
|
|
|
* Non-linear users can use irq_create_identity_mapping() for IRQ-at-a-time
|
|
|
|
|
* domain insertion.
|
|
|
|
|
*
|
|
|
|
|
* 0 is returned upon success, while any failure to establish a static
|
|
|
|
|
* mapping is treated as an error.
|
|
|
|
|
*/
|
|
|
|
|
int irq_create_strict_mappings(struct irq_domain *domain, unsigned int irq_base,
|
|
|
|
|
irq_hw_number_t hwirq_base, int count)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
ret = irq_alloc_descs(irq_base, irq_base, count,
|
|
|
|
|
of_node_to_nid(domain->of_node));
|
|
|
|
|
if (unlikely(ret < 0))
|
|
|
|
|
return ret;
|
|
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
irq_domain_associate_many(domain, irq_base, hwirq_base, count);
|
2012-06-18 06:17:04 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(irq_create_strict_mappings);
|
|
|
|
|
|
2012-02-16 16:37:49 +08:00
|
|
|
unsigned int irq_create_of_mapping(struct device_node *controller,
|
|
|
|
|
const u32 *intspec, unsigned int intsize)
|
|
|
|
|
{
|
2012-02-15 05:06:53 +08:00
|
|
|
struct irq_domain *domain;
|
2012-02-16 16:37:49 +08:00
|
|
|
irq_hw_number_t hwirq;
|
|
|
|
|
unsigned int type = IRQ_TYPE_NONE;
|
|
|
|
|
unsigned int virq;
|
|
|
|
|
|
2012-02-15 05:06:53 +08:00
|
|
|
domain = controller ? irq_find_host(controller) : irq_default_domain;
|
|
|
|
|
if (!domain) {
|
2012-02-24 23:07:06 +08:00
|
|
|
#ifdef CONFIG_MIPS
|
|
|
|
|
/*
|
|
|
|
|
* Workaround to avoid breaking interrupt controller drivers
|
|
|
|
|
* that don't yet register an irq_domain. This is temporary
|
|
|
|
|
* code. ~~~gcl, Feb 24, 2012
|
|
|
|
|
*
|
|
|
|
|
* Scheduled for removal in Linux v3.6. That should be enough
|
|
|
|
|
* time.
|
|
|
|
|
*/
|
|
|
|
|
if (intsize > 0)
|
|
|
|
|
return intspec[0];
|
|
|
|
|
#endif
|
2013-06-06 19:20:27 +08:00
|
|
|
pr_warn("no irq domain found for %s !\n",
|
|
|
|
|
of_node_full_name(controller));
|
2012-02-15 05:06:52 +08:00
|
|
|
return 0;
|
2012-02-16 16:37:49 +08:00
|
|
|
}
|
|
|
|
|
|
2012-02-15 05:06:53 +08:00
|
|
|
/* If domain has no translation, then we assume interrupt line */
|
|
|
|
|
if (domain->ops->xlate == NULL)
|
2012-02-16 16:37:49 +08:00
|
|
|
hwirq = intspec[0];
|
|
|
|
|
else {
|
2012-02-15 05:06:53 +08:00
|
|
|
if (domain->ops->xlate(domain, controller, intspec, intsize,
|
2012-02-16 16:37:49 +08:00
|
|
|
&hwirq, &type))
|
2012-02-15 05:06:52 +08:00
|
|
|
return 0;
|
2012-02-16 16:37:49 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Create mapping */
|
2012-02-15 05:06:53 +08:00
|
|
|
virq = irq_create_mapping(domain, hwirq);
|
2012-02-15 05:06:52 +08:00
|
|
|
if (!virq)
|
2012-02-16 16:37:49 +08:00
|
|
|
return virq;
|
|
|
|
|
|
|
|
|
|
/* Set type if specified and different than the current one */
|
|
|
|
|
if (type != IRQ_TYPE_NONE &&
|
|
|
|
|
type != (irqd_get_trigger_type(irq_get_irq_data(virq))))
|
|
|
|
|
irq_set_irq_type(virq, type);
|
|
|
|
|
return virq;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(irq_create_of_mapping);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irq_dispose_mapping() - Unmap an interrupt
|
|
|
|
|
* @virq: linux irq number of the interrupt to unmap
|
|
|
|
|
*/
|
|
|
|
|
void irq_dispose_mapping(unsigned int virq)
|
|
|
|
|
{
|
|
|
|
|
struct irq_data *irq_data = irq_get_irq_data(virq);
|
2012-02-15 05:06:53 +08:00
|
|
|
struct irq_domain *domain;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-02-15 05:06:52 +08:00
|
|
|
if (!virq || !irq_data)
|
2012-02-16 16:37:49 +08:00
|
|
|
return;
|
|
|
|
|
|
2012-02-15 05:06:53 +08:00
|
|
|
domain = irq_data->domain;
|
|
|
|
|
if (WARN_ON(domain == NULL))
|
2012-02-16 16:37:49 +08:00
|
|
|
return;
|
|
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 08:06:02 +08:00
|
|
|
irq_domain_disassociate(domain, virq);
|
2012-02-16 16:37:49 +08:00
|
|
|
irq_free_desc(virq);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(irq_dispose_mapping);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irq_find_mapping() - Find a linux irq from an hw irq number.
|
2012-02-15 05:06:53 +08:00
|
|
|
* @domain: domain owning this hardware interrupt
|
|
|
|
|
* @hwirq: hardware irq number in that domain space
|
2012-02-16 16:37:49 +08:00
|
|
|
*/
|
2012-02-15 05:06:53 +08:00
|
|
|
unsigned int irq_find_mapping(struct irq_domain *domain,
|
2012-02-16 16:37:49 +08:00
|
|
|
irq_hw_number_t hwirq)
|
|
|
|
|
{
|
2012-06-04 13:04:39 +08:00
|
|
|
struct irq_data *data;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-02-15 05:06:53 +08:00
|
|
|
/* Look for default domain if nececssary */
|
|
|
|
|
if (domain == NULL)
|
|
|
|
|
domain = irq_default_domain;
|
|
|
|
|
if (domain == NULL)
|
2012-02-15 05:06:52 +08:00
|
|
|
return 0;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2013-06-08 19:03:59 +08:00
|
|
|
if (hwirq < domain->revmap_direct_max_irq) {
|
2012-06-04 13:04:39 +08:00
|
|
|
data = irq_get_irq_data(hwirq);
|
2012-02-15 05:06:53 +08:00
|
|
|
if (data && (data->domain == domain) && (data->hwirq == hwirq))
|
2012-06-04 13:04:39 +08:00
|
|
|
return hwirq;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 19:19:17 +08:00
|
|
|
/* Check if the hwirq is in the linear revmap. */
|
|
|
|
|
if (hwirq < domain->revmap_size)
|
|
|
|
|
return domain->linear_revmap[hwirq];
|
|
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
data = radix_tree_lookup(&domain->revmap_tree, hwirq);
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
return data ? data->irq : 0;
|
2012-02-16 16:37:49 +08:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(irq_find_mapping);
|
|
|
|
|
|
2012-03-30 04:10:30 +08:00
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_DEBUG
|
2012-02-16 16:37:49 +08:00
|
|
|
static int virq_debug_show(struct seq_file *m, void *private)
|
|
|
|
|
{
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
struct irq_desc *desc;
|
2013-06-07 05:20:44 +08:00
|
|
|
struct irq_domain *domain;
|
|
|
|
|
struct radix_tree_iter iter;
|
|
|
|
|
void *data, **slot;
|
2012-02-16 16:37:49 +08:00
|
|
|
int i;
|
|
|
|
|
|
2013-06-07 05:20:44 +08:00
|
|
|
seq_printf(m, " %-16s %-6s %-10s %-10s %s\n",
|
|
|
|
|
"name", "mapped", "linear-max", "direct-max", "devtree-node");
|
|
|
|
|
mutex_lock(&irq_domain_mutex);
|
|
|
|
|
list_for_each_entry(domain, &irq_domain_list, link) {
|
|
|
|
|
int count = 0;
|
|
|
|
|
radix_tree_for_each_slot(slot, &domain->revmap_tree, &iter, 0)
|
|
|
|
|
count++;
|
|
|
|
|
seq_printf(m, "%c%-16s %6u %10u %10u %s\n",
|
|
|
|
|
domain == irq_default_domain ? '*' : ' ', domain->name,
|
|
|
|
|
domain->revmap_size + count, domain->revmap_size,
|
|
|
|
|
domain->revmap_direct_max_irq,
|
|
|
|
|
domain->of_node ? of_node_full_name(domain->of_node) : "");
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&irq_domain_mutex);
|
|
|
|
|
|
|
|
|
|
seq_printf(m, "%-5s %-7s %-15s %-*s %6s %-14s %s\n", "irq", "hwirq",
|
2012-04-13 04:42:15 +08:00
|
|
|
"chip name", (int)(2 * sizeof(void *) + 2), "chip data",
|
2013-06-07 05:20:44 +08:00
|
|
|
"active", "type", "domain");
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
for (i = 1; i < nr_irqs; i++) {
|
|
|
|
|
desc = irq_to_desc(i);
|
|
|
|
|
if (!desc)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2013-06-07 05:20:44 +08:00
|
|
|
domain = desc->irq_data.domain;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2013-06-07 05:20:44 +08:00
|
|
|
if (domain) {
|
2012-02-16 16:37:49 +08:00
|
|
|
struct irq_chip *chip;
|
2013-06-07 05:20:44 +08:00
|
|
|
int hwirq = desc->irq_data.hwirq;
|
|
|
|
|
bool direct;
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
seq_printf(m, "%5d ", i);
|
2013-06-07 05:20:44 +08:00
|
|
|
seq_printf(m, "0x%05x ", hwirq);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
chip = irq_desc_get_chip(desc);
|
2013-06-06 21:23:30 +08:00
|
|
|
seq_printf(m, "%-15s ", (chip && chip->name) ? chip->name : "none");
|
2012-02-16 16:37:49 +08:00
|
|
|
|
|
|
|
|
data = irq_desc_get_chip_data(desc);
|
2012-04-11 14:26:25 +08:00
|
|
|
seq_printf(m, data ? "0x%p " : " %p ", data);
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2013-06-07 05:20:44 +08:00
|
|
|
seq_printf(m, " %c ", (desc->action && desc->action->handler) ? '*' : ' ');
|
|
|
|
|
direct = (i == hwirq) && (i < domain->revmap_direct_max_irq);
|
|
|
|
|
seq_printf(m, "%6s%-8s ",
|
|
|
|
|
(hwirq < domain->revmap_size) ? "LINEAR" : "RADIX",
|
|
|
|
|
direct ? "(DIRECT)" : "");
|
2013-06-06 21:23:30 +08:00
|
|
|
seq_printf(m, "%s\n", desc->irq_data.domain->name);
|
2012-02-16 16:37:49 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int virq_debug_open(struct inode *inode, struct file *file)
|
|
|
|
|
{
|
|
|
|
|
return single_open(file, virq_debug_show, inode->i_private);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct file_operations virq_debug_fops = {
|
|
|
|
|
.open = virq_debug_open,
|
|
|
|
|
.read = seq_read,
|
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
|
.release = single_release,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int __init irq_debugfs_init(void)
|
|
|
|
|
{
|
2012-03-30 04:10:30 +08:00
|
|
|
if (debugfs_create_file("irq_domain_mapping", S_IRUGO, NULL,
|
2012-02-16 16:37:49 +08:00
|
|
|
NULL, &virq_debug_fops) == NULL)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
__initcall(irq_debugfs_init);
|
2012-03-30 04:10:30 +08:00
|
|
|
#endif /* CONFIG_IRQ_DOMAIN_DEBUG */
|
2012-02-16 16:37:49 +08:00
|
|
|
|
2012-01-27 02:26:52 +08:00
|
|
|
/**
|
|
|
|
|
* irq_domain_xlate_onecell() - Generic xlate for direct one cell bindings
|
|
|
|
|
*
|
|
|
|
|
* Device Tree IRQ specifier translation function which works with one cell
|
|
|
|
|
* bindings where the cell value maps directly to the hwirq number.
|
|
|
|
|
*/
|
|
|
|
|
int irq_domain_xlate_onecell(struct irq_domain *d, struct device_node *ctrlr,
|
|
|
|
|
const u32 *intspec, unsigned int intsize,
|
|
|
|
|
unsigned long *out_hwirq, unsigned int *out_type)
|
2011-07-26 17:19:06 +08:00
|
|
|
{
|
2012-01-27 02:26:52 +08:00
|
|
|
if (WARN_ON(intsize < 1))
|
2011-07-26 17:19:06 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
*out_hwirq = intspec[0];
|
|
|
|
|
*out_type = IRQ_TYPE_NONE;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2012-01-27 02:26:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_domain_xlate_onecell);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irq_domain_xlate_twocell() - Generic xlate for direct two cell bindings
|
|
|
|
|
*
|
|
|
|
|
* Device Tree IRQ specifier translation function which works with two cell
|
|
|
|
|
* bindings where the cell values map directly to the hwirq number
|
|
|
|
|
* and linux irq flags.
|
|
|
|
|
*/
|
|
|
|
|
int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr,
|
|
|
|
|
const u32 *intspec, unsigned int intsize,
|
|
|
|
|
irq_hw_number_t *out_hwirq, unsigned int *out_type)
|
|
|
|
|
{
|
|
|
|
|
if (WARN_ON(intsize < 2))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
*out_hwirq = intspec[0];
|
|
|
|
|
*out_type = intspec[1] & IRQ_TYPE_SENSE_MASK;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(irq_domain_xlate_twocell);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irq_domain_xlate_onetwocell() - Generic xlate for one or two cell bindings
|
|
|
|
|
*
|
|
|
|
|
* Device Tree IRQ specifier translation function which works with either one
|
|
|
|
|
* or two cell bindings where the cell values map directly to the hwirq number
|
|
|
|
|
* and linux irq flags.
|
|
|
|
|
*
|
|
|
|
|
* Note: don't use this function unless your interrupt controller explicitly
|
|
|
|
|
* supports both one and two cell bindings. For the majority of controllers
|
|
|
|
|
* the _onecell() or _twocell() variants above should be used.
|
|
|
|
|
*/
|
|
|
|
|
int irq_domain_xlate_onetwocell(struct irq_domain *d,
|
|
|
|
|
struct device_node *ctrlr,
|
|
|
|
|
const u32 *intspec, unsigned int intsize,
|
|
|
|
|
unsigned long *out_hwirq, unsigned int *out_type)
|
|
|
|
|
{
|
|
|
|
|
if (WARN_ON(intsize < 1))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
*out_hwirq = intspec[0];
|
|
|
|
|
*out_type = (intsize > 1) ? intspec[1] : IRQ_TYPE_NONE;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(irq_domain_xlate_onetwocell);
|
2011-07-26 17:19:06 +08:00
|
|
|
|
2012-01-27 03:12:14 +08:00
|
|
|
const struct irq_domain_ops irq_domain_simple_ops = {
|
2012-01-27 02:26:52 +08:00
|
|
|
.xlate = irq_domain_xlate_onetwocell,
|
2012-02-15 05:06:57 +08:00
|
|
|
};
|
|
|
|
|
EXPORT_SYMBOL_GPL(irq_domain_simple_ops);
|
