mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-29 23:53:32 +00:00
1eccc6e152
Core infrastructural changes: - Support for natively single-ended GPIO driver stages. This means that if the hardware has registers to configure open drain or open source configuration, we use that rather than (as we did before) try to emulate it by switching the line to an input to get high impedance. This is also documented throughly in Documentation/gpio/driver.txt for those of you who did not understand one word of what I just wrote. - Start to do away with the unnecessarily complex and unitelligible ARCH_REQUIRE_GPIOLIB and ARCH_WANT_OPTIONAL_GPIOLIB, another evolutional artifact from the time when the GPIO subsystem was unmaintained. Archs can now just select GPIOLIB and be done with it, cleanups to arches will trickle in for the next kernel. Some minor archs ACKed the changes immediately so these are included in this pull request. - Advancing the use of the data pointer inside the GPIO device for storing driver data by switching the PowerPC, Super-H Unicore and a few other subarches or subsystem drivers in ALSA SoC, Input, serial, SSB, staging etc to use it. - The initialization now reads the input/output state of the GPIO lines, so that each GPIO descriptor knows - if this callback is implemented - whether the line is input or output. This also reflects nicely in userspace "lsgpio". - It is now possible to name GPIO producer names, line names, from the device tree. (Platform data has been supported for a while.) I bet we will get a similar mechanism for ACPI one of those days. This makes is possible to get sensible producer names for e.g. GPIO rails in "lsgpio" in userspace. New drivers: - New driver for the Loongson1. - The XLP driver now supports Broadcom Vulcan ARM64. - The IT87 driver now supports IT8620 and IT8628. - The PCA953X driver now supports Galileo Gen2. Driver improvements: - MCP23S08 was switched to use the gpiolib irqchip helpers and now also suppors level-triggered interrupts. - 74x164 and RCAR now supports the .set_multiple() callback - AMDPT was converted to use generic GPIO. - TC3589x, TPS65218, SX150X, F7188X, MENZ127, VX855, WM831X, WM8994 support the new single ended callback for open drain and in some cases open source. - Implement the .get_direction() callback for a few more drivers like PL061, Xgene. Cleanups: - Paul Gortmaker combed through the drivers and de-modularized those who are not really modules. - Move the GPIO poweroff DT bindings to the power subdir where they belong. - Rename gpio-generic.c to gpio-mmio.c, which is much more to the point. That's what it is handling, nothing more, nothing less. -----BEGIN PGP SIGNATURE----- Version: GnuPG v1 iQIcBAABAgAGBQJXOuJ5AAoJEEEQszewGV1zNXsQAII5wtkP69WRJ3goYBKg1dZN DkuLqZyVI4hCgRhptzUW10gDLHKKOCVubfetTJHSpyG/dWDJXPCyH6FHF+pW6lMX y+em8kAvWctKpaosy4EM7O55/IohW0/fNCTOfzfrUNivjydFuA2XwPUiPqC7111O DeKlC/t+W1JEvZTiKMi83pKq+9wqhiHmD0qxRHhV57S+MT8e7mdlSKOp7uUkKPkg LPlerXosnmeFjL2emuSnKl/tq8pOyruU6uaIGG/uwpbo2W86Dok9GY2GWkQ4pANT pDtprc4aJ/Clf6Q0CoKwQbmAozqTDeJo+Und9tRs2KuZRly2bWOcyVE0lyK+Y4s0 544LcKw2q6cB9ARZ6JExEVRJejPISGKMqo9TaHkyNSIJoiiatKYvNS4WVeFtTgbI W+1WfM1svPymNRqVPO1PMLV+3m9dalDH2WjtaFF21uCAQ/G0AuPEHjEDbbx0HIpb qrvWmYzZ97Rm/LdYROFRO53nEdCp2jh6c3n4/2kGYM8H0suvGxXZsB1g4i+Dm+B+ qKVTS282azlDuH9ohXeXizeb6atK6s8TC3Rmew97SmXDO00cUQzEQO/ZquRLHY9r n83afQ4OL2Z9yruAxAk7pCshVSyheOsHuFPuZ7bwPW31VMdoWNRkhnaTUXMjGfYg 3y39IHrCKWNMCCVM1iNl =z4d6 -----END PGP SIGNATURE----- Merge tag 'gpio-v4.7-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio Pull GPIO updates from Linus Walleij: "This is the bulk of GPIO changes for kernel cycle v4.7: Core infrastructural changes: - Support for natively single-ended GPIO driver stages. This means that if the hardware has registers to configure open drain or open source configuration, we use that rather than (as we did before) try to emulate it by switching the line to an input to get high impedance. This is also documented throughly in Documentation/gpio/driver.txt for those of you who did not understand one word of what I just wrote. - Start to do away with the unnecessarily complex and unitelligible ARCH_REQUIRE_GPIOLIB and ARCH_WANT_OPTIONAL_GPIOLIB, another evolutional artifact from the time when the GPIO subsystem was unmaintained. Archs can now just select GPIOLIB and be done with it, cleanups to arches will trickle in for the next kernel. Some minor archs ACKed the changes immediately so these are included in this pull request. - Advancing the use of the data pointer inside the GPIO device for storing driver data by switching the PowerPC, Super-H Unicore and a few other subarches or subsystem drivers in ALSA SoC, Input, serial, SSB, staging etc to use it. - The initialization now reads the input/output state of the GPIO lines, so that each GPIO descriptor knows - if this callback is implemented - whether the line is input or output. This also reflects nicely in userspace "lsgpio". - It is now possible to name GPIO producer names, line names, from the device tree. (Platform data has been supported for a while). I bet we will get a similar mechanism for ACPI one of those days. This makes is possible to get sensible producer names for e.g. GPIO rails in "lsgpio" in userspace. New drivers: - New driver for the Loongson1. - The XLP driver now supports Broadcom Vulcan ARM64. - The IT87 driver now supports IT8620 and IT8628. - The PCA953X driver now supports Galileo Gen2. Driver improvements: - MCP23S08 was switched to use the gpiolib irqchip helpers and now also suppors level-triggered interrupts. - 74x164 and RCAR now supports the .set_multiple() callback - AMDPT was converted to use generic GPIO. - TC3589x, TPS65218, SX150X, F7188X, MENZ127, VX855, WM831X, WM8994 support the new single ended callback for open drain and in some cases open source. - Implement the .get_direction() callback for a few more drivers like PL061, Xgene. Cleanups: - Paul Gortmaker combed through the drivers and de-modularized those who are not really modules. - Move the GPIO poweroff DT bindings to the power subdir where they belong. - Rename gpio-generic.c to gpio-mmio.c, which is much more to the point. That's what it is handling, nothing more, nothing less" * tag 'gpio-v4.7-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio: (126 commits) MIPS: do away with ARCH_[WANT_OPTIONAL|REQUIRE]_GPIOLIB gpio: zevio: make it explicitly non-modular gpio: timberdale: make it explicitly non-modular gpio: stmpe: make it explicitly non-modular gpio: sodaville: make it explicitly non-modular pinctrl: sh-pfc: Let gpio_chip.to_irq() return zero on error gpio: dwapb: Add ACPI device ID for DWAPB GPIO controller on X-Gene platforms gpio: dt-bindings: add wd,mbl-gpio bindings gpio: of: make it possible to name GPIO lines gpio: make gpiod_to_irq() return negative for NO_IRQ gpio: xgene: implement .get_direction() gpio: xgene: Enable ACPI support for X-Gene GFC GPIO driver gpio: tegra: Implement gpio_get_direction callback gpio: set up initial state from .get_direction() gpio: rename gpio-generic.c into gpio-mmio.c gpio: generic: fix GPIO_GENERIC_PLATFORM is set to module case gpio: dwapb: add gpio-signaled acpi event support gpio: dwapb: convert device node to fwnode gpio: dwapb: remove name from dwapb_port_property gpio/qoriq: select IRQ_DOMAIN ...
1386 lines
39 KiB
C
1386 lines
39 KiB
C
#define pr_fmt(fmt) "irq: " fmt
|
|
|
|
#include <linux/debugfs.h>
|
|
#include <linux/hardirq.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/irqdesc.h>
|
|
#include <linux/irqdomain.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_address.h>
|
|
#include <linux/of_irq.h>
|
|
#include <linux/topology.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/smp.h>
|
|
#include <linux/fs.h>
|
|
|
|
static LIST_HEAD(irq_domain_list);
|
|
static DEFINE_MUTEX(irq_domain_mutex);
|
|
|
|
static DEFINE_MUTEX(revmap_trees_mutex);
|
|
static struct irq_domain *irq_default_domain;
|
|
|
|
static void irq_domain_check_hierarchy(struct irq_domain *domain);
|
|
|
|
struct irqchip_fwid {
|
|
struct fwnode_handle fwnode;
|
|
char *name;
|
|
void *data;
|
|
};
|
|
|
|
/**
|
|
* irq_domain_alloc_fwnode - Allocate a fwnode_handle suitable for
|
|
* identifying an irq domain
|
|
* @data: optional user-provided data
|
|
*
|
|
* Allocate a struct device_node, and return a poiner to the embedded
|
|
* fwnode_handle (or NULL on failure).
|
|
*/
|
|
struct fwnode_handle *irq_domain_alloc_fwnode(void *data)
|
|
{
|
|
struct irqchip_fwid *fwid;
|
|
char *name;
|
|
|
|
fwid = kzalloc(sizeof(*fwid), GFP_KERNEL);
|
|
name = kasprintf(GFP_KERNEL, "irqchip@%p", data);
|
|
|
|
if (!fwid || !name) {
|
|
kfree(fwid);
|
|
kfree(name);
|
|
return NULL;
|
|
}
|
|
|
|
fwid->name = name;
|
|
fwid->data = data;
|
|
fwid->fwnode.type = FWNODE_IRQCHIP;
|
|
return &fwid->fwnode;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_alloc_fwnode);
|
|
|
|
/**
|
|
* irq_domain_free_fwnode - Free a non-OF-backed fwnode_handle
|
|
*
|
|
* Free a fwnode_handle allocated with irq_domain_alloc_fwnode.
|
|
*/
|
|
void irq_domain_free_fwnode(struct fwnode_handle *fwnode)
|
|
{
|
|
struct irqchip_fwid *fwid;
|
|
|
|
if (WARN_ON(!is_fwnode_irqchip(fwnode)))
|
|
return;
|
|
|
|
fwid = container_of(fwnode, struct irqchip_fwid, fwnode);
|
|
kfree(fwid->name);
|
|
kfree(fwid);
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_free_fwnode);
|
|
|
|
/**
|
|
* __irq_domain_add() - Allocate a new irq_domain data structure
|
|
* @of_node: optional device-tree node of the interrupt controller
|
|
* @size: Size of linear map; 0 for radix mapping only
|
|
* @hwirq_max: Maximum number of interrupts supported by controller
|
|
* @direct_max: Maximum value of direct maps; Use ~0 for no limit; 0 for no
|
|
* direct mapping
|
|
* @ops: domain callbacks
|
|
* @host_data: Controller private data pointer
|
|
*
|
|
* Allocates and initialize and irq_domain structure.
|
|
* Returns pointer to IRQ domain, or NULL on failure.
|
|
*/
|
|
struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, int size,
|
|
irq_hw_number_t hwirq_max, int direct_max,
|
|
const struct irq_domain_ops *ops,
|
|
void *host_data)
|
|
{
|
|
struct irq_domain *domain;
|
|
struct device_node *of_node;
|
|
|
|
of_node = to_of_node(fwnode);
|
|
|
|
domain = kzalloc_node(sizeof(*domain) + (sizeof(unsigned int) * size),
|
|
GFP_KERNEL, of_node_to_nid(of_node));
|
|
if (WARN_ON(!domain))
|
|
return NULL;
|
|
|
|
of_node_get(of_node);
|
|
|
|
/* Fill structure */
|
|
INIT_RADIX_TREE(&domain->revmap_tree, GFP_KERNEL);
|
|
domain->ops = ops;
|
|
domain->host_data = host_data;
|
|
domain->fwnode = fwnode;
|
|
domain->hwirq_max = hwirq_max;
|
|
domain->revmap_size = size;
|
|
domain->revmap_direct_max_irq = direct_max;
|
|
irq_domain_check_hierarchy(domain);
|
|
|
|
mutex_lock(&irq_domain_mutex);
|
|
list_add(&domain->link, &irq_domain_list);
|
|
mutex_unlock(&irq_domain_mutex);
|
|
|
|
pr_debug("Added domain %s\n", domain->name);
|
|
return domain;
|
|
}
|
|
EXPORT_SYMBOL_GPL(__irq_domain_add);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/*
|
|
* radix_tree_delete() takes care of destroying the root
|
|
* node when all entries are removed. Shout if there are
|
|
* any mappings left.
|
|
*/
|
|
WARN_ON(domain->revmap_tree.height);
|
|
|
|
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);
|
|
|
|
pr_debug("Removed domain %s\n", domain->name);
|
|
|
|
of_node_put(irq_domain_get_of_node(domain));
|
|
kfree(domain);
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_remove);
|
|
|
|
/**
|
|
* irq_domain_add_simple() - Register an irq_domain and optionally map a range of irqs
|
|
* @of_node: pointer to interrupt controller's device tree node.
|
|
* @size: total number of irqs in mapping
|
|
* @first_irq: first number of irq block assigned to the domain,
|
|
* 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.
|
|
* @ops: domain callbacks
|
|
* @host_data: Controller private data pointer
|
|
*
|
|
* 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.
|
|
*
|
|
* This is intended to implement the expected behaviour for most
|
|
* 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.
|
|
*/
|
|
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)
|
|
{
|
|
struct irq_domain *domain;
|
|
|
|
domain = __irq_domain_add(of_node_to_fwnode(of_node), size, size, 0, ops, host_data);
|
|
if (!domain)
|
|
return NULL;
|
|
|
|
if (first_irq > 0) {
|
|
if (IS_ENABLED(CONFIG_SPARSE_IRQ)) {
|
|
/* attempt to allocated irq_descs */
|
|
int rc = irq_alloc_descs(first_irq, first_irq, size,
|
|
of_node_to_nid(of_node));
|
|
if (rc < 0)
|
|
pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
|
|
first_irq);
|
|
}
|
|
irq_domain_associate_many(domain, first_irq, 0, size);
|
|
}
|
|
|
|
return domain;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_add_simple);
|
|
|
|
/**
|
|
* irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
|
|
* @of_node: pointer to interrupt controller's device tree node.
|
|
* @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.
|
|
* @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,
|
|
unsigned int size,
|
|
unsigned int first_irq,
|
|
irq_hw_number_t first_hwirq,
|
|
const struct irq_domain_ops *ops,
|
|
void *host_data)
|
|
{
|
|
struct irq_domain *domain;
|
|
|
|
domain = __irq_domain_add(of_node_to_fwnode(of_node), first_hwirq + size,
|
|
first_hwirq + size, 0, ops, host_data);
|
|
if (domain)
|
|
irq_domain_associate_many(domain, first_irq, first_hwirq, size);
|
|
|
|
return domain;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_add_legacy);
|
|
|
|
/**
|
|
* irq_find_matching_fwspec() - Locates a domain for a given fwspec
|
|
* @fwspec: FW specifier for an interrupt
|
|
* @bus_token: domain-specific data
|
|
*/
|
|
struct irq_domain *irq_find_matching_fwspec(struct irq_fwspec *fwspec,
|
|
enum irq_domain_bus_token bus_token)
|
|
{
|
|
struct irq_domain *h, *found = NULL;
|
|
struct fwnode_handle *fwnode = fwspec->fwnode;
|
|
int rc;
|
|
|
|
/* 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...
|
|
*
|
|
* bus_token == DOMAIN_BUS_ANY matches any domain, any other
|
|
* values must generate an exact match for the domain to be
|
|
* selected.
|
|
*/
|
|
mutex_lock(&irq_domain_mutex);
|
|
list_for_each_entry(h, &irq_domain_list, link) {
|
|
if (h->ops->select && fwspec->param_count)
|
|
rc = h->ops->select(h, fwspec, bus_token);
|
|
else if (h->ops->match)
|
|
rc = h->ops->match(h, to_of_node(fwnode), bus_token);
|
|
else
|
|
rc = ((fwnode != NULL) && (h->fwnode == fwnode) &&
|
|
((bus_token == DOMAIN_BUS_ANY) ||
|
|
(h->bus_token == bus_token)));
|
|
|
|
if (rc) {
|
|
found = h;
|
|
break;
|
|
}
|
|
}
|
|
mutex_unlock(&irq_domain_mutex);
|
|
return found;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_find_matching_fwspec);
|
|
|
|
/**
|
|
* irq_set_default_host() - Set a "default" irq domain
|
|
* @domain: default domain pointer
|
|
*
|
|
* 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.
|
|
*/
|
|
void irq_set_default_host(struct irq_domain *domain)
|
|
{
|
|
pr_debug("Default domain set to @0x%p\n", domain);
|
|
|
|
irq_default_domain = domain;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_set_default_host);
|
|
|
|
void irq_domain_disassociate(struct irq_domain *domain, unsigned int irq)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
int irq_domain_associate(struct irq_domain *domain, unsigned int virq,
|
|
irq_hw_number_t hwirq)
|
|
{
|
|
struct irq_data *irq_data = irq_get_irq_data(virq);
|
|
int ret;
|
|
|
|
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;
|
|
|
|
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);
|
|
}
|
|
irq_data->domain = NULL;
|
|
irq_data->hwirq = 0;
|
|
mutex_unlock(&irq_domain_mutex);
|
|
return ret;
|
|
}
|
|
|
|
/* If not already assigned, give the domain the chip's name */
|
|
if (!domain->name && irq_data->chip)
|
|
domain->name = irq_data->chip->name;
|
|
}
|
|
|
|
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);
|
|
}
|
|
mutex_unlock(&irq_domain_mutex);
|
|
|
|
irq_clear_status_flags(virq, IRQ_NOREQUEST);
|
|
|
|
return 0;
|
|
}
|
|
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)
|
|
{
|
|
struct device_node *of_node;
|
|
int i;
|
|
|
|
of_node = irq_domain_get_of_node(domain);
|
|
pr_debug("%s(%s, irqbase=%i, hwbase=%i, count=%i)\n", __func__,
|
|
of_node_full_name(of_node), irq_base, (int)hwirq_base, count);
|
|
|
|
for (i = 0; i < count; i++) {
|
|
irq_domain_associate(domain, irq_base + i, hwirq_base + i);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_associate_many);
|
|
|
|
/**
|
|
* irq_create_direct_mapping() - Allocate an irq for direct mapping
|
|
* @domain: domain to allocate the irq for or NULL for default domain
|
|
*
|
|
* 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
|
|
* 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.
|
|
*/
|
|
unsigned int irq_create_direct_mapping(struct irq_domain *domain)
|
|
{
|
|
struct device_node *of_node;
|
|
unsigned int virq;
|
|
|
|
if (domain == NULL)
|
|
domain = irq_default_domain;
|
|
|
|
of_node = irq_domain_get_of_node(domain);
|
|
virq = irq_alloc_desc_from(1, of_node_to_nid(of_node));
|
|
if (!virq) {
|
|
pr_debug("create_direct virq allocation failed\n");
|
|
return 0;
|
|
}
|
|
if (virq >= domain->revmap_direct_max_irq) {
|
|
pr_err("ERROR: no free irqs available below %i maximum\n",
|
|
domain->revmap_direct_max_irq);
|
|
irq_free_desc(virq);
|
|
return 0;
|
|
}
|
|
pr_debug("create_direct obtained virq %d\n", virq);
|
|
|
|
if (irq_domain_associate(domain, virq, virq)) {
|
|
irq_free_desc(virq);
|
|
return 0;
|
|
}
|
|
|
|
return virq;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_create_direct_mapping);
|
|
|
|
/**
|
|
* irq_create_mapping() - Map a hardware interrupt into linux irq space
|
|
* @domain: domain owning this hardware interrupt or NULL for default domain
|
|
* @hwirq: hardware irq number in that domain space
|
|
*
|
|
* 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.
|
|
*/
|
|
unsigned int irq_create_mapping(struct irq_domain *domain,
|
|
irq_hw_number_t hwirq)
|
|
{
|
|
struct device_node *of_node;
|
|
int virq;
|
|
|
|
pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain, hwirq);
|
|
|
|
/* Look for default domain if nececssary */
|
|
if (domain == NULL)
|
|
domain = irq_default_domain;
|
|
if (domain == NULL) {
|
|
WARN(1, "%s(, %lx) called with NULL domain\n", __func__, hwirq);
|
|
return 0;
|
|
}
|
|
pr_debug("-> using domain @%p\n", domain);
|
|
|
|
of_node = irq_domain_get_of_node(domain);
|
|
|
|
/* Check if mapping already exists */
|
|
virq = irq_find_mapping(domain, hwirq);
|
|
if (virq) {
|
|
pr_debug("-> existing mapping on virq %d\n", virq);
|
|
return virq;
|
|
}
|
|
|
|
/* Allocate a virtual interrupt number */
|
|
virq = irq_domain_alloc_descs(-1, 1, hwirq, of_node_to_nid(of_node));
|
|
if (virq <= 0) {
|
|
pr_debug("-> virq allocation failed\n");
|
|
return 0;
|
|
}
|
|
|
|
if (irq_domain_associate(domain, virq, hwirq)) {
|
|
irq_free_desc(virq);
|
|
return 0;
|
|
}
|
|
|
|
pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
|
|
hwirq, of_node_full_name(of_node), virq);
|
|
|
|
return virq;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_create_mapping);
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
struct device_node *of_node;
|
|
int ret;
|
|
|
|
of_node = irq_domain_get_of_node(domain);
|
|
ret = irq_alloc_descs(irq_base, irq_base, count,
|
|
of_node_to_nid(of_node));
|
|
if (unlikely(ret < 0))
|
|
return ret;
|
|
|
|
irq_domain_associate_many(domain, irq_base, hwirq_base, count);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_create_strict_mappings);
|
|
|
|
static int irq_domain_translate(struct irq_domain *d,
|
|
struct irq_fwspec *fwspec,
|
|
irq_hw_number_t *hwirq, unsigned int *type)
|
|
{
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
|
if (d->ops->translate)
|
|
return d->ops->translate(d, fwspec, hwirq, type);
|
|
#endif
|
|
if (d->ops->xlate)
|
|
return d->ops->xlate(d, to_of_node(fwspec->fwnode),
|
|
fwspec->param, fwspec->param_count,
|
|
hwirq, type);
|
|
|
|
/* If domain has no translation, then we assume interrupt line */
|
|
*hwirq = fwspec->param[0];
|
|
return 0;
|
|
}
|
|
|
|
static void of_phandle_args_to_fwspec(struct of_phandle_args *irq_data,
|
|
struct irq_fwspec *fwspec)
|
|
{
|
|
int i;
|
|
|
|
fwspec->fwnode = irq_data->np ? &irq_data->np->fwnode : NULL;
|
|
fwspec->param_count = irq_data->args_count;
|
|
|
|
for (i = 0; i < irq_data->args_count; i++)
|
|
fwspec->param[i] = irq_data->args[i];
|
|
}
|
|
|
|
unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec)
|
|
{
|
|
struct irq_domain *domain;
|
|
irq_hw_number_t hwirq;
|
|
unsigned int type = IRQ_TYPE_NONE;
|
|
int virq;
|
|
|
|
if (fwspec->fwnode) {
|
|
domain = irq_find_matching_fwspec(fwspec, DOMAIN_BUS_WIRED);
|
|
if (!domain)
|
|
domain = irq_find_matching_fwspec(fwspec, DOMAIN_BUS_ANY);
|
|
} else {
|
|
domain = irq_default_domain;
|
|
}
|
|
|
|
if (!domain) {
|
|
pr_warn("no irq domain found for %s !\n",
|
|
of_node_full_name(to_of_node(fwspec->fwnode)));
|
|
return 0;
|
|
}
|
|
|
|
if (irq_domain_translate(domain, fwspec, &hwirq, &type))
|
|
return 0;
|
|
|
|
if (irq_domain_is_hierarchy(domain)) {
|
|
/*
|
|
* If we've already configured this interrupt,
|
|
* don't do it again, or hell will break loose.
|
|
*/
|
|
virq = irq_find_mapping(domain, hwirq);
|
|
if (virq)
|
|
return virq;
|
|
|
|
virq = irq_domain_alloc_irqs(domain, 1, NUMA_NO_NODE, fwspec);
|
|
if (virq <= 0)
|
|
return 0;
|
|
} else {
|
|
/* Create mapping */
|
|
virq = irq_create_mapping(domain, hwirq);
|
|
if (!virq)
|
|
return virq;
|
|
}
|
|
|
|
/* Set type if specified and different than the current one */
|
|
if (type != IRQ_TYPE_NONE &&
|
|
type != irq_get_trigger_type(virq))
|
|
irq_set_irq_type(virq, type);
|
|
return virq;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_create_fwspec_mapping);
|
|
|
|
unsigned int irq_create_of_mapping(struct of_phandle_args *irq_data)
|
|
{
|
|
struct irq_fwspec fwspec;
|
|
|
|
of_phandle_args_to_fwspec(irq_data, &fwspec);
|
|
return irq_create_fwspec_mapping(&fwspec);
|
|
}
|
|
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);
|
|
struct irq_domain *domain;
|
|
|
|
if (!virq || !irq_data)
|
|
return;
|
|
|
|
domain = irq_data->domain;
|
|
if (WARN_ON(domain == NULL))
|
|
return;
|
|
|
|
irq_domain_disassociate(domain, virq);
|
|
irq_free_desc(virq);
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_dispose_mapping);
|
|
|
|
/**
|
|
* irq_find_mapping() - Find a linux irq from an hw irq number.
|
|
* @domain: domain owning this hardware interrupt
|
|
* @hwirq: hardware irq number in that domain space
|
|
*/
|
|
unsigned int irq_find_mapping(struct irq_domain *domain,
|
|
irq_hw_number_t hwirq)
|
|
{
|
|
struct irq_data *data;
|
|
|
|
/* Look for default domain if nececssary */
|
|
if (domain == NULL)
|
|
domain = irq_default_domain;
|
|
if (domain == NULL)
|
|
return 0;
|
|
|
|
if (hwirq < domain->revmap_direct_max_irq) {
|
|
data = irq_domain_get_irq_data(domain, hwirq);
|
|
if (data && data->hwirq == hwirq)
|
|
return hwirq;
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_find_mapping);
|
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_DEBUG
|
|
static int virq_debug_show(struct seq_file *m, void *private)
|
|
{
|
|
unsigned long flags;
|
|
struct irq_desc *desc;
|
|
struct irq_domain *domain;
|
|
struct radix_tree_iter iter;
|
|
void *data, **slot;
|
|
int i;
|
|
|
|
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) {
|
|
struct device_node *of_node;
|
|
int count = 0;
|
|
of_node = irq_domain_get_of_node(domain);
|
|
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,
|
|
of_node ? of_node_full_name(of_node) : "");
|
|
}
|
|
mutex_unlock(&irq_domain_mutex);
|
|
|
|
seq_printf(m, "%-5s %-7s %-15s %-*s %6s %-14s %s\n", "irq", "hwirq",
|
|
"chip name", (int)(2 * sizeof(void *) + 2), "chip data",
|
|
"active", "type", "domain");
|
|
|
|
for (i = 1; i < nr_irqs; i++) {
|
|
desc = irq_to_desc(i);
|
|
if (!desc)
|
|
continue;
|
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
|
domain = desc->irq_data.domain;
|
|
|
|
if (domain) {
|
|
struct irq_chip *chip;
|
|
int hwirq = desc->irq_data.hwirq;
|
|
bool direct;
|
|
|
|
seq_printf(m, "%5d ", i);
|
|
seq_printf(m, "0x%05x ", hwirq);
|
|
|
|
chip = irq_desc_get_chip(desc);
|
|
seq_printf(m, "%-15s ", (chip && chip->name) ? chip->name : "none");
|
|
|
|
data = irq_desc_get_chip_data(desc);
|
|
seq_printf(m, data ? "0x%p " : " %p ", data);
|
|
|
|
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)" : "");
|
|
seq_printf(m, "%s\n", desc->irq_data.domain->name);
|
|
}
|
|
|
|
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)
|
|
{
|
|
if (debugfs_create_file("irq_domain_mapping", S_IRUGO, NULL,
|
|
NULL, &virq_debug_fops) == NULL)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
__initcall(irq_debugfs_init);
|
|
#endif /* CONFIG_IRQ_DOMAIN_DEBUG */
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
if (WARN_ON(intsize < 1))
|
|
return -EINVAL;
|
|
*out_hwirq = intspec[0];
|
|
*out_type = IRQ_TYPE_NONE;
|
|
return 0;
|
|
}
|
|
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);
|
|
|
|
const struct irq_domain_ops irq_domain_simple_ops = {
|
|
.xlate = irq_domain_xlate_onetwocell,
|
|
};
|
|
EXPORT_SYMBOL_GPL(irq_domain_simple_ops);
|
|
|
|
int irq_domain_alloc_descs(int virq, unsigned int cnt, irq_hw_number_t hwirq,
|
|
int node)
|
|
{
|
|
unsigned int hint;
|
|
|
|
if (virq >= 0) {
|
|
virq = irq_alloc_descs(virq, virq, cnt, node);
|
|
} else {
|
|
hint = hwirq % nr_irqs;
|
|
if (hint == 0)
|
|
hint++;
|
|
virq = irq_alloc_descs_from(hint, cnt, node);
|
|
if (virq <= 0 && hint > 1)
|
|
virq = irq_alloc_descs_from(1, cnt, node);
|
|
}
|
|
|
|
return virq;
|
|
}
|
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
|
/**
|
|
* irq_domain_create_hierarchy - Add a irqdomain into the hierarchy
|
|
* @parent: Parent irq domain to associate with the new domain
|
|
* @flags: Irq domain flags associated to the domain
|
|
* @size: Size of the domain. See below
|
|
* @fwnode: Optional fwnode of the interrupt controller
|
|
* @ops: Pointer to the interrupt domain callbacks
|
|
* @host_data: Controller private data pointer
|
|
*
|
|
* If @size is 0 a tree domain is created, otherwise a linear domain.
|
|
*
|
|
* If successful the parent is associated to the new domain and the
|
|
* domain flags are set.
|
|
* Returns pointer to IRQ domain, or NULL on failure.
|
|
*/
|
|
struct irq_domain *irq_domain_create_hierarchy(struct irq_domain *parent,
|
|
unsigned int flags,
|
|
unsigned int size,
|
|
struct fwnode_handle *fwnode,
|
|
const struct irq_domain_ops *ops,
|
|
void *host_data)
|
|
{
|
|
struct irq_domain *domain;
|
|
|
|
if (size)
|
|
domain = irq_domain_create_linear(fwnode, size, ops, host_data);
|
|
else
|
|
domain = irq_domain_create_tree(fwnode, ops, host_data);
|
|
if (domain) {
|
|
domain->parent = parent;
|
|
domain->flags |= flags;
|
|
}
|
|
|
|
return domain;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_create_hierarchy);
|
|
|
|
static void irq_domain_insert_irq(int virq)
|
|
{
|
|
struct irq_data *data;
|
|
|
|
for (data = irq_get_irq_data(virq); data; data = data->parent_data) {
|
|
struct irq_domain *domain = data->domain;
|
|
irq_hw_number_t hwirq = data->hwirq;
|
|
|
|
if (hwirq < domain->revmap_size) {
|
|
domain->linear_revmap[hwirq] = virq;
|
|
} else {
|
|
mutex_lock(&revmap_trees_mutex);
|
|
radix_tree_insert(&domain->revmap_tree, hwirq, data);
|
|
mutex_unlock(&revmap_trees_mutex);
|
|
}
|
|
|
|
/* If not already assigned, give the domain the chip's name */
|
|
if (!domain->name && data->chip)
|
|
domain->name = data->chip->name;
|
|
}
|
|
|
|
irq_clear_status_flags(virq, IRQ_NOREQUEST);
|
|
}
|
|
|
|
static void irq_domain_remove_irq(int virq)
|
|
{
|
|
struct irq_data *data;
|
|
|
|
irq_set_status_flags(virq, IRQ_NOREQUEST);
|
|
irq_set_chip_and_handler(virq, NULL, NULL);
|
|
synchronize_irq(virq);
|
|
smp_mb();
|
|
|
|
for (data = irq_get_irq_data(virq); data; data = data->parent_data) {
|
|
struct irq_domain *domain = data->domain;
|
|
irq_hw_number_t hwirq = data->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);
|
|
}
|
|
}
|
|
}
|
|
|
|
static struct irq_data *irq_domain_insert_irq_data(struct irq_domain *domain,
|
|
struct irq_data *child)
|
|
{
|
|
struct irq_data *irq_data;
|
|
|
|
irq_data = kzalloc_node(sizeof(*irq_data), GFP_KERNEL,
|
|
irq_data_get_node(child));
|
|
if (irq_data) {
|
|
child->parent_data = irq_data;
|
|
irq_data->irq = child->irq;
|
|
irq_data->common = child->common;
|
|
irq_data->domain = domain;
|
|
}
|
|
|
|
return irq_data;
|
|
}
|
|
|
|
static void irq_domain_free_irq_data(unsigned int virq, unsigned int nr_irqs)
|
|
{
|
|
struct irq_data *irq_data, *tmp;
|
|
int i;
|
|
|
|
for (i = 0; i < nr_irqs; i++) {
|
|
irq_data = irq_get_irq_data(virq + i);
|
|
tmp = irq_data->parent_data;
|
|
irq_data->parent_data = NULL;
|
|
irq_data->domain = NULL;
|
|
|
|
while (tmp) {
|
|
irq_data = tmp;
|
|
tmp = tmp->parent_data;
|
|
kfree(irq_data);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int irq_domain_alloc_irq_data(struct irq_domain *domain,
|
|
unsigned int virq, unsigned int nr_irqs)
|
|
{
|
|
struct irq_data *irq_data;
|
|
struct irq_domain *parent;
|
|
int i;
|
|
|
|
/* The outermost irq_data is embedded in struct irq_desc */
|
|
for (i = 0; i < nr_irqs; i++) {
|
|
irq_data = irq_get_irq_data(virq + i);
|
|
irq_data->domain = domain;
|
|
|
|
for (parent = domain->parent; parent; parent = parent->parent) {
|
|
irq_data = irq_domain_insert_irq_data(parent, irq_data);
|
|
if (!irq_data) {
|
|
irq_domain_free_irq_data(virq, i + 1);
|
|
return -ENOMEM;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
|
|
* @domain: domain to match
|
|
* @virq: IRQ number to get irq_data
|
|
*/
|
|
struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
|
|
unsigned int virq)
|
|
{
|
|
struct irq_data *irq_data;
|
|
|
|
for (irq_data = irq_get_irq_data(virq); irq_data;
|
|
irq_data = irq_data->parent_data)
|
|
if (irq_data->domain == domain)
|
|
return irq_data;
|
|
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_get_irq_data);
|
|
|
|
/**
|
|
* irq_domain_set_hwirq_and_chip - Set hwirq and irqchip of @virq at @domain
|
|
* @domain: Interrupt domain to match
|
|
* @virq: IRQ number
|
|
* @hwirq: The hwirq number
|
|
* @chip: The associated interrupt chip
|
|
* @chip_data: The associated chip data
|
|
*/
|
|
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)
|
|
{
|
|
struct irq_data *irq_data = irq_domain_get_irq_data(domain, virq);
|
|
|
|
if (!irq_data)
|
|
return -ENOENT;
|
|
|
|
irq_data->hwirq = hwirq;
|
|
irq_data->chip = chip ? chip : &no_irq_chip;
|
|
irq_data->chip_data = chip_data;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_set_hwirq_and_chip);
|
|
|
|
/**
|
|
* irq_domain_set_info - Set the complete data for a @virq in @domain
|
|
* @domain: Interrupt domain to match
|
|
* @virq: IRQ number
|
|
* @hwirq: The hardware interrupt number
|
|
* @chip: The associated interrupt chip
|
|
* @chip_data: The associated interrupt chip data
|
|
* @handler: The interrupt flow handler
|
|
* @handler_data: The interrupt flow handler data
|
|
* @handler_name: The interrupt handler name
|
|
*/
|
|
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)
|
|
{
|
|
irq_domain_set_hwirq_and_chip(domain, virq, hwirq, chip, chip_data);
|
|
__irq_set_handler(virq, handler, 0, handler_name);
|
|
irq_set_handler_data(virq, handler_data);
|
|
}
|
|
EXPORT_SYMBOL(irq_domain_set_info);
|
|
|
|
/**
|
|
* irq_domain_reset_irq_data - Clear hwirq, chip and chip_data in @irq_data
|
|
* @irq_data: The pointer to irq_data
|
|
*/
|
|
void irq_domain_reset_irq_data(struct irq_data *irq_data)
|
|
{
|
|
irq_data->hwirq = 0;
|
|
irq_data->chip = &no_irq_chip;
|
|
irq_data->chip_data = NULL;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_reset_irq_data);
|
|
|
|
/**
|
|
* irq_domain_free_irqs_common - Clear irq_data and free the parent
|
|
* @domain: Interrupt domain to match
|
|
* @virq: IRQ number to start with
|
|
* @nr_irqs: The number of irqs to free
|
|
*/
|
|
void irq_domain_free_irqs_common(struct irq_domain *domain, unsigned int virq,
|
|
unsigned int nr_irqs)
|
|
{
|
|
struct irq_data *irq_data;
|
|
int i;
|
|
|
|
for (i = 0; i < nr_irqs; i++) {
|
|
irq_data = irq_domain_get_irq_data(domain, virq + i);
|
|
if (irq_data)
|
|
irq_domain_reset_irq_data(irq_data);
|
|
}
|
|
irq_domain_free_irqs_parent(domain, virq, nr_irqs);
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_free_irqs_common);
|
|
|
|
/**
|
|
* irq_domain_free_irqs_top - Clear handler and handler data, clear irqdata and free parent
|
|
* @domain: Interrupt domain to match
|
|
* @virq: IRQ number to start with
|
|
* @nr_irqs: The number of irqs to free
|
|
*/
|
|
void irq_domain_free_irqs_top(struct irq_domain *domain, unsigned int virq,
|
|
unsigned int nr_irqs)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < nr_irqs; i++) {
|
|
irq_set_handler_data(virq + i, NULL);
|
|
irq_set_handler(virq + i, NULL);
|
|
}
|
|
irq_domain_free_irqs_common(domain, virq, nr_irqs);
|
|
}
|
|
|
|
static bool irq_domain_is_auto_recursive(struct irq_domain *domain)
|
|
{
|
|
return domain->flags & IRQ_DOMAIN_FLAG_AUTO_RECURSIVE;
|
|
}
|
|
|
|
static void irq_domain_free_irqs_recursive(struct irq_domain *domain,
|
|
unsigned int irq_base,
|
|
unsigned int nr_irqs)
|
|
{
|
|
domain->ops->free(domain, irq_base, nr_irqs);
|
|
if (irq_domain_is_auto_recursive(domain)) {
|
|
BUG_ON(!domain->parent);
|
|
irq_domain_free_irqs_recursive(domain->parent, irq_base,
|
|
nr_irqs);
|
|
}
|
|
}
|
|
|
|
int irq_domain_alloc_irqs_recursive(struct irq_domain *domain,
|
|
unsigned int irq_base,
|
|
unsigned int nr_irqs, void *arg)
|
|
{
|
|
int ret = 0;
|
|
struct irq_domain *parent = domain->parent;
|
|
bool recursive = irq_domain_is_auto_recursive(domain);
|
|
|
|
BUG_ON(recursive && !parent);
|
|
if (recursive)
|
|
ret = irq_domain_alloc_irqs_recursive(parent, irq_base,
|
|
nr_irqs, arg);
|
|
if (ret >= 0)
|
|
ret = domain->ops->alloc(domain, irq_base, nr_irqs, arg);
|
|
if (ret < 0 && recursive)
|
|
irq_domain_free_irqs_recursive(parent, irq_base, nr_irqs);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* __irq_domain_alloc_irqs - Allocate IRQs from domain
|
|
* @domain: domain to allocate from
|
|
* @irq_base: allocate specified IRQ nubmer if irq_base >= 0
|
|
* @nr_irqs: number of IRQs to allocate
|
|
* @node: NUMA node id for memory allocation
|
|
* @arg: domain specific argument
|
|
* @realloc: IRQ descriptors have already been allocated if true
|
|
*
|
|
* Allocate IRQ numbers and initialized all data structures to support
|
|
* hierarchy IRQ domains.
|
|
* Parameter @realloc is mainly to support legacy IRQs.
|
|
* Returns error code or allocated IRQ number
|
|
*
|
|
* The whole process to setup an IRQ has been split into two steps.
|
|
* The first step, __irq_domain_alloc_irqs(), is to allocate IRQ
|
|
* descriptor and required hardware resources. The second step,
|
|
* irq_domain_activate_irq(), is to program hardwares with preallocated
|
|
* resources. In this way, it's easier to rollback when failing to
|
|
* allocate resources.
|
|
*/
|
|
int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
|
|
unsigned int nr_irqs, int node, void *arg,
|
|
bool realloc)
|
|
{
|
|
int i, ret, virq;
|
|
|
|
if (domain == NULL) {
|
|
domain = irq_default_domain;
|
|
if (WARN(!domain, "domain is NULL; cannot allocate IRQ\n"))
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!domain->ops->alloc) {
|
|
pr_debug("domain->ops->alloc() is NULL\n");
|
|
return -ENOSYS;
|
|
}
|
|
|
|
if (realloc && irq_base >= 0) {
|
|
virq = irq_base;
|
|
} else {
|
|
virq = irq_domain_alloc_descs(irq_base, nr_irqs, 0, node);
|
|
if (virq < 0) {
|
|
pr_debug("cannot allocate IRQ(base %d, count %d)\n",
|
|
irq_base, nr_irqs);
|
|
return virq;
|
|
}
|
|
}
|
|
|
|
if (irq_domain_alloc_irq_data(domain, virq, nr_irqs)) {
|
|
pr_debug("cannot allocate memory for IRQ%d\n", virq);
|
|
ret = -ENOMEM;
|
|
goto out_free_desc;
|
|
}
|
|
|
|
mutex_lock(&irq_domain_mutex);
|
|
ret = irq_domain_alloc_irqs_recursive(domain, virq, nr_irqs, arg);
|
|
if (ret < 0) {
|
|
mutex_unlock(&irq_domain_mutex);
|
|
goto out_free_irq_data;
|
|
}
|
|
for (i = 0; i < nr_irqs; i++)
|
|
irq_domain_insert_irq(virq + i);
|
|
mutex_unlock(&irq_domain_mutex);
|
|
|
|
return virq;
|
|
|
|
out_free_irq_data:
|
|
irq_domain_free_irq_data(virq, nr_irqs);
|
|
out_free_desc:
|
|
irq_free_descs(virq, nr_irqs);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* irq_domain_free_irqs - Free IRQ number and associated data structures
|
|
* @virq: base IRQ number
|
|
* @nr_irqs: number of IRQs to free
|
|
*/
|
|
void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs)
|
|
{
|
|
struct irq_data *data = irq_get_irq_data(virq);
|
|
int i;
|
|
|
|
if (WARN(!data || !data->domain || !data->domain->ops->free,
|
|
"NULL pointer, cannot free irq\n"))
|
|
return;
|
|
|
|
mutex_lock(&irq_domain_mutex);
|
|
for (i = 0; i < nr_irqs; i++)
|
|
irq_domain_remove_irq(virq + i);
|
|
irq_domain_free_irqs_recursive(data->domain, virq, nr_irqs);
|
|
mutex_unlock(&irq_domain_mutex);
|
|
|
|
irq_domain_free_irq_data(virq, nr_irqs);
|
|
irq_free_descs(virq, nr_irqs);
|
|
}
|
|
|
|
/**
|
|
* irq_domain_alloc_irqs_parent - Allocate interrupts from parent domain
|
|
* @irq_base: Base IRQ number
|
|
* @nr_irqs: Number of IRQs to allocate
|
|
* @arg: Allocation data (arch/domain specific)
|
|
*
|
|
* Check whether the domain has been setup recursive. If not allocate
|
|
* through the parent domain.
|
|
*/
|
|
int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
|
|
unsigned int irq_base, unsigned int nr_irqs,
|
|
void *arg)
|
|
{
|
|
/* irq_domain_alloc_irqs_recursive() has called parent's alloc() */
|
|
if (irq_domain_is_auto_recursive(domain))
|
|
return 0;
|
|
|
|
domain = domain->parent;
|
|
if (domain)
|
|
return irq_domain_alloc_irqs_recursive(domain, irq_base,
|
|
nr_irqs, arg);
|
|
return -ENOSYS;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_alloc_irqs_parent);
|
|
|
|
/**
|
|
* irq_domain_free_irqs_parent - Free interrupts from parent domain
|
|
* @irq_base: Base IRQ number
|
|
* @nr_irqs: Number of IRQs to free
|
|
*
|
|
* Check whether the domain has been setup recursive. If not free
|
|
* through the parent domain.
|
|
*/
|
|
void irq_domain_free_irqs_parent(struct irq_domain *domain,
|
|
unsigned int irq_base, unsigned int nr_irqs)
|
|
{
|
|
/* irq_domain_free_irqs_recursive() will call parent's free */
|
|
if (!irq_domain_is_auto_recursive(domain) && domain->parent)
|
|
irq_domain_free_irqs_recursive(domain->parent, irq_base,
|
|
nr_irqs);
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent);
|
|
|
|
/**
|
|
* irq_domain_activate_irq - Call domain_ops->activate recursively to activate
|
|
* interrupt
|
|
* @irq_data: outermost irq_data associated with interrupt
|
|
*
|
|
* This is the second step to call domain_ops->activate to program interrupt
|
|
* controllers, so the interrupt could actually get delivered.
|
|
*/
|
|
void irq_domain_activate_irq(struct irq_data *irq_data)
|
|
{
|
|
if (irq_data && irq_data->domain) {
|
|
struct irq_domain *domain = irq_data->domain;
|
|
|
|
if (irq_data->parent_data)
|
|
irq_domain_activate_irq(irq_data->parent_data);
|
|
if (domain->ops->activate)
|
|
domain->ops->activate(domain, irq_data);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* irq_domain_deactivate_irq - Call domain_ops->deactivate recursively to
|
|
* deactivate interrupt
|
|
* @irq_data: outermost irq_data associated with interrupt
|
|
*
|
|
* It calls domain_ops->deactivate to program interrupt controllers to disable
|
|
* interrupt delivery.
|
|
*/
|
|
void irq_domain_deactivate_irq(struct irq_data *irq_data)
|
|
{
|
|
if (irq_data && irq_data->domain) {
|
|
struct irq_domain *domain = irq_data->domain;
|
|
|
|
if (domain->ops->deactivate)
|
|
domain->ops->deactivate(domain, irq_data);
|
|
if (irq_data->parent_data)
|
|
irq_domain_deactivate_irq(irq_data->parent_data);
|
|
}
|
|
}
|
|
|
|
static void irq_domain_check_hierarchy(struct irq_domain *domain)
|
|
{
|
|
/* Hierarchy irq_domains must implement callback alloc() */
|
|
if (domain->ops->alloc)
|
|
domain->flags |= IRQ_DOMAIN_FLAG_HIERARCHY;
|
|
}
|
|
#else /* CONFIG_IRQ_DOMAIN_HIERARCHY */
|
|
/**
|
|
* irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
|
|
* @domain: domain to match
|
|
* @virq: IRQ number to get irq_data
|
|
*/
|
|
struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
|
|
unsigned int virq)
|
|
{
|
|
struct irq_data *irq_data = irq_get_irq_data(virq);
|
|
|
|
return (irq_data && irq_data->domain == domain) ? irq_data : NULL;
|
|
}
|
|
EXPORT_SYMBOL_GPL(irq_domain_get_irq_data);
|
|
|
|
/**
|
|
* irq_domain_set_info - Set the complete data for a @virq in @domain
|
|
* @domain: Interrupt domain to match
|
|
* @virq: IRQ number
|
|
* @hwirq: The hardware interrupt number
|
|
* @chip: The associated interrupt chip
|
|
* @chip_data: The associated interrupt chip data
|
|
* @handler: The interrupt flow handler
|
|
* @handler_data: The interrupt flow handler data
|
|
* @handler_name: The interrupt handler name
|
|
*/
|
|
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)
|
|
{
|
|
irq_set_chip_and_handler_name(virq, chip, handler, handler_name);
|
|
irq_set_chip_data(virq, chip_data);
|
|
irq_set_handler_data(virq, handler_data);
|
|
}
|
|
|
|
static void irq_domain_check_hierarchy(struct irq_domain *domain)
|
|
{
|
|
}
|
|
#endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */
|