2011-07-26 16:19:06 +07:00
|
|
|
/*
|
|
|
|
* irq_domain - IRQ translation domains
|
|
|
|
*
|
|
|
|
* Translation infrastructure between hw and linux irq numbers. This is
|
|
|
|
* helpful for interrupt controllers to implement mapping between hardware
|
|
|
|
* irq numbers and the Linux irq number space.
|
|
|
|
*
|
|
|
|
* irq_domains also have a hook for translating device tree interrupt
|
|
|
|
* representation into a hardware irq number that can be mapped back to a
|
|
|
|
* Linux irq number without any extra platform support code.
|
|
|
|
*
|
2012-02-15 04:06:48 +07:00
|
|
|
* Interrupt controller "domain" data structure. This could be defined as a
|
|
|
|
* irq domain controller. That is, it handles the mapping between hardware
|
|
|
|
* and virtual interrupt numbers for a given interrupt domain. The domain
|
|
|
|
* structure is generally created by the PIC code for a given PIC instance
|
|
|
|
* (though a domain can cover more than one PIC if they have a flat number
|
|
|
|
* model). It's the domain callbacks that are responsible for setting the
|
|
|
|
* irq_chip on a given irq_desc after it's been mapped.
|
2012-02-16 15:37:49 +07:00
|
|
|
*
|
|
|
|
* The host code and data structures are agnostic to whether or not
|
|
|
|
* we use an open firmware device-tree. We do have references to struct
|
|
|
|
* device_node in two places: in irq_find_host() to find the host matching
|
|
|
|
* a given interrupt controller node, and of course as an argument to its
|
|
|
|
* counterpart domain->ops->match() callback. However, those are treated as
|
|
|
|
* generic pointers by the core and the fact that it's actually a device-node
|
|
|
|
* pointer is purely a convention between callers and implementation. This
|
|
|
|
* code could thus be used on other architectures by replacing those two
|
|
|
|
* by some sort of arch-specific void * "token" used to identify interrupt
|
|
|
|
* controllers.
|
2011-07-26 16:19:06 +07:00
|
|
|
*/
|
2012-02-15 04:06:48 +07:00
|
|
|
|
2011-07-26 16:19:06 +07:00
|
|
|
#ifndef _LINUX_IRQDOMAIN_H
|
|
|
|
#define _LINUX_IRQDOMAIN_H
|
|
|
|
|
2012-02-15 04:06:48 +07:00
|
|
|
#include <linux/types.h>
|
2014-11-09 22:10:24 +07:00
|
|
|
#include <linux/irqhandler.h>
|
2012-02-15 04:06:48 +07:00
|
|
|
#include <linux/radix-tree.h>
|
2011-07-26 16:19:06 +07:00
|
|
|
|
|
|
|
struct device_node;
|
|
|
|
struct irq_domain;
|
2012-02-15 04:06:48 +07:00
|
|
|
struct of_device_id;
|
2014-11-06 21:20:14 +07:00
|
|
|
struct irq_chip;
|
|
|
|
struct irq_data;
|
2012-02-15 04:06:48 +07:00
|
|
|
|
2012-02-15 04:06:55 +07:00
|
|
|
/* Number of irqs reserved for a legacy isa controller */
|
|
|
|
#define NUM_ISA_INTERRUPTS 16
|
|
|
|
|
2011-07-26 16:19:06 +07:00
|
|
|
/**
|
|
|
|
* struct irq_domain_ops - Methods for irq_domain objects
|
2012-02-15 04:06:48 +07:00
|
|
|
* @match: Match an interrupt controller device node to a host, returns
|
|
|
|
* 1 on a match
|
|
|
|
* @map: Create or update a mapping between a virtual irq number and a hw
|
|
|
|
* irq number. This is called only once for a given mapping.
|
|
|
|
* @unmap: Dispose of such a mapping
|
|
|
|
* @xlate: Given a device tree node and interrupt specifier, decode
|
|
|
|
* the hardware irq number and linux irq type value.
|
|
|
|
*
|
|
|
|
* Functions below are provided by the driver and called whenever a new mapping
|
|
|
|
* is created or an old mapping is disposed. The driver can then proceed to
|
|
|
|
* whatever internal data structures management is required. It also needs
|
|
|
|
* to setup the irq_desc when returning from map().
|
2011-07-26 16:19:06 +07:00
|
|
|
*/
|
|
|
|
struct irq_domain_ops {
|
2012-02-15 04:06:48 +07:00
|
|
|
int (*match)(struct irq_domain *d, struct device_node *node);
|
|
|
|
int (*map)(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw);
|
|
|
|
void (*unmap)(struct irq_domain *d, unsigned int virq);
|
|
|
|
int (*xlate)(struct irq_domain *d, struct device_node *node,
|
|
|
|
const u32 *intspec, unsigned int intsize,
|
|
|
|
unsigned long *out_hwirq, unsigned int *out_type);
|
2014-11-06 21:20:14 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
|
|
|
/* extended V2 interfaces to support hierarchy irq_domains */
|
|
|
|
int (*alloc)(struct irq_domain *d, unsigned int virq,
|
|
|
|
unsigned int nr_irqs, void *arg);
|
|
|
|
void (*free)(struct irq_domain *d, unsigned int virq,
|
|
|
|
unsigned int nr_irqs);
|
|
|
|
void (*activate)(struct irq_domain *d, struct irq_data *irq_data);
|
|
|
|
void (*deactivate)(struct irq_domain *d, struct irq_data *irq_data);
|
|
|
|
#endif
|
2011-07-26 16:19:06 +07:00
|
|
|
};
|
|
|
|
|
2013-05-06 21:30:27 +07:00
|
|
|
extern struct irq_domain_ops irq_generic_chip_ops;
|
|
|
|
|
|
|
|
struct irq_domain_chip_generic;
|
|
|
|
|
2011-07-26 16:19:06 +07:00
|
|
|
/**
|
|
|
|
* struct irq_domain - Hardware interrupt number translation object
|
2012-02-15 04:06:48 +07:00
|
|
|
* @link: Element in global irq_domain list.
|
2013-06-08 18:03:59 +07:00
|
|
|
* @name: Name of interrupt domain
|
2012-02-15 04:06:48 +07:00
|
|
|
* @ops: pointer to irq_domain methods
|
|
|
|
* @host_data: private data pointer for use by owner. Not touched by irq_domain
|
|
|
|
* core code.
|
2014-11-06 21:20:14 +07:00
|
|
|
* @flags: host per irq_domain flags
|
2013-06-08 18:03:59 +07:00
|
|
|
*
|
|
|
|
* Optional elements
|
|
|
|
* @of_node: Pointer to device tree nodes associated with the irq_domain. Used
|
|
|
|
* when decoding device tree interrupt specifiers.
|
|
|
|
* @gc: Pointer to a list of generic chips. There is a helper function for
|
|
|
|
* setting up one or more generic chips for interrupt controllers
|
|
|
|
* drivers using the generic chip library which uses this pointer.
|
2014-11-06 21:20:14 +07:00
|
|
|
* @parent: Pointer to parent irq_domain to support hierarchy irq_domains
|
2013-06-08 18:03:59 +07:00
|
|
|
*
|
|
|
|
* Revmap data, used internally by irq_domain
|
|
|
|
* @revmap_direct_max_irq: The largest hwirq that can be set for controllers that
|
|
|
|
* support direct mapping
|
|
|
|
* @revmap_size: Size of the linear map table @linear_revmap[]
|
|
|
|
* @revmap_tree: Radix map tree for hwirqs that don't fit in the linear map
|
|
|
|
* @linear_revmap: Linear table of hwirq->virq reverse mappings
|
2011-07-26 16:19:06 +07:00
|
|
|
*/
|
|
|
|
struct irq_domain {
|
2012-02-15 04:06:48 +07:00
|
|
|
struct list_head link;
|
2013-06-06 20:23:30 +07:00
|
|
|
const char *name;
|
2012-01-27 02:12:14 +07:00
|
|
|
const struct irq_domain_ops *ops;
|
2012-02-15 04:06:48 +07:00
|
|
|
void *host_data;
|
2014-11-06 21:20:14 +07:00
|
|
|
unsigned int flags;
|
2012-02-15 04:06:48 +07:00
|
|
|
|
2013-06-08 18:03:59 +07:00
|
|
|
/* Optional data */
|
2011-07-26 16:19:06 +07:00
|
|
|
struct device_node *of_node;
|
2013-05-06 21:30:27 +07:00
|
|
|
struct irq_domain_chip_generic *gc;
|
2014-11-06 21:20:14 +07:00
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
|
|
|
struct irq_domain *parent;
|
|
|
|
#endif
|
2012-07-11 23:24:31 +07:00
|
|
|
|
2013-06-08 18:03:59 +07:00
|
|
|
/* reverse map data. The linear map gets appended to the irq_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 07:06:02 +07:00
|
|
|
irq_hw_number_t hwirq_max;
|
2013-06-08 18:03:59 +07:00
|
|
|
unsigned int revmap_direct_max_irq;
|
|
|
|
unsigned int revmap_size;
|
|
|
|
struct radix_tree_root revmap_tree;
|
2012-07-11 23:24:31 +07:00
|
|
|
unsigned int linear_revmap[];
|
2011-07-26 16:19:06 +07:00
|
|
|
};
|
|
|
|
|
2014-11-06 21:20:14 +07:00
|
|
|
/* Irq domain flags */
|
|
|
|
enum {
|
|
|
|
/* Irq domain is hierarchical */
|
|
|
|
IRQ_DOMAIN_FLAG_HIERARCHY = (1 << 0),
|
|
|
|
|
2014-11-15 21:24:01 +07:00
|
|
|
/* Core calls alloc/free recursive through the domain hierarchy. */
|
|
|
|
IRQ_DOMAIN_FLAG_AUTO_RECURSIVE = (1 << 1),
|
|
|
|
|
2014-11-06 21:20:14 +07:00
|
|
|
/*
|
|
|
|
* Flags starting from IRQ_DOMAIN_FLAG_NONCORE are reserved
|
|
|
|
* for implementation specific purposes and ignored by the
|
|
|
|
* core code.
|
|
|
|
*/
|
|
|
|
IRQ_DOMAIN_FLAG_NONCORE = (1 << 16),
|
|
|
|
};
|
|
|
|
|
2012-02-15 04:06:48 +07:00
|
|
|
#ifdef CONFIG_IRQ_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 07:06:02 +07: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 18:57:40 +07:00
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
void *host_data);
|
2012-07-05 18:19:19 +07: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);
|
2012-02-15 04:06:54 +07:00
|
|
|
struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
|
2012-02-15 04:06:55 +07:00
|
|
|
unsigned int size,
|
|
|
|
unsigned int first_irq,
|
|
|
|
irq_hw_number_t first_hwirq,
|
2012-01-27 02:12:14 +07:00
|
|
|
const struct irq_domain_ops *ops,
|
2012-02-15 04:06:54 +07:00
|
|
|
void *host_data);
|
2013-06-08 18:57:40 +07:00
|
|
|
extern struct irq_domain *irq_find_host(struct device_node *node);
|
|
|
|
extern void irq_set_default_host(struct irq_domain *host);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_domain_add_linear() - Allocate and register a linear revmap irq_domain.
|
|
|
|
* @of_node: pointer to interrupt controller's device tree node.
|
|
|
|
* @size: Number of interrupts in the domain.
|
|
|
|
* @ops: map/unmap domain callbacks
|
|
|
|
* @host_data: Controller private data pointer
|
|
|
|
*/
|
|
|
|
static inline struct irq_domain *irq_domain_add_linear(struct device_node *of_node,
|
2012-02-15 04:06:54 +07:00
|
|
|
unsigned int size,
|
2012-01-27 02:12:14 +07:00
|
|
|
const struct irq_domain_ops *ops,
|
2013-06-08 18:57:40 +07:00
|
|
|
void *host_data)
|
|
|
|
{
|
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 07:06:02 +07:00
|
|
|
return __irq_domain_add(of_node, size, size, 0, ops, host_data);
|
2013-06-08 18:57:40 +07:00
|
|
|
}
|
|
|
|
static inline struct irq_domain *irq_domain_add_nomap(struct device_node *of_node,
|
2012-02-16 05:06:08 +07:00
|
|
|
unsigned int max_irq,
|
2012-01-27 02:12:14 +07:00
|
|
|
const struct irq_domain_ops *ops,
|
2013-06-08 18:57:40 +07:00
|
|
|
void *host_data)
|
|
|
|
{
|
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 07:06:02 +07:00
|
|
|
return __irq_domain_add(of_node, 0, max_irq, max_irq, ops, host_data);
|
2013-06-08 18:57:40 +07:00
|
|
|
}
|
2012-02-15 04:06:55 +07:00
|
|
|
static inline struct irq_domain *irq_domain_add_legacy_isa(
|
|
|
|
struct device_node *of_node,
|
2012-01-27 02:12:14 +07:00
|
|
|
const struct irq_domain_ops *ops,
|
2012-02-15 04:06:55 +07:00
|
|
|
void *host_data)
|
|
|
|
{
|
|
|
|
return irq_domain_add_legacy(of_node, NUM_ISA_INTERRUPTS, 0, 0, ops,
|
|
|
|
host_data);
|
|
|
|
}
|
2012-07-11 23:24:31 +07:00
|
|
|
static inline struct irq_domain *irq_domain_add_tree(struct device_node *of_node,
|
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
void *host_data)
|
|
|
|
{
|
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 07:06:02 +07:00
|
|
|
return __irq_domain_add(of_node, 0, ~0, 0, ops, host_data);
|
2012-07-11 23:24:31 +07:00
|
|
|
}
|
2012-05-19 13:11:41 +07:00
|
|
|
|
|
|
|
extern void irq_domain_remove(struct irq_domain *host);
|
|
|
|
|
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 07:06:02 +07:00
|
|
|
extern int irq_domain_associate(struct irq_domain *domain, unsigned int irq,
|
|
|
|
irq_hw_number_t hwirq);
|
|
|
|
extern void irq_domain_associate_many(struct irq_domain *domain,
|
|
|
|
unsigned int irq_base,
|
|
|
|
irq_hw_number_t hwirq_base, int count);
|
2014-06-09 15:20:05 +07:00
|
|
|
extern void irq_domain_disassociate(struct irq_domain *domain,
|
|
|
|
unsigned int irq);
|
2012-06-18 05:17:04 +07:00
|
|
|
|
2012-02-16 15:37:49 +07:00
|
|
|
extern unsigned int irq_create_mapping(struct irq_domain *host,
|
|
|
|
irq_hw_number_t hwirq);
|
|
|
|
extern void irq_dispose_mapping(unsigned int virq);
|
2013-06-10 18:19:17 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_linear_revmap() - Find a linux irq from a hw irq number.
|
|
|
|
* @domain: domain owning this hardware interrupt
|
|
|
|
* @hwirq: hardware irq number in that domain space
|
|
|
|
*
|
|
|
|
* This is a fast path alternative to irq_find_mapping() that can be
|
|
|
|
* called directly by irq controller code to save a handful of
|
|
|
|
* instructions. It is always safe to call, but won't find irqs mapped
|
|
|
|
* using the radix tree.
|
|
|
|
*/
|
|
|
|
static inline unsigned int irq_linear_revmap(struct irq_domain *domain,
|
|
|
|
irq_hw_number_t hwirq)
|
|
|
|
{
|
|
|
|
return hwirq < domain->revmap_size ? domain->linear_revmap[hwirq] : 0;
|
|
|
|
}
|
2012-02-16 15:37:49 +07:00
|
|
|
extern unsigned int irq_find_mapping(struct irq_domain *host,
|
|
|
|
irq_hw_number_t hwirq);
|
|
|
|
extern unsigned int irq_create_direct_mapping(struct irq_domain *host);
|
2012-06-18 05:17:04 +07:00
|
|
|
extern int irq_create_strict_mappings(struct irq_domain *domain,
|
|
|
|
unsigned int irq_base,
|
|
|
|
irq_hw_number_t hwirq_base, int count);
|
|
|
|
|
|
|
|
static inline int irq_create_identity_mapping(struct irq_domain *host,
|
|
|
|
irq_hw_number_t hwirq)
|
|
|
|
{
|
|
|
|
return irq_create_strict_mappings(host, hwirq, hwirq, 1);
|
|
|
|
}
|
|
|
|
|
2012-01-27 02:12:14 +07:00
|
|
|
extern const struct irq_domain_ops irq_domain_simple_ops;
|
2012-01-27 01:26:52 +07:00
|
|
|
|
|
|
|
/* stock xlate functions */
|
|
|
|
int irq_domain_xlate_onecell(struct irq_domain *d, struct device_node *ctrlr,
|
|
|
|
const u32 *intspec, unsigned int intsize,
|
|
|
|
irq_hw_number_t *out_hwirq, unsigned int *out_type);
|
|
|
|
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);
|
|
|
|
int irq_domain_xlate_onetwocell(struct irq_domain *d, struct device_node *ctrlr,
|
|
|
|
const u32 *intspec, unsigned int intsize,
|
|
|
|
irq_hw_number_t *out_hwirq, unsigned int *out_type);
|
|
|
|
|
2014-11-06 21:20:14 +07:00
|
|
|
/* V2 interfaces to support hierarchy IRQ domains. */
|
|
|
|
extern struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
|
|
|
|
unsigned int virq);
|
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
2014-11-15 21:24:02 +07:00
|
|
|
extern struct irq_domain *irq_domain_add_hierarchy(struct irq_domain *parent,
|
|
|
|
unsigned int flags, unsigned int size,
|
|
|
|
struct device_node *node,
|
|
|
|
const struct irq_domain_ops *ops, void *host_data);
|
2014-11-06 21:20:14 +07:00
|
|
|
extern int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
|
|
|
|
unsigned int nr_irqs, int node, void *arg,
|
|
|
|
bool realloc);
|
|
|
|
extern void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs);
|
|
|
|
extern void irq_domain_activate_irq(struct irq_data *irq_data);
|
|
|
|
extern void irq_domain_deactivate_irq(struct irq_data *irq_data);
|
|
|
|
|
|
|
|
static inline int irq_domain_alloc_irqs(struct irq_domain *domain,
|
|
|
|
unsigned int nr_irqs, int node, void *arg)
|
|
|
|
{
|
|
|
|
return __irq_domain_alloc_irqs(domain, -1, nr_irqs, node, arg, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern int irq_domain_set_hwirq_and_chip(struct irq_domain *domain,
|
|
|
|
unsigned int virq,
|
|
|
|
irq_hw_number_t hwirq,
|
|
|
|
struct irq_chip *chip,
|
|
|
|
void *chip_data);
|
2014-11-09 22:10:24 +07:00
|
|
|
extern void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
|
|
|
|
irq_hw_number_t hwirq, struct irq_chip *chip,
|
|
|
|
void *chip_data, irq_flow_handler_t handler,
|
|
|
|
void *handler_data, const char *handler_name);
|
2014-11-06 21:20:14 +07:00
|
|
|
extern void irq_domain_reset_irq_data(struct irq_data *irq_data);
|
|
|
|
extern void irq_domain_free_irqs_common(struct irq_domain *domain,
|
|
|
|
unsigned int virq,
|
|
|
|
unsigned int nr_irqs);
|
|
|
|
extern void irq_domain_free_irqs_top(struct irq_domain *domain,
|
|
|
|
unsigned int virq, unsigned int nr_irqs);
|
|
|
|
|
2014-11-15 21:24:01 +07:00
|
|
|
extern int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
|
|
|
|
unsigned int irq_base,
|
|
|
|
unsigned int nr_irqs, void *arg);
|
2014-11-06 21:20:14 +07:00
|
|
|
|
2014-11-15 21:24:01 +07:00
|
|
|
extern void irq_domain_free_irqs_parent(struct irq_domain *domain,
|
|
|
|
unsigned int irq_base,
|
|
|
|
unsigned int nr_irqs);
|
2014-11-06 21:20:14 +07:00
|
|
|
|
|
|
|
static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
|
|
|
|
{
|
|
|
|
return domain->flags & IRQ_DOMAIN_FLAG_HIERARCHY;
|
|
|
|
}
|
|
|
|
#else /* CONFIG_IRQ_DOMAIN_HIERARCHY */
|
|
|
|
static inline void irq_domain_activate_irq(struct irq_data *data) { }
|
|
|
|
static inline void irq_domain_deactivate_irq(struct irq_data *data) { }
|
|
|
|
static inline int irq_domain_alloc_irqs(struct irq_domain *domain,
|
|
|
|
unsigned int nr_irqs, int node, void *arg)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */
|
|
|
|
|
2012-02-24 22:24:17 +07:00
|
|
|
#else /* CONFIG_IRQ_DOMAIN */
|
|
|
|
static inline void irq_dispose_mapping(unsigned int virq) { }
|
2014-11-06 21:20:14 +07:00
|
|
|
static inline void irq_domain_activate_irq(struct irq_data *data) { }
|
|
|
|
static inline void irq_domain_deactivate_irq(struct irq_data *data) { }
|
2012-02-24 22:24:17 +07:00
|
|
|
#endif /* !CONFIG_IRQ_DOMAIN */
|
2011-07-26 16:19:06 +07:00
|
|
|
|
2011-07-26 16:19:06 +07:00
|
|
|
#endif /* _LINUX_IRQDOMAIN_H */
|