Release 4.15 kernel/irq/irqdesc.c

Directory: kernel/irq
/*
 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
 * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
 *
 * This file contains the interrupt descriptor management code
 *
 * Detailed information is available in Documentation/core-api/genericirq.rst
 *
 */
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/export.h>
#include <linux/interrupt.h>
#include <linux/kernel_stat.h>
#include <linux/radix-tree.h>
#include <linux/bitmap.h>
#include <linux/irqdomain.h>
#include <linux/sysfs.h>

#include "internals.h"

/*
 * lockdep: we want to handle all irq_desc locks as a single lock-class:
 */

static struct lock_class_key irq_desc_lock_class;

#if defined(CONFIG_SMP)


static int __init irq_affinity_setup(char *str)
{
	alloc_bootmem_cpumask_var(&irq_default_affinity);
	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;
}
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 35 97.22% 1 50.00%
Rakib Mullick 1 2.78% 1 50.00%
Total 36 100.00% 2 100.00%

__setup("irqaffinity=", irq_affinity_setup);



static void __init init_irq_default_affinity(void)
{
	if (!cpumask_available(irq_default_affinity))
		zalloc_cpumask_var(&irq_default_affinity, GFP_NOWAIT);
	if (cpumask_empty(irq_default_affinity))
		cpumask_setall(irq_default_affinity);
}
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 34 91.89% 2 66.67%
Rakib Mullick 3 8.11% 1 33.33%
Total 37 100.00% 3 100.00%

#else


static void __init init_irq_default_affinity(void)
{
}
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%

#endif

#ifdef CONFIG_SMP


static int alloc_masks(struct irq_desc *desc, int node)
{
	if (!zalloc_cpumask_var_node(&desc->irq_common_data.affinity,
				     GFP_KERNEL, node))
		return -ENOMEM;

#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

#ifdef CONFIG_GENERIC_PENDING_IRQ
	if (!zalloc_cpumask_var_node(&desc->pending_mask, GFP_KERNEL, node)) {
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
		free_cpumask_var(desc->irq_common_data.effective_affinity);
#endif
		free_cpumask_var(desc->irq_common_data.affinity);
		return -ENOMEM;
	}
#endif
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 122 98.39% 4 80.00%
Jiang Liu 2 1.61% 1 20.00%
Total 124 100.00% 5 100.00%



static void desc_smp_init(struct irq_desc *desc, int node,
			  const struct cpumask *affinity)
{
	if (!affinity)
		affinity = irq_default_affinity;
	cpumask_copy(desc->irq_common_data.affinity, affinity);

#ifdef CONFIG_GENERIC_PENDING_IRQ
	cpumask_clear(desc->pending_mask);
#endif
#ifdef CONFIG_NUMA
	desc->irq_common_data.node = node;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 51 78.46% 4 66.67%
Jiang Liu 14 21.54% 2 33.33%
Total 65 100.00% 6 100.00%

#else

static inline int

alloc_masks(struct irq_desc *desc, int node) { return 0; }
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


static inline void

desc_smp_init(struct irq_desc *desc, int node, const struct cpumask *affinity) { }
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 20 100.00% 2 100.00%
Total 20 100.00% 2 100.00%

#endif



static void desc_set_defaults(unsigned int irq, struct irq_desc *desc, int node,
			      const struct cpumask *affinity, struct module *owner)
{
	int cpu;

	desc->irq_common_data.handler_data = NULL;
	desc->irq_common_data.msi_desc = NULL;

	desc->irq_data.common = &desc->irq_common_data;
	desc->irq_data.irq = irq;
	desc->irq_data.chip = &no_irq_chip;
	desc->irq_data.chip_data = NULL;
	irq_settings_clr_and_set(desc, ~0, _IRQ_DEFAULT_INIT_FLAGS);
	irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
	irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
	desc->handle_irq = handle_bad_irq;
	desc->depth = 1;
	desc->irq_count = 0;
	desc->irqs_unhandled = 0;
	desc->name = NULL;
	desc->owner = owner;
	for_each_possible_cpu(cpu)
		*per_cpu_ptr(desc->kstat_irqs, cpu) = 0;
	desc_smp_init(desc, node, affinity);
}

Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 92 52.57% 1 10.00%
Thomas Gleixner 38 21.71% 3 30.00%
Jiang Liu 27 15.43% 3 30.00%
Jeffy Chen 10 5.71% 1 10.00%
Sebastian Andrzej Siewior 5 2.86% 1 10.00%
Eric Dumazet 3 1.71% 1 10.00%
Total 175 100.00% 10 100.00%


int nr_irqs = NR_IRQS;

EXPORT_SYMBOL_GPL(nr_irqs);

static DEFINE_MUTEX(sparse_irq_lock);
static DECLARE_BITMAP(allocated_irqs, IRQ_BITMAP_BITS);

#ifdef CONFIG_SPARSE_IRQ

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;
}
Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 115 100.00% 1 100.00%
Total 115 100.00% 1 100.00%


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;
}
Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 96 100.00% 1 100.00%
Total 96 100.00% 1 100.00%


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;
}
Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 85 100.00% 1 100.00%
Total 85 100.00% 1 100.00%


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;

}
Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 80 100.00% 1 100.00%
Total 80 100.00% 1 100.00%


IRQ_ATTR_RO(type);



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;
}
Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 80 100.00% 1 100.00%
Total 80 100.00% 1 100.00%


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;
}
Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 134 100.00% 1 100.00%
Total 134 100.00% 1 100.00%


IRQ_ATTR_RO(actions);


static struct attribute *irq_attrs[] = {
	&per_cpu_count_attr.attr,
	&chip_name_attr.attr,
	&hwirq_attr.attr,
	&type_attr.attr,
	&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);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 35 79.55% 1 20.00%
Thomas Gleixner 9 20.45% 4 80.00%
Total 44 100.00% 5 100.00%



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;
}
Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 51 79.69% 1 16.67%
Thomas Gleixner 11 17.19% 3 50.00%
Eric Dumazet 1 1.56% 1 16.67%
Sebastian Andrzej Siewior 1 1.56% 1 16.67%
Total 64 100.00% 6 100.00%


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) {}

Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 12 92.31% 1 50.00%
Thomas Gleixner 1 7.69% 1 50.00%
Total 13 100.00% 2 100.00%

#endif /* CONFIG_SYSFS */

static RADIX_TREE(irq_desc_tree, GFP_KERNEL);



static void irq_insert_desc(unsigned int irq, struct irq_desc *desc)
{
	radix_tree_insert(&irq_desc_tree, irq, desc);
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 25 100.00% 2 100.00%
Total 25 100.00% 2 100.00%



struct irq_desc *irq_to_desc(unsigned int irq)
{
	return radix_tree_lookup(&irq_desc_tree, irq);
}
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 20 100.00% 2 100.00%
Total 20 100.00% 2 100.00%


EXPORT_SYMBOL(irq_to_desc);



static void delete_irq_desc(unsigned int irq)
{
	radix_tree_delete(&irq_desc_tree, irq);
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 18 100.00% 2 100.00%
Total 18 100.00% 2 100.00%

#ifdef CONFIG_SMP


static void free_masks(struct irq_desc *desc)
{
#ifdef CONFIG_GENERIC_PENDING_IRQ
	free_cpumask_var(desc->pending_mask);
#endif
	free_cpumask_var(desc->irq_common_data.affinity);
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
	free_cpumask_var(desc->irq_common_data.effective_affinity);
#endif
}
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 45 97.83% 4 80.00%
Jiang Liu 1 2.17% 1 20.00%
Total 46 100.00% 5 100.00%

#else


static inline void free_masks(struct irq_desc *desc) { }
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 11 100.00% 1 100.00%
Total 11 100.00% 1 100.00%

#endif



void irq_lock_sparse(void)
{
	mutex_lock(&sparse_irq_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%



void irq_unlock_sparse(void)
{
	mutex_unlock(&sparse_irq_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%



static struct irq_desc *alloc_desc(int irq, int node, unsigned int flags,
				   const struct cpumask *affinity,
				   struct module *owner)
{
	struct irq_desc *desc;

	desc = kzalloc_node(sizeof(*desc), GFP_KERNEL, node);
	if (!desc)
		return NULL;
	/* allocate based on nr_cpu_ids */
	desc->kstat_irqs = alloc_percpu(unsigned int);
	if (!desc->kstat_irqs)
		goto err_desc;

	if (alloc_masks(desc, node))
		goto err_kstat;

	raw_spin_lock_init(&desc->lock);
	lockdep_set_class(&desc->lock, &irq_desc_lock_class);
	mutex_init(&desc->request_mutex);
	init_rcu_head(&desc->rcu);

	desc_set_defaults(irq, desc, node, affinity, owner);
	irqd_set(&desc->irq_data, flags);
	kobject_init(&desc->kobj, &irq_kobj_type);

	return desc;

err_kstat:
	free_percpu(desc->kstat_irqs);
err_desc:
	kfree(desc);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 159 88.33% 6 66.67%
Craig Gallek 11 6.11% 1 11.11%
Sebastian Andrzej Siewior 7 3.89% 1 11.11%
Eric Dumazet 3 1.67% 1 11.11%
Total 180 100.00% 9 100.00%



static void irq_kobj_release(struct kobject *kobj)
{
	struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj);

	free_masks(desc);
	free_percpu(desc->kstat_irqs);
	kfree(desc);
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 38 88.37% 1 50.00%
Craig Gallek 5 11.63% 1 50.00%
Total 43 100.00% 2 100.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);
}

Contributors
Person Tokens Prop Commits CommitProp
Craig Gallek 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%



static void free_desc(unsigned int irq)
{
	struct irq_desc *desc = irq_to_desc(irq);

	irq_remove_debugfs_entry(desc);
	unregister_irq_proc(irq, desc);

	/*
         * 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.
         *
         * The sysfs entry must be serialized against a concurrent
         * irq_sysfs_init() as well.
         */
	kobject_del(&desc->kobj);
	delete_irq_desc(irq);

	/*
         * We free the descriptor, masks and stat fields via RCU. That
         * allows demultiplex interrupts to do rcu based management of
         * the child interrupts.
         */
	call_rcu(&desc->rcu, delayed_free_desc);
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 48 84.21% 4 80.00%
Craig Gallek 9 15.79% 1 20.00%
Total 57 100.00% 5 100.00%



static int alloc_descs(unsigned int start, unsigned int cnt, int node,
		       const struct cpumask *affinity, struct module *owner)
{
	const struct cpumask *mask = NULL;
	struct irq_desc *desc;
	unsigned int flags;
	int i;

	/* Validate affinity mask(s) */
	if (affinity) {
		for (i = 0, mask = affinity; i < cnt; i++, mask++) {
			if (cpumask_empty(mask))
				return -EINVAL;
		}
	}

	flags = affinity ? IRQD_AFFINITY_MANAGED | IRQD_MANAGED_SHUTDOWN : 0;
	mask = NULL;

	for (i = 0; i < cnt; i++) {
		if (affinity) {
			node = cpu_to_node(cpumask_first(affinity));
			mask = affinity;
			affinity++;
		}
		desc = alloc_desc(start + i, node, flags, mask, owner);
		if (!desc)
			goto err;
		irq_insert_desc(start + i, desc);
		irq_sysfs_add(start + i, desc);
		irq_add_debugfs_entry(start + i, desc);
	}
	bitmap_set(allocated_irqs, start, cnt);
	return start;

err:
	for (i--; i >= 0; i--)
		free_desc(start + i);
	return -ENOMEM;
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 213 93.01% 7 77.78%
Craig Gallek 9 3.93% 1 11.11%
Sebastian Andrzej Siewior 7 3.06% 1 11.11%
Total 229 100.00% 9 100.00%



static int irq_expand_nr_irqs(unsigned int nr)
{
	if (nr > IRQ_BITMAP_BITS)
		return -ENOMEM;
	nr_irqs = nr;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 23 85.19% 1 50.00%
Yinghai Lu 4 14.81% 1 50.00%
Total 27 100.00% 2 100.00%



int __init early_irq_init(void)
{
	int i, initcnt, node = first_online_node;
	struct irq_desc *desc;

	init_irq_default_affinity();

	/* Let arch update nr_irqs and return the nr of preallocated irqs */
	initcnt = arch_probe_nr_irqs();
	printk(KERN_INFO "NR_IRQS: %d, nr_irqs: %d, preallocated irqs: %d\n",
	       NR_IRQS, nr_irqs, initcnt);

	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;

	for (i = 0; i < initcnt; i++) {
		desc = alloc_desc(i, node, 0, NULL, NULL);
		set_bit(i, allocated_irqs);
		irq_insert_desc(i, desc);
	}
	return arch_early_irq_init();
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 124 97.64% 7 77.78%
Sebastian Andrzej Siewior 2 1.57% 1 11.11%
Vincent Legoll 1 0.79% 1 11.11%
Total 127 100.00% 9 100.00%

#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)
{
	int count, i, node = first_online_node;
	struct irq_desc *desc;

	init_irq_default_affinity();

	printk(KERN_INFO "NR_IRQS: %d\n", NR_IRQS);

	desc = irq_desc;
	count = ARRAY_SIZE(irq_desc);

	for (i = 0; i < count; i++) {
		desc[i].kstat_irqs = alloc_percpu(unsigned int);
		alloc_masks(&desc[i], node);
		raw_spin_lock_init(&desc[i].lock);
		lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
		desc_set_defaults(i, &desc[i], node, NULL, NULL);
	}
	return arch_early_irq_init();
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 99 77.34% 3 42.86%
Linus Walleij 22 17.19% 1 14.29%
Eric Dumazet 4 3.12% 1 14.29%
Sebastian Andrzej Siewior 2 1.56% 1 14.29%
Vincent Legoll 1 0.78% 1 14.29%
Total 128 100.00% 7 100.00%



struct irq_desc *irq_to_desc(unsigned int irq)
{
	return (irq < NR_IRQS) ? irq_desc + irq : NULL;
}
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%


EXPORT_SYMBOL(irq_to_desc);



static void free_desc(unsigned int irq)
{
	struct irq_desc *desc = irq_to_desc(irq);
	unsigned long flags;

	raw_spin_lock_irqsave(&desc->lock, flags);
	desc_set_defaults(irq, desc, irq_desc_get_node(desc), NULL, NULL);
	raw_spin_unlock_irqrestore(&desc->lock, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 59 98.33% 3 75.00%
Jiang Liu 1 1.67% 1 25.00%
Total 60 100.00% 4 100.00%



static inline int alloc_descs(unsigned int start, unsigned int cnt, int node,
			      const struct cpumask *affinity,
			      struct module *owner)
{
	u32 i;

	for (i = 0; i < cnt; i++) {
		struct irq_desc *desc = irq_to_desc(start + i);

		desc->owner = owner;
	}
	bitmap_set(allocated_irqs, start, cnt);
	return start;
}

Contributors
Person Tokens Prop Commits CommitProp
Sebastian Andrzej Siewior 41 53.25% 1 25.00%
Thomas Gleixner 36 46.75% 3 75.00%
Total 77 100.00% 4 100.00%



static int irq_expand_nr_irqs(unsigned int nr)
{
	return -ENOMEM;
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 13 92.86% 1 50.00%
Yinghai Lu 1 7.14% 1 50.00%
Total 14 100.00% 2 100.00%



void irq_mark_irq(unsigned int irq)
{
	mutex_lock(&sparse_irq_lock);
	bitmap_set(allocated_irqs, irq, 1);
	mutex_unlock(&sparse_irq_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%

#ifdef CONFIG_GENERIC_IRQ_LEGACY


void irq_init_desc(unsigned int irq)
{
	free_desc(irq);
}
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 14 100.00% 2 100.00%
Total 14 100.00% 2 100.00%

#endif

#endif /* !CONFIG_SPARSE_IRQ */

/**
 * 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;
	generic_handle_irq_desc(desc);
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Thomas Gleixner 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(generic_handle_irq);

#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
Person	Tokens	Prop	Commits	CommitProp
Thomas Gleixner	35	97.22%	1	50.00%
Rakib Mullick	1	2.78%	1	50.00%
Total	36	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.15 kernel/irq/irqdesc.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
