2018-03-14 21:15:19 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2010-09-22 15:09:43 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
|
|
|
|
* Copyright (C) 2005-2006, Thomas Gleixner, Russell King
|
|
|
|
*
|
2018-03-14 21:15:16 +00:00
|
|
|
* This file contains the interrupt descriptor management code. Detailed
|
|
|
|
* information is available in Documentation/core-api/genericirq.rst
|
2010-09-22 15:09:43 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
#include <linux/irq.h>
|
|
|
|
#include <linux/slab.h>
|
2011-09-20 00:33:19 +00:00
|
|
|
#include <linux/export.h>
|
2010-09-22 15:09:43 +00:00
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
#include <linux/radix-tree.h>
|
2010-09-27 15:48:26 +00:00
|
|
|
#include <linux/bitmap.h>
|
genirq: Add irq_domain-aware core IRQ handler
Calling irq_find_mapping from outside a irq_{enter,exit} section is
unsafe and produces ugly messages if CONFIG_PROVE_RCU is enabled:
If coming from the idle state, the rcu_read_lock call in irq_find_mapping
will generate an unpleasant warning:
<quote>
===============================
[ INFO: suspicious RCU usage. ]
3.16.0-rc1+ #135 Not tainted
-------------------------------
include/linux/rcupdate.h:871 rcu_read_lock() used illegally while idle!
other info that might help us debug this:
RCU used illegally from idle CPU!
rcu_scheduler_active = 1, debug_locks = 0
RCU used illegally from extended quiescent state!
1 lock held by swapper/0/0:
#0: (rcu_read_lock){......}, at: [<ffffffc00010206c>]
irq_find_mapping+0x4c/0x198
</quote>
As this issue is fairly widespread and involves at least three
different architectures, a possible solution is to add a new
handle_domain_irq entry point into the generic IRQ code that
the interrupt controller code can call.
This new function takes an irq_domain, and calls into irq_find_domain
inside the irq_{enter,exit} block. An additional "lookup" parameter is
used to allow non-domain architecture code to be replaced by this as well.
Interrupt controllers can then be updated to use the new mechanism.
This code is sitting behind a new CONFIG_HANDLE_DOMAIN_IRQ, as not all
architectures implement set_irq_regs (yes, mn10300, I'm looking at you...).
Reported-by: Vladimir Murzin <vladimir.murzin@arm.com>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Link: https://lkml.kernel.org/r/1409047421-27649-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Jason Cooper <jason@lakedaemon.net>
2014-08-26 10:03:16 +00:00
|
|
|
#include <linux/irqdomain.h>
|
2016-09-13 16:14:51 +00:00
|
|
|
#include <linux/sysfs.h>
|
2010-09-22 15:09:43 +00:00
|
|
|
|
|
|
|
#include "internals.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lockdep: we want to handle all irq_desc locks as a single lock-class:
|
|
|
|
*/
|
2010-09-29 15:18:47 +00:00
|
|
|
static struct lock_class_key irq_desc_lock_class;
|
2010-09-22 15:09:43 +00:00
|
|
|
|
2011-05-18 10:53:03 +00:00
|
|
|
#if defined(CONFIG_SMP)
|
2016-02-03 18:52:23 +00:00
|
|
|
static int __init irq_affinity_setup(char *str)
|
|
|
|
{
|
2017-11-01 04:14:51 +00:00
|
|
|
alloc_bootmem_cpumask_var(&irq_default_affinity);
|
2016-02-03 18:52:23 +00:00
|
|
|
cpulist_parse(str, irq_default_affinity);
|
|
|
|
/*
|
|
|
|
* Set at least the boot cpu. We don't want to end up with
|
|
|
|
* bugreports caused by random comandline masks
|
|
|
|
*/
|
|
|
|
cpumask_set_cpu(smp_processor_id(), irq_default_affinity);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("irqaffinity=", irq_affinity_setup);
|
|
|
|
|
2010-09-22 15:09:43 +00:00
|
|
|
static void __init init_irq_default_affinity(void)
|
|
|
|
{
|
2017-11-01 04:14:51 +00:00
|
|
|
if (!cpumask_available(irq_default_affinity))
|
2016-02-03 18:52:23 +00:00
|
|
|
zalloc_cpumask_var(&irq_default_affinity, GFP_NOWAIT);
|
|
|
|
if (cpumask_empty(irq_default_affinity))
|
|
|
|
cpumask_setall(irq_default_affinity);
|
2010-09-22 15:09:43 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void __init init_irq_default_affinity(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-09-27 15:48:26 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2017-06-19 23:37:36 +00:00
|
|
|
static int alloc_masks(struct irq_desc *desc, int node)
|
2010-09-27 15:48:26 +00:00
|
|
|
{
|
2015-06-03 03:47:50 +00:00
|
|
|
if (!zalloc_cpumask_var_node(&desc->irq_common_data.affinity,
|
2017-06-19 23:37:36 +00:00
|
|
|
GFP_KERNEL, node))
|
2010-09-27 15:48:26 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2017-06-19 23:37:38 +00:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
|
|
|
|
if (!zalloc_cpumask_var_node(&desc->irq_common_data.effective_affinity,
|
|
|
|
GFP_KERNEL, node)) {
|
|
|
|
free_cpumask_var(desc->irq_common_data.affinity);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-09-27 15:48:26 +00:00
|
|
|
#ifdef CONFIG_GENERIC_PENDING_IRQ
|
2017-06-19 23:37:36 +00:00
|
|
|
if (!zalloc_cpumask_var_node(&desc->pending_mask, GFP_KERNEL, node)) {
|
2017-06-19 23:37:38 +00:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
|
|
|
|
free_cpumask_var(desc->irq_common_data.effective_affinity);
|
|
|
|
#endif
|
2015-06-03 03:47:50 +00:00
|
|
|
free_cpumask_var(desc->irq_common_data.affinity);
|
2010-09-27 15:48:26 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-07-04 08:39:25 +00:00
|
|
|
static void desc_smp_init(struct irq_desc *desc, int node,
|
|
|
|
const struct cpumask *affinity)
|
2010-09-27 15:48:26 +00:00
|
|
|
{
|
2016-07-04 08:39:25 +00:00
|
|
|
if (!affinity)
|
|
|
|
affinity = irq_default_affinity;
|
|
|
|
cpumask_copy(desc->irq_common_data.affinity, affinity);
|
|
|
|
|
2010-09-29 16:46:55 +00:00
|
|
|
#ifdef CONFIG_GENERIC_PENDING_IRQ
|
|
|
|
cpumask_clear(desc->pending_mask);
|
|
|
|
#endif
|
2015-06-01 08:05:16 +00:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
desc->irq_common_data.node = node;
|
|
|
|
#endif
|
2010-09-29 16:46:55 +00:00
|
|
|
}
|
|
|
|
|
2010-09-27 15:48:26 +00:00
|
|
|
#else
|
|
|
|
static inline int
|
2017-06-19 23:37:36 +00:00
|
|
|
alloc_masks(struct irq_desc *desc, int node) { return 0; }
|
2016-07-04 08:39:25 +00:00
|
|
|
static inline void
|
|
|
|
desc_smp_init(struct irq_desc *desc, int node, const struct cpumask *affinity) { }
|
2010-09-27 15:48:26 +00:00
|
|
|
#endif
|
|
|
|
|
2011-07-11 10:17:31 +00:00
|
|
|
static void desc_set_defaults(unsigned int irq, struct irq_desc *desc, int node,
|
2016-07-04 08:39:25 +00:00
|
|
|
const struct cpumask *affinity, struct module *owner)
|
2010-09-27 15:48:26 +00:00
|
|
|
{
|
2011-01-13 23:45:38 +00:00
|
|
|
int cpu;
|
|
|
|
|
2015-06-01 08:05:21 +00:00
|
|
|
desc->irq_common_data.handler_data = NULL;
|
2015-06-01 08:05:43 +00:00
|
|
|
desc->irq_common_data.msi_desc = NULL;
|
2015-06-01 08:05:21 +00:00
|
|
|
|
2015-06-01 08:05:12 +00:00
|
|
|
desc->irq_data.common = &desc->irq_common_data;
|
2010-09-27 15:48:26 +00:00
|
|
|
desc->irq_data.irq = irq;
|
|
|
|
desc->irq_data.chip = &no_irq_chip;
|
|
|
|
desc->irq_data.chip_data = NULL;
|
2011-02-09 13:54:49 +00:00
|
|
|
irq_settings_clr_and_set(desc, ~0, _IRQ_DEFAULT_INIT_FLAGS);
|
2011-03-27 09:02:49 +00:00
|
|
|
irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
|
2017-06-26 11:33:33 +00:00
|
|
|
irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
|
2010-09-27 15:48:26 +00:00
|
|
|
desc->handle_irq = handle_bad_irq;
|
|
|
|
desc->depth = 1;
|
2010-09-29 16:46:55 +00:00
|
|
|
desc->irq_count = 0;
|
|
|
|
desc->irqs_unhandled = 0;
|
2010-09-27 15:48:26 +00:00
|
|
|
desc->name = NULL;
|
2011-07-11 10:17:31 +00:00
|
|
|
desc->owner = owner;
|
2011-01-13 23:45:38 +00:00
|
|
|
for_each_possible_cpu(cpu)
|
|
|
|
*per_cpu_ptr(desc->kstat_irqs, cpu) = 0;
|
2016-07-04 08:39:25 +00:00
|
|
|
desc_smp_init(desc, node, affinity);
|
2010-09-27 15:48:26 +00:00
|
|
|
}
|
|
|
|
|
2010-09-22 15:09:43 +00:00
|
|
|
int nr_irqs = NR_IRQS;
|
|
|
|
EXPORT_SYMBOL_GPL(nr_irqs);
|
|
|
|
|
2010-10-08 10:47:53 +00:00
|
|
|
static DEFINE_MUTEX(sparse_irq_lock);
|
2011-02-17 16:45:15 +00:00
|
|
|
static DECLARE_BITMAP(allocated_irqs, IRQ_BITMAP_BITS);
|
2010-09-27 15:48:26 +00:00
|
|
|
|
2010-09-22 15:09:43 +00:00
|
|
|
#ifdef CONFIG_SPARSE_IRQ
|
|
|
|
|
2016-09-13 16:14:51 +00:00
|
|
|
static void irq_kobj_release(struct kobject *kobj);
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYSFS
|
|
|
|
static struct kobject *irq_kobj_base;
|
|
|
|
|
|
|
|
#define IRQ_ATTR_RO(_name) \
|
|
|
|
static struct kobj_attribute _name##_attr = __ATTR_RO(_name)
|
|
|
|
|
|
|
|
static ssize_t per_cpu_count_show(struct kobject *kobj,
|
|
|
|
struct kobj_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj);
|
|
|
|
int cpu, irq = desc->irq_data.irq;
|
|
|
|
ssize_t ret = 0;
|
|
|
|
char *p = "";
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
unsigned int c = kstat_irqs_cpu(irq, cpu);
|
|
|
|
|
|
|
|
ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%u", p, c);
|
|
|
|
p = ",";
|
|
|
|
}
|
|
|
|
|
|
|
|
ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
IRQ_ATTR_RO(per_cpu_count);
|
|
|
|
|
|
|
|
static ssize_t chip_name_show(struct kobject *kobj,
|
|
|
|
struct kobj_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj);
|
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
raw_spin_lock_irq(&desc->lock);
|
|
|
|
if (desc->irq_data.chip && desc->irq_data.chip->name) {
|
|
|
|
ret = scnprintf(buf, PAGE_SIZE, "%s\n",
|
|
|
|
desc->irq_data.chip->name);
|
|
|
|
}
|
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
IRQ_ATTR_RO(chip_name);
|
|
|
|
|
|
|
|
static ssize_t hwirq_show(struct kobject *kobj,
|
|
|
|
struct kobj_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj);
|
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
raw_spin_lock_irq(&desc->lock);
|
|
|
|
if (desc->irq_data.domain)
|
|
|
|
ret = sprintf(buf, "%d\n", (int)desc->irq_data.hwirq);
|
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
IRQ_ATTR_RO(hwirq);
|
|
|
|
|
|
|
|
static ssize_t type_show(struct kobject *kobj,
|
|
|
|
struct kobj_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj);
|
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
raw_spin_lock_irq(&desc->lock);
|
|
|
|
ret = sprintf(buf, "%s\n",
|
|
|
|
irqd_is_level_type(&desc->irq_data) ? "level" : "edge");
|
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
IRQ_ATTR_RO(type);
|
|
|
|
|
2018-02-26 15:50:43 +00:00
|
|
|
static ssize_t wakeup_show(struct kobject *kobj,
|
|
|
|
struct kobj_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj);
|
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
raw_spin_lock_irq(&desc->lock);
|
|
|
|
ret = sprintf(buf, "%s\n",
|
|
|
|
irqd_is_wakeup_set(&desc->irq_data) ? "enabled" : "disabled");
|
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
IRQ_ATTR_RO(wakeup);
|
|
|
|
|
2016-09-13 16:14:51 +00:00
|
|
|
static ssize_t name_show(struct kobject *kobj,
|
|
|
|
struct kobj_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj);
|
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
raw_spin_lock_irq(&desc->lock);
|
|
|
|
if (desc->name)
|
|
|
|
ret = scnprintf(buf, PAGE_SIZE, "%s\n", desc->name);
|
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
IRQ_ATTR_RO(name);
|
|
|
|
|
|
|
|
static ssize_t actions_show(struct kobject *kobj,
|
|
|
|
struct kobj_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj);
|
|
|
|
struct irqaction *action;
|
|
|
|
ssize_t ret = 0;
|
|
|
|
char *p = "";
|
|
|
|
|
|
|
|
raw_spin_lock_irq(&desc->lock);
|
|
|
|
for (action = desc->action; action != NULL; action = action->next) {
|
|
|
|
ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s",
|
|
|
|
p, action->name);
|
|
|
|
p = ",";
|
|
|
|
}
|
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n");
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
IRQ_ATTR_RO(actions);
|
|
|
|
|
|
|
|
static struct attribute *irq_attrs[] = {
|
|
|
|
&per_cpu_count_attr.attr,
|
|
|
|
&chip_name_attr.attr,
|
|
|
|
&hwirq_attr.attr,
|
|
|
|
&type_attr.attr,
|
2018-02-26 15:50:43 +00:00
|
|
|
&wakeup_attr.attr,
|
2016-09-13 16:14:51 +00:00
|
|
|
&name_attr.attr,
|
|
|
|
&actions_attr.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct kobj_type irq_kobj_type = {
|
|
|
|
.release = irq_kobj_release,
|
|
|
|
.sysfs_ops = &kobj_sysfs_ops,
|
|
|
|
.default_attrs = irq_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void irq_sysfs_add(int irq, struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
if (irq_kobj_base) {
|
|
|
|
/*
|
|
|
|
* Continue even in case of failure as this is nothing
|
|
|
|
* crucial.
|
|
|
|
*/
|
|
|
|
if (kobject_add(&desc->kobj, irq_kobj_base, "%d", irq))
|
|
|
|
pr_warn("Failed to add kobject for irq %d\n", irq);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init irq_sysfs_init(void)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc;
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
/* Prevent concurrent irq alloc/free */
|
|
|
|
irq_lock_sparse();
|
|
|
|
|
|
|
|
irq_kobj_base = kobject_create_and_add("irq", kernel_kobj);
|
|
|
|
if (!irq_kobj_base) {
|
|
|
|
irq_unlock_sparse();
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add the already allocated interrupts */
|
|
|
|
for_each_irq_desc(irq, desc)
|
|
|
|
irq_sysfs_add(irq, desc);
|
|
|
|
irq_unlock_sparse();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
postcore_initcall(irq_sysfs_init);
|
|
|
|
|
|
|
|
#else /* !CONFIG_SYSFS */
|
|
|
|
|
|
|
|
static struct kobj_type irq_kobj_type = {
|
|
|
|
.release = irq_kobj_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void irq_sysfs_add(int irq, struct irq_desc *desc) {}
|
|
|
|
|
|
|
|
#endif /* CONFIG_SYSFS */
|
|
|
|
|
2010-10-05 13:14:35 +00:00
|
|
|
static RADIX_TREE(irq_desc_tree, GFP_KERNEL);
|
2010-09-22 15:09:43 +00:00
|
|
|
|
2010-09-27 15:48:26 +00:00
|
|
|
static void irq_insert_desc(unsigned int irq, struct irq_desc *desc)
|
2010-09-22 15:09:43 +00:00
|
|
|
{
|
|
|
|
radix_tree_insert(&irq_desc_tree, irq, desc);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct irq_desc *irq_to_desc(unsigned int irq)
|
|
|
|
{
|
|
|
|
return radix_tree_lookup(&irq_desc_tree, irq);
|
|
|
|
}
|
2012-05-13 10:13:15 +00:00
|
|
|
EXPORT_SYMBOL(irq_to_desc);
|
2010-09-22 15:09:43 +00:00
|
|
|
|
2010-09-27 15:48:26 +00:00
|
|
|
static void delete_irq_desc(unsigned int irq)
|
|
|
|
{
|
|
|
|
radix_tree_delete(&irq_desc_tree, irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
static void free_masks(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_GENERIC_PENDING_IRQ
|
|
|
|
free_cpumask_var(desc->pending_mask);
|
|
|
|
#endif
|
2015-06-03 03:47:50 +00:00
|
|
|
free_cpumask_var(desc->irq_common_data.affinity);
|
2017-06-19 23:37:38 +00:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
|
|
|
|
free_cpumask_var(desc->irq_common_data.effective_affinity);
|
|
|
|
#endif
|
2010-09-27 15:48:26 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void free_masks(struct irq_desc *desc) { }
|
|
|
|
#endif
|
|
|
|
|
2014-12-11 22:01:41 +00:00
|
|
|
void irq_lock_sparse(void)
|
|
|
|
{
|
|
|
|
mutex_lock(&sparse_irq_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void irq_unlock_sparse(void)
|
|
|
|
{
|
|
|
|
mutex_unlock(&sparse_irq_lock);
|
|
|
|
}
|
|
|
|
|
2016-07-04 08:39:25 +00:00
|
|
|
static struct irq_desc *alloc_desc(int irq, int node, unsigned int flags,
|
|
|
|
const struct cpumask *affinity,
|
|
|
|
struct module *owner)
|
2010-09-27 15:48:26 +00:00
|
|
|
{
|
|
|
|
struct irq_desc *desc;
|
|
|
|
|
2017-06-19 23:37:36 +00:00
|
|
|
desc = kzalloc_node(sizeof(*desc), GFP_KERNEL, node);
|
2010-09-27 15:48:26 +00:00
|
|
|
if (!desc)
|
|
|
|
return NULL;
|
|
|
|
/* allocate based on nr_cpu_ids */
|
2011-01-13 23:45:38 +00:00
|
|
|
desc->kstat_irqs = alloc_percpu(unsigned int);
|
2010-09-27 15:48:26 +00:00
|
|
|
if (!desc->kstat_irqs)
|
|
|
|
goto err_desc;
|
|
|
|
|
2017-06-19 23:37:36 +00:00
|
|
|
if (alloc_masks(desc, node))
|
2010-09-27 15:48:26 +00:00
|
|
|
goto err_kstat;
|
|
|
|
|
|
|
|
raw_spin_lock_init(&desc->lock);
|
|
|
|
lockdep_set_class(&desc->lock, &irq_desc_lock_class);
|
2017-06-29 21:33:37 +00:00
|
|
|
mutex_init(&desc->request_mutex);
|
2015-12-13 17:02:22 +00:00
|
|
|
init_rcu_head(&desc->rcu);
|
2010-09-27 15:48:26 +00:00
|
|
|
|
2016-07-04 08:39:25 +00:00
|
|
|
desc_set_defaults(irq, desc, node, affinity, owner);
|
|
|
|
irqd_set(&desc->irq_data, flags);
|
2016-09-13 16:14:51 +00:00
|
|
|
kobject_init(&desc->kobj, &irq_kobj_type);
|
2010-09-27 15:48:26 +00:00
|
|
|
|
|
|
|
return desc;
|
|
|
|
|
|
|
|
err_kstat:
|
2011-01-13 23:45:38 +00:00
|
|
|
free_percpu(desc->kstat_irqs);
|
2010-09-27 15:48:26 +00:00
|
|
|
err_desc:
|
|
|
|
kfree(desc);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-09-13 16:14:51 +00:00
|
|
|
static void irq_kobj_release(struct kobject *kobj)
|
2015-12-13 17:02:22 +00:00
|
|
|
{
|
2016-09-13 16:14:51 +00:00
|
|
|
struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj);
|
2015-12-13 17:02:22 +00:00
|
|
|
|
|
|
|
free_masks(desc);
|
|
|
|
free_percpu(desc->kstat_irqs);
|
|
|
|
kfree(desc);
|
|
|
|
}
|
|
|
|
|
2016-09-13 16:14:51 +00:00
|
|
|
static void delayed_free_desc(struct rcu_head *rhp)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = container_of(rhp, struct irq_desc, rcu);
|
|
|
|
|
|
|
|
kobject_put(&desc->kobj);
|
|
|
|
}
|
|
|
|
|
2010-09-27 15:48:26 +00:00
|
|
|
static void free_desc(unsigned int irq)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
2017-06-19 23:37:17 +00:00
|
|
|
irq_remove_debugfs_entry(desc);
|
2010-09-30 00:46:07 +00:00
|
|
|
unregister_irq_proc(irq, desc);
|
|
|
|
|
2014-12-11 22:01:41 +00:00
|
|
|
/*
|
|
|
|
* sparse_irq_lock protects also show_interrupts() and
|
|
|
|
* kstat_irq_usr(). Once we deleted the descriptor from the
|
|
|
|
* sparse tree we can free it. Access in proc will fail to
|
|
|
|
* lookup the descriptor.
|
2016-09-13 16:14:51 +00:00
|
|
|
*
|
|
|
|
* The sysfs entry must be serialized against a concurrent
|
|
|
|
* irq_sysfs_init() as well.
|
2014-12-11 22:01:41 +00:00
|
|
|
*/
|
2016-09-13 16:14:51 +00:00
|
|
|
kobject_del(&desc->kobj);
|
2010-09-27 15:48:26 +00:00
|
|
|
delete_irq_desc(irq);
|
|
|
|
|
2015-12-13 17:02:22 +00:00
|
|
|
/*
|
|
|
|
* We free the descriptor, masks and stat fields via RCU. That
|
|
|
|
* allows demultiplex interrupts to do rcu based management of
|
|
|
|
* the child interrupts.
|
2018-06-18 12:56:12 +00:00
|
|
|
* This also allows us to use rcu in kstat_irqs_usr().
|
2015-12-13 17:02:22 +00:00
|
|
|
*/
|
|
|
|
call_rcu(&desc->rcu, delayed_free_desc);
|
2010-09-27 15:48:26 +00:00
|
|
|
}
|
|
|
|
|
2011-07-11 10:17:31 +00:00
|
|
|
static int alloc_descs(unsigned int start, unsigned int cnt, int node,
|
2018-12-04 15:51:20 +00:00
|
|
|
const struct irq_affinity_desc *affinity,
|
|
|
|
struct module *owner)
|
2010-09-27 15:48:26 +00:00
|
|
|
{
|
|
|
|
struct irq_desc *desc;
|
2016-09-14 14:18:49 +00:00
|
|
|
int i;
|
2016-07-04 08:39:25 +00:00
|
|
|
|
2016-09-14 14:18:49 +00:00
|
|
|
/* Validate affinity mask(s) */
|
|
|
|
if (affinity) {
|
2019-01-17 03:00:09 +00:00
|
|
|
for (i = 0; i < cnt; i++) {
|
2018-12-04 15:51:20 +00:00
|
|
|
if (cpumask_empty(&affinity[i].mask))
|
2016-09-14 14:18:49 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2016-07-04 08:39:25 +00:00
|
|
|
|
2010-09-27 15:48:26 +00:00
|
|
|
for (i = 0; i < cnt; i++) {
|
2018-12-04 15:51:20 +00:00
|
|
|
const struct cpumask *mask = NULL;
|
2018-12-04 15:51:21 +00:00
|
|
|
unsigned int flags = 0;
|
2018-12-04 15:51:20 +00:00
|
|
|
|
2016-07-04 08:39:25 +00:00
|
|
|
if (affinity) {
|
2018-12-04 15:51:21 +00:00
|
|
|
if (affinity->is_managed) {
|
|
|
|
flags = IRQD_AFFINITY_MANAGED |
|
|
|
|
IRQD_MANAGED_SHUTDOWN;
|
|
|
|
}
|
2018-12-04 15:51:20 +00:00
|
|
|
mask = &affinity->mask;
|
2018-12-04 15:51:21 +00:00
|
|
|
node = cpu_to_node(cpumask_first(mask));
|
2016-09-14 14:18:49 +00:00
|
|
|
affinity++;
|
2016-07-04 08:39:25 +00:00
|
|
|
}
|
2018-12-04 15:51:21 +00:00
|
|
|
|
2016-07-04 08:39:25 +00:00
|
|
|
desc = alloc_desc(start + i, node, flags, mask, owner);
|
2010-09-27 15:48:26 +00:00
|
|
|
if (!desc)
|
|
|
|
goto err;
|
|
|
|
irq_insert_desc(start + i, desc);
|
2016-09-13 16:14:51 +00:00
|
|
|
irq_sysfs_add(start + i, desc);
|
2017-09-13 21:29:04 +00:00
|
|
|
irq_add_debugfs_entry(start + i, desc);
|
2010-09-27 15:48:26 +00:00
|
|
|
}
|
2017-09-05 08:12:20 +00:00
|
|
|
bitmap_set(allocated_irqs, start, cnt);
|
2010-09-27 15:48:26 +00:00
|
|
|
return start;
|
|
|
|
|
|
|
|
err:
|
|
|
|
for (i--; i >= 0; i--)
|
|
|
|
free_desc(start + i);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2011-02-19 19:07:37 +00:00
|
|
|
static int irq_expand_nr_irqs(unsigned int nr)
|
2011-02-16 16:12:57 +00:00
|
|
|
{
|
2011-02-19 19:07:37 +00:00
|
|
|
if (nr > IRQ_BITMAP_BITS)
|
2011-02-16 16:12:57 +00:00
|
|
|
return -ENOMEM;
|
2011-02-19 19:07:37 +00:00
|
|
|
nr_irqs = nr;
|
2011-02-16 16:12:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-22 15:09:43 +00:00
|
|
|
int __init early_irq_init(void)
|
|
|
|
{
|
2010-09-27 18:55:03 +00:00
|
|
|
int i, initcnt, node = first_online_node;
|
2010-09-22 15:09:43 +00:00
|
|
|
struct irq_desc *desc;
|
|
|
|
|
|
|
|
init_irq_default_affinity();
|
|
|
|
|
2010-09-27 18:55:03 +00:00
|
|
|
/* Let arch update nr_irqs and return the nr of preallocated irqs */
|
|
|
|
initcnt = arch_probe_nr_irqs();
|
2017-05-09 08:34:09 +00:00
|
|
|
printk(KERN_INFO "NR_IRQS: %d, nr_irqs: %d, preallocated irqs: %d\n",
|
|
|
|
NR_IRQS, nr_irqs, initcnt);
|
2010-09-22 15:09:43 +00:00
|
|
|
|
2011-02-17 16:45:15 +00:00
|
|
|
if (WARN_ON(nr_irqs > IRQ_BITMAP_BITS))
|
|
|
|
nr_irqs = IRQ_BITMAP_BITS;
|
|
|
|
|
|
|
|
if (WARN_ON(initcnt > IRQ_BITMAP_BITS))
|
|
|
|
initcnt = IRQ_BITMAP_BITS;
|
|
|
|
|
|
|
|
if (initcnt > nr_irqs)
|
|
|
|
nr_irqs = initcnt;
|
|
|
|
|
2010-09-27 18:55:03 +00:00
|
|
|
for (i = 0; i < initcnt; i++) {
|
2016-07-04 08:39:25 +00:00
|
|
|
desc = alloc_desc(i, node, 0, NULL, NULL);
|
2010-09-27 18:02:56 +00:00
|
|
|
set_bit(i, allocated_irqs);
|
|
|
|
irq_insert_desc(i, desc);
|
2010-09-22 15:09:43 +00:00
|
|
|
}
|
|
|
|
return arch_early_irq_init();
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* !CONFIG_SPARSE_IRQ */
|
|
|
|
|
|
|
|
struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
|
|
|
|
[0 ... NR_IRQS-1] = {
|
|
|
|
.handle_irq = handle_bad_irq,
|
|
|
|
.depth = 1,
|
|
|
|
.lock = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
int __init early_irq_init(void)
|
|
|
|
{
|
2010-09-27 18:02:56 +00:00
|
|
|
int count, i, node = first_online_node;
|
2010-09-22 15:09:43 +00:00
|
|
|
struct irq_desc *desc;
|
|
|
|
|
|
|
|
init_irq_default_affinity();
|
|
|
|
|
2017-05-09 08:34:09 +00:00
|
|
|
printk(KERN_INFO "NR_IRQS: %d\n", NR_IRQS);
|
2010-09-22 15:09:43 +00:00
|
|
|
|
|
|
|
desc = irq_desc;
|
|
|
|
count = ARRAY_SIZE(irq_desc);
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
2011-01-13 23:45:38 +00:00
|
|
|
desc[i].kstat_irqs = alloc_percpu(unsigned int);
|
2017-06-19 23:37:36 +00:00
|
|
|
alloc_masks(&desc[i], node);
|
2011-05-31 16:14:39 +00:00
|
|
|
raw_spin_lock_init(&desc[i].lock);
|
2010-09-22 13:58:45 +00:00
|
|
|
lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
|
2016-07-04 08:39:25 +00:00
|
|
|
desc_set_defaults(i, &desc[i], node, NULL, NULL);
|
2010-09-22 15:09:43 +00:00
|
|
|
}
|
|
|
|
return arch_early_irq_init();
|
|
|
|
}
|
|
|
|
|
|
|
|
struct irq_desc *irq_to_desc(unsigned int irq)
|
|
|
|
{
|
|
|
|
return (irq < NR_IRQS) ? irq_desc + irq : NULL;
|
|
|
|
}
|
2014-02-10 18:39:53 +00:00
|
|
|
EXPORT_SYMBOL(irq_to_desc);
|
2010-09-22 15:09:43 +00:00
|
|
|
|
2010-09-27 15:48:26 +00:00
|
|
|
static void free_desc(unsigned int irq)
|
|
|
|
{
|
2014-05-07 15:44:23 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2016-07-04 08:39:25 +00:00
|
|
|
desc_set_defaults(irq, desc, irq_desc_get_node(desc), NULL, NULL);
|
2014-05-07 15:44:23 +00:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2010-09-27 15:48:26 +00:00
|
|
|
}
|
|
|
|
|
2011-07-11 10:17:31 +00:00
|
|
|
static inline int alloc_descs(unsigned int start, unsigned int cnt, int node,
|
2018-12-04 15:51:20 +00:00
|
|
|
const struct irq_affinity_desc *affinity,
|
2011-07-11 10:17:31 +00:00
|
|
|
struct module *owner)
|
2010-09-27 15:48:26 +00:00
|
|
|
{
|
2011-07-11 10:17:31 +00:00
|
|
|
u32 i;
|
|
|
|
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
struct irq_desc *desc = irq_to_desc(start + i);
|
|
|
|
|
|
|
|
desc->owner = owner;
|
|
|
|
}
|
2017-09-05 08:12:20 +00:00
|
|
|
bitmap_set(allocated_irqs, start, cnt);
|
2010-09-27 15:48:26 +00:00
|
|
|
return start;
|
|
|
|
}
|
2011-02-16 16:12:57 +00:00
|
|
|
|
2011-02-19 19:07:37 +00:00
|
|
|
static int irq_expand_nr_irqs(unsigned int nr)
|
2011-02-16 16:12:57 +00:00
|
|
|
{
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2014-05-07 15:44:21 +00:00
|
|
|
void irq_mark_irq(unsigned int irq)
|
|
|
|
{
|
|
|
|
mutex_lock(&sparse_irq_lock);
|
|
|
|
bitmap_set(allocated_irqs, irq, 1);
|
|
|
|
mutex_unlock(&sparse_irq_lock);
|
|
|
|
}
|
|
|
|
|
2014-05-07 15:44:22 +00:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_LEGACY
|
|
|
|
void irq_init_desc(unsigned int irq)
|
|
|
|
{
|
2014-05-07 15:44:23 +00:00
|
|
|
free_desc(irq);
|
2014-05-07 15:44:22 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-09-22 15:09:43 +00:00
|
|
|
#endif /* !CONFIG_SPARSE_IRQ */
|
|
|
|
|
2011-05-18 10:48:00 +00:00
|
|
|
/**
|
|
|
|
* generic_handle_irq - Invoke the handler for a particular irq
|
|
|
|
* @irq: The irq number to handle
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int generic_handle_irq(unsigned int irq)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
|
|
|
if (!desc)
|
|
|
|
return -EINVAL;
|
2015-09-14 08:42:37 +00:00
|
|
|
generic_handle_irq_desc(desc);
|
2011-05-18 10:48:00 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2011-05-18 09:39:04 +00:00
|
|
|
EXPORT_SYMBOL_GPL(generic_handle_irq);
|
2011-05-18 10:48:00 +00:00
|
|
|
|
genirq: Add irq_domain-aware core IRQ handler
Calling irq_find_mapping from outside a irq_{enter,exit} section is
unsafe and produces ugly messages if CONFIG_PROVE_RCU is enabled:
If coming from the idle state, the rcu_read_lock call in irq_find_mapping
will generate an unpleasant warning:
<quote>
===============================
[ INFO: suspicious RCU usage. ]
3.16.0-rc1+ #135 Not tainted
-------------------------------
include/linux/rcupdate.h:871 rcu_read_lock() used illegally while idle!
other info that might help us debug this:
RCU used illegally from idle CPU!
rcu_scheduler_active = 1, debug_locks = 0
RCU used illegally from extended quiescent state!
1 lock held by swapper/0/0:
#0: (rcu_read_lock){......}, at: [<ffffffc00010206c>]
irq_find_mapping+0x4c/0x198
</quote>
As this issue is fairly widespread and involves at least three
different architectures, a possible solution is to add a new
handle_domain_irq entry point into the generic IRQ code that
the interrupt controller code can call.
This new function takes an irq_domain, and calls into irq_find_domain
inside the irq_{enter,exit} block. An additional "lookup" parameter is
used to allow non-domain architecture code to be replaced by this as well.
Interrupt controllers can then be updated to use the new mechanism.
This code is sitting behind a new CONFIG_HANDLE_DOMAIN_IRQ, as not all
architectures implement set_irq_regs (yes, mn10300, I'm looking at you...).
Reported-by: Vladimir Murzin <vladimir.murzin@arm.com>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Link: https://lkml.kernel.org/r/1409047421-27649-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Jason Cooper <jason@lakedaemon.net>
2014-08-26 10:03:16 +00:00
|
|
|
#ifdef CONFIG_HANDLE_DOMAIN_IRQ
|
|
|
|
/**
|
|
|
|
* __handle_domain_irq - Invoke the handler for a HW irq belonging to a domain
|
|
|
|
* @domain: The domain where to perform the lookup
|
|
|
|
* @hwirq: The HW irq number to convert to a logical one
|
|
|
|
* @lookup: Whether to perform the domain lookup or not
|
|
|
|
* @regs: Register file coming from the low-level handling code
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, or -EINVAL if conversion has failed
|
|
|
|
*/
|
|
|
|
int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq,
|
|
|
|
bool lookup, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct pt_regs *old_regs = set_irq_regs(regs);
|
|
|
|
unsigned int irq = hwirq;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
irq_enter();
|
|
|
|
|
|
|
|
#ifdef CONFIG_IRQ_DOMAIN
|
|
|
|
if (lookup)
|
|
|
|
irq = irq_find_mapping(domain, hwirq);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some hardware gives randomly wrong interrupts. Rather
|
|
|
|
* than crashing, do something sensible.
|
|
|
|
*/
|
|
|
|
if (unlikely(!irq || irq >= nr_irqs)) {
|
|
|
|
ack_bad_irq(irq);
|
|
|
|
ret = -EINVAL;
|
|
|
|
} else {
|
|
|
|
generic_handle_irq(irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
irq_exit();
|
|
|
|
set_irq_regs(old_regs);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-09-27 15:48:26 +00:00
|
|
|
/* Dynamic interrupt handling */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_free_descs - free irq descriptors
|
|
|
|
* @from: Start of descriptor range
|
|
|
|
* @cnt: Number of consecutive irqs to free
|
|
|
|
*/
|
|
|
|
void irq_free_descs(unsigned int from, unsigned int cnt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (from >= nr_irqs || (from + cnt) > nr_irqs)
|
|
|
|
return;
|
|
|
|
|
2017-09-05 08:12:20 +00:00
|
|
|
mutex_lock(&sparse_irq_lock);
|
2010-09-27 15:48:26 +00:00
|
|
|
for (i = 0; i < cnt; i++)
|
|
|
|
free_desc(from + i);
|
|
|
|
|
|
|
|
bitmap_clear(allocated_irqs, from, cnt);
|
2010-10-08 10:47:53 +00:00
|
|
|
mutex_unlock(&sparse_irq_lock);
|
2010-09-27 15:48:26 +00:00
|
|
|
}
|
2011-05-18 09:39:04 +00:00
|
|
|
EXPORT_SYMBOL_GPL(irq_free_descs);
|
2010-09-27 15:48:26 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_alloc_descs - allocate and initialize a range of irq descriptors
|
|
|
|
* @irq: Allocate for specific irq number if irq >= 0
|
|
|
|
* @from: Start the search from this irq number
|
|
|
|
* @cnt: Number of consecutive irqs to allocate.
|
|
|
|
* @node: Preferred node on which the irq descriptor should be allocated
|
2011-08-18 19:19:27 +00:00
|
|
|
* @owner: Owning module (can be NULL)
|
2016-09-14 14:18:49 +00:00
|
|
|
* @affinity: Optional pointer to an affinity mask array of size @cnt which
|
|
|
|
* hints where the irq descriptors should be allocated and which
|
|
|
|
* default affinities to use
|
2010-09-27 15:48:26 +00:00
|
|
|
*
|
|
|
|
* Returns the first irq number or error code
|
|
|
|
*/
|
|
|
|
int __ref
|
2011-07-11 10:17:31 +00:00
|
|
|
__irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node,
|
2018-12-04 15:51:20 +00:00
|
|
|
struct module *owner, const struct irq_affinity_desc *affinity)
|
2010-09-27 15:48:26 +00:00
|
|
|
{
|
|
|
|
int start, ret;
|
|
|
|
|
|
|
|
if (!cnt)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-06-02 17:55:13 +00:00
|
|
|
if (irq >= 0) {
|
|
|
|
if (from > irq)
|
|
|
|
return -EINVAL;
|
|
|
|
from = irq;
|
2014-04-24 07:50:53 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* For interrupts which are freely allocated the
|
|
|
|
* architecture can force a lower bound to the @from
|
|
|
|
* argument. x86 uses this to exclude the GSI space.
|
|
|
|
*/
|
|
|
|
from = arch_dynirq_lower_bound(from);
|
2011-06-02 17:55:13 +00:00
|
|
|
}
|
|
|
|
|
2010-10-08 10:47:53 +00:00
|
|
|
mutex_lock(&sparse_irq_lock);
|
2010-09-27 15:48:26 +00:00
|
|
|
|
2011-02-19 19:07:37 +00:00
|
|
|
start = bitmap_find_next_zero_area(allocated_irqs, IRQ_BITMAP_BITS,
|
|
|
|
from, cnt, 0);
|
2010-09-27 15:48:26 +00:00
|
|
|
ret = -EEXIST;
|
|
|
|
if (irq >=0 && start != irq)
|
2017-09-05 08:12:20 +00:00
|
|
|
goto unlock;
|
2010-09-27 15:48:26 +00:00
|
|
|
|
2011-02-19 19:07:37 +00:00
|
|
|
if (start + cnt > nr_irqs) {
|
|
|
|
ret = irq_expand_nr_irqs(start + cnt);
|
2011-02-16 16:12:57 +00:00
|
|
|
if (ret)
|
2017-09-05 08:12:20 +00:00
|
|
|
goto unlock;
|
2011-02-16 16:12:57 +00:00
|
|
|
}
|
2017-09-05 08:12:20 +00:00
|
|
|
ret = alloc_descs(start, cnt, node, affinity, owner);
|
|
|
|
unlock:
|
2010-10-08 10:47:53 +00:00
|
|
|
mutex_unlock(&sparse_irq_lock);
|
2010-09-27 15:48:26 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2011-07-11 10:17:31 +00:00
|
|
|
EXPORT_SYMBOL_GPL(__irq_alloc_descs);
|
2010-09-27 15:48:26 +00:00
|
|
|
|
2014-05-07 15:44:05 +00:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_LEGACY_ALLOC_HWIRQ
|
|
|
|
/**
|
|
|
|
* irq_alloc_hwirqs - Allocate an irq descriptor and initialize the hardware
|
|
|
|
* @cnt: number of interrupts to allocate
|
|
|
|
* @node: node on which to allocate
|
|
|
|
*
|
|
|
|
* Returns an interrupt number > 0 or 0, if the allocation fails.
|
|
|
|
*/
|
|
|
|
unsigned int irq_alloc_hwirqs(int cnt, int node)
|
|
|
|
{
|
2016-07-04 08:39:24 +00:00
|
|
|
int i, irq = __irq_alloc_descs(-1, 0, cnt, node, NULL, NULL);
|
2014-05-07 15:44:05 +00:00
|
|
|
|
|
|
|
if (irq < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (i = irq; cnt > 0; i++, cnt--) {
|
|
|
|
if (arch_setup_hwirq(i, node))
|
|
|
|
goto err;
|
|
|
|
irq_clear_status_flags(i, _IRQ_NOREQUEST);
|
|
|
|
}
|
|
|
|
return irq;
|
|
|
|
|
|
|
|
err:
|
|
|
|
for (i--; i >= irq; i--) {
|
|
|
|
irq_set_status_flags(i, _IRQ_NOREQUEST | _IRQ_NOPROBE);
|
|
|
|
arch_teardown_hwirq(i);
|
|
|
|
}
|
|
|
|
irq_free_descs(irq, cnt);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(irq_alloc_hwirqs);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_free_hwirqs - Free irq descriptor and cleanup the hardware
|
|
|
|
* @from: Free from irq number
|
|
|
|
* @cnt: number of interrupts to free
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void irq_free_hwirqs(unsigned int from, int cnt)
|
|
|
|
{
|
2014-06-30 22:24:44 +00:00
|
|
|
int i, j;
|
2014-05-07 15:44:05 +00:00
|
|
|
|
2014-06-30 22:24:44 +00:00
|
|
|
for (i = from, j = cnt; j > 0; i++, j--) {
|
2014-05-07 15:44:05 +00:00
|
|
|
irq_set_status_flags(i, _IRQ_NOREQUEST | _IRQ_NOPROBE);
|
|
|
|
arch_teardown_hwirq(i);
|
|
|
|
}
|
|
|
|
irq_free_descs(from, cnt);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(irq_free_hwirqs);
|
|
|
|
#endif
|
|
|
|
|
2010-09-30 08:45:07 +00:00
|
|
|
/**
|
|
|
|
* irq_get_next_irq - get next allocated irq number
|
|
|
|
* @offset: where to start the search
|
|
|
|
*
|
|
|
|
* Returns next irq number after offset or nr_irqs if none is found.
|
|
|
|
*/
|
|
|
|
unsigned int irq_get_next_irq(unsigned int offset)
|
|
|
|
{
|
|
|
|
return find_next_bit(allocated_irqs, nr_irqs, offset);
|
|
|
|
}
|
|
|
|
|
2011-02-12 11:16:16 +00:00
|
|
|
struct irq_desc *
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-23 16:03:06 +00:00
|
|
|
__irq_get_desc_lock(unsigned int irq, unsigned long *flags, bool bus,
|
|
|
|
unsigned int check)
|
2011-02-12 11:16:16 +00:00
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
|
|
|
if (desc) {
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-23 16:03:06 +00:00
|
|
|
if (check & _IRQ_DESC_CHECK) {
|
|
|
|
if ((check & _IRQ_DESC_PERCPU) &&
|
|
|
|
!irq_settings_is_per_cpu_devid(desc))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!(check & _IRQ_DESC_PERCPU) &&
|
|
|
|
irq_settings_is_per_cpu_devid(desc))
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-02-12 11:16:16 +00:00
|
|
|
if (bus)
|
|
|
|
chip_bus_lock(desc);
|
|
|
|
raw_spin_lock_irqsave(&desc->lock, *flags);
|
|
|
|
}
|
|
|
|
return desc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __irq_put_desc_unlock(struct irq_desc *desc, unsigned long flags, bool bus)
|
|
|
|
{
|
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
|
|
|
if (bus)
|
|
|
|
chip_bus_sync_unlock(desc);
|
|
|
|
}
|
|
|
|
|
2016-04-11 08:57:52 +00:00
|
|
|
int irq_set_percpu_devid_partition(unsigned int irq,
|
|
|
|
const struct cpumask *affinity)
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-23 16:03:06 +00:00
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
|
|
|
if (!desc)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (desc->percpu_enabled)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
desc->percpu_enabled = kzalloc(sizeof(*desc->percpu_enabled), GFP_KERNEL);
|
|
|
|
|
|
|
|
if (!desc->percpu_enabled)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2016-04-11 08:57:52 +00:00
|
|
|
if (affinity)
|
|
|
|
desc->percpu_affinity = affinity;
|
|
|
|
else
|
|
|
|
desc->percpu_affinity = cpu_possible_mask;
|
|
|
|
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-23 16:03:06 +00:00
|
|
|
irq_set_percpu_devid_flags(irq);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-11 08:57:52 +00:00
|
|
|
int irq_set_percpu_devid(unsigned int irq)
|
|
|
|
{
|
|
|
|
return irq_set_percpu_devid_partition(irq, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
int irq_get_percpu_devid_partition(unsigned int irq, struct cpumask *affinity)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
|
|
|
if (!desc || !desc->percpu_enabled)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (affinity)
|
|
|
|
cpumask_copy(affinity, desc->percpu_affinity);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2016-07-25 15:07:10 +00:00
|
|
|
EXPORT_SYMBOL_GPL(irq_get_percpu_devid_partition);
|
2016-04-11 08:57:52 +00:00
|
|
|
|
2014-02-23 21:40:14 +00:00
|
|
|
void kstat_incr_irq_this_cpu(unsigned int irq)
|
|
|
|
{
|
2015-06-04 04:13:25 +00:00
|
|
|
kstat_incr_irqs_this_cpu(irq_to_desc(irq));
|
2014-02-23 21:40:14 +00:00
|
|
|
}
|
|
|
|
|
2014-12-11 22:01:41 +00:00
|
|
|
/**
|
|
|
|
* kstat_irqs_cpu - Get the statistics for an interrupt on a cpu
|
|
|
|
* @irq: The interrupt number
|
|
|
|
* @cpu: The cpu number
|
|
|
|
*
|
|
|
|
* Returns the sum of interrupt counts on @cpu since boot for
|
|
|
|
* @irq. The caller must ensure that the interrupt is not removed
|
|
|
|
* concurrently.
|
|
|
|
*/
|
2010-09-22 15:09:43 +00:00
|
|
|
unsigned int kstat_irqs_cpu(unsigned int irq, int cpu)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2011-01-13 23:45:38 +00:00
|
|
|
|
|
|
|
return desc && desc->kstat_irqs ?
|
|
|
|
*per_cpu_ptr(desc->kstat_irqs, cpu) : 0;
|
2010-09-22 15:09:43 +00:00
|
|
|
}
|
2010-10-27 22:34:15 +00:00
|
|
|
|
2014-12-11 22:01:41 +00:00
|
|
|
/**
|
|
|
|
* kstat_irqs - Get the statistics for an interrupt
|
|
|
|
* @irq: The interrupt number
|
|
|
|
*
|
|
|
|
* Returns the sum of interrupt counts on all cpus since boot for
|
|
|
|
* @irq. The caller must ensure that the interrupt is not removed
|
|
|
|
* concurrently.
|
|
|
|
*/
|
2010-10-27 22:34:15 +00:00
|
|
|
unsigned int kstat_irqs(unsigned int irq)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
int cpu;
|
2015-05-03 08:48:50 +00:00
|
|
|
unsigned int sum = 0;
|
2010-10-27 22:34:15 +00:00
|
|
|
|
2011-01-13 23:45:38 +00:00
|
|
|
if (!desc || !desc->kstat_irqs)
|
2010-10-27 22:34:15 +00:00
|
|
|
return 0;
|
|
|
|
for_each_possible_cpu(cpu)
|
2011-01-13 23:45:38 +00:00
|
|
|
sum += *per_cpu_ptr(desc->kstat_irqs, cpu);
|
2010-10-27 22:34:15 +00:00
|
|
|
return sum;
|
|
|
|
}
|
2014-12-11 22:01:41 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* kstat_irqs_usr - Get the statistics for an interrupt
|
|
|
|
* @irq: The interrupt number
|
|
|
|
*
|
2018-06-18 12:56:12 +00:00
|
|
|
* Returns the sum of interrupt counts on all cpus since boot for @irq.
|
|
|
|
* Contrary to kstat_irqs() this can be called from any context.
|
|
|
|
* It uses rcu since a concurrent removal of an interrupt descriptor is
|
|
|
|
* observing an rcu grace period before delayed_free_desc()/irq_kobj_release().
|
2014-12-11 22:01:41 +00:00
|
|
|
*/
|
|
|
|
unsigned int kstat_irqs_usr(unsigned int irq)
|
|
|
|
{
|
2015-05-03 08:49:11 +00:00
|
|
|
unsigned int sum;
|
2014-12-11 22:01:41 +00:00
|
|
|
|
2018-06-18 12:56:12 +00:00
|
|
|
rcu_read_lock();
|
2014-12-11 22:01:41 +00:00
|
|
|
sum = kstat_irqs(irq);
|
2018-06-18 12:56:12 +00:00
|
|
|
rcu_read_unlock();
|
2014-12-11 22:01:41 +00:00
|
|
|
return sum;
|
|
|
|
}
|