Commit 4bbdd45a authored by Grant Likely's avatar Grant Likely
Browse files

irq_domain/powerpc: eliminate irq_map; use irq_alloc_desc() instead 



This patch drops the powerpc-specific irq_map table and replaces it with
directly using the irq_alloc_desc()/irq_free_desc() interfaces for allocating
and freeing irq_desc structures.

This patch is a preparation step for generalizing the powerpc-specific virq
infrastructure to become irq_domains.

As part of this change, the irq_big_lock is changed to a mutex from a raw
spinlock.  There is no longer any need to use a spin lock since the irq_desc
allocation code is now responsible for the critical section of finding
an unused range of irq numbers.

The radix lookup table is also changed to store the irq_data pointer instead
of the irq_map entry since the irq_map is removed.  This should end up being
functionally equivalent since only allocated irq_descs are ever added to the
radix tree.

v5: - Really don't ever allocate virq 0.  The previous version could still
      do it if hint == 0
    - Respect irq_virq_count setting for NOMAP.  Some NOMAP domains cannot
      use virq values above irq_virq_count.
    - Use numa_node_id() when allocating irq_descs.  Ideally the API should
      obtain that value from the caller, but that touches a lot of call sites
      so will be deferred to a follow-on patch.
    - Fix irq_find_mapping() to include irq numbers lower than
      NUM_ISA_INTERRUPTS.  With the switch to irq_alloc_desc*(), the lowest
      possible allocated irq is now returned by arch_probe_nr_irqs().
v4: - Fix incorrect access to irq_data structure in debugfs code
    - Don't ever allocate virq 0

Signed-off-by: default avatarGrant Likely <grant.likely@secretlab.ca>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Milton Miller <miltonm@bga.com>
Tested-by: default avatarOlof Johansson <olof@lixom.net>
parent bae1d8f1

arch/powerpc/include/asm/irq.h

+0 −27
Original line number Diff line number Diff line
@@ -191,33 +191,6 @@ extern unsigned int irq_linear_revmap(struct irq_domain *host, 
				      irq_hw_number_t hwirq);







/**

 * irq_alloc_virt - Allocate virtual irq numbers

 * @host: host owning these new virtual irqs

 * @count: number of consecutive numbers to allocate

 * @hint: pass a hint number, the allocator will try to use a 1:1 mapping

 *

 * This is a low level function that is used internally by irq_create_mapping()

 * and that can be used by some irq controllers implementations for things

 * like allocating ranges of numbers for MSIs. The revmaps are left untouched.

 */

extern unsigned int irq_alloc_virt(struct irq_domain *host,

				   unsigned int count,

				   unsigned int hint);



/**

 * irq_free_virt - Free virtual irq numbers

 * @virq: virtual irq number of the first interrupt to free

 * @count: number of interrupts to free

 *

 * This function is the opposite of irq_alloc_virt. It will not clear reverse

 * maps, this should be done previously by unmap'ing the interrupt. In fact,

 * all interrupts covered by the range being freed should have been unmapped

 * prior to calling this.

 */

extern void irq_free_virt(unsigned int virq, unsigned int count);



/**

 * irq_early_init - Init irq remapping subsystem

 */

arch/powerpc/kernel/irq.c

+69 −171
Original line number Diff line number Diff line
@@ -491,38 +491,29 @@ void do_softirq(void) 
 * IRQ controller and virtual interrupts

 */



/* The main irq map itself is an array of NR_IRQ entries containing the

 * associate host and irq number. An entry with a host of NULL is free.

 * An entry can be allocated if it's free, the allocator always then sets

 * hwirq first to the host's invalid irq number and then fills ops.

 */

struct irq_map_entry {

	irq_hw_number_t	hwirq;

	struct irq_domain	*host;

};



static LIST_HEAD(irq_domain_list);

static DEFINE_RAW_SPINLOCK(irq_big_lock);

static DEFINE_MUTEX(irq_domain_mutex);

static DEFINE_MUTEX(revmap_trees_mutex);

static struct irq_map_entry irq_map[NR_IRQS];

static unsigned int irq_virq_count = NR_IRQS;

static struct irq_domain *irq_default_host;



irq_hw_number_t irqd_to_hwirq(struct irq_data *d)

{

	return irq_map[d->irq].hwirq;

	return d->hwirq;

}

EXPORT_SYMBOL_GPL(irqd_to_hwirq);



irq_hw_number_t virq_to_hw(unsigned int virq)

{

	return irq_map[virq].hwirq;

	struct irq_data *irq_data = irq_get_irq_data(virq);

	return WARN_ON(!irq_data) ? 0 : irq_data->hwirq;

}

EXPORT_SYMBOL_GPL(virq_to_hw);



bool virq_is_host(unsigned int virq, struct irq_domain *host)

{

	return irq_map[virq].host == host;

	struct irq_data *irq_data = irq_get_irq_data(virq);

	return irq_data ? irq_data->domain == host : false;

}

EXPORT_SYMBOL_GPL(virq_is_host);
@@ -537,11 +528,10 @@ struct irq_domain *irq_alloc_host(struct device_node *of_node, 
				struct irq_domain_ops *ops,

				irq_hw_number_t inval_irq)

{

	struct irq_domain *host;

	struct irq_domain *host, *h;

	unsigned int size = sizeof(struct irq_domain);

	unsigned int i;

	unsigned int *rmap;

	unsigned long flags;



	/* Allocate structure and revmap table if using linear mapping */

	if (revmap_type == IRQ_DOMAIN_MAP_LINEAR)
@@ -559,23 +549,20 @@ struct irq_domain *irq_alloc_host(struct device_node *of_node, 
	if (host->ops->match == NULL)

		host->ops->match = default_irq_host_match;



	raw_spin_lock_irqsave(&irq_big_lock, flags);



	/* If it's a legacy controller, check for duplicates and

	 * mark it as allocated (we use irq 0 host pointer for that

	 */

	mutex_lock(&irq_domain_mutex);

	/* Make sure only one legacy controller can be created */

	if (revmap_type == IRQ_DOMAIN_MAP_LEGACY) {

		if (irq_map[0].host != NULL) {

			raw_spin_unlock_irqrestore(&irq_big_lock, flags);

		list_for_each_entry(h, &irq_domain_list, link) {

			if (WARN_ON(h->revmap_type == IRQ_DOMAIN_MAP_LEGACY)) {

				mutex_unlock(&irq_domain_mutex);

				of_node_put(host->of_node);

				kfree(host);

				return NULL;

			}

		irq_map[0].host = host;

		}



	}

	list_add(&host->link, &irq_domain_list);

	raw_spin_unlock_irqrestore(&irq_big_lock, flags);

	mutex_unlock(&irq_domain_mutex);



	/* Additional setups per revmap type */

	switch(revmap_type) {
@@ -584,10 +571,9 @@ struct irq_domain *irq_alloc_host(struct device_node *of_node, 
		host->inval_irq = 0;

		/* setup us as the host for all legacy interrupts */

		for (i = 1; i < NUM_ISA_INTERRUPTS; i++) {

			irq_map[i].hwirq = i;

			smp_wmb();

			irq_map[i].host = host;

			smp_wmb();

			struct irq_data *irq_data = irq_get_irq_data(i);

			irq_data->hwirq = i;

			irq_data->domain = host;



			/* Legacy flags are left to default at this point,

			 * one can then use irq_create_mapping() to
@@ -604,7 +590,6 @@ struct irq_domain *irq_alloc_host(struct device_node *of_node, 
		for (i = 0; i < revmap_arg; i++)

			rmap[i] = NO_IRQ;

		host->revmap_data.linear.size = revmap_arg;

		smp_wmb();

		host->revmap_data.linear.revmap = rmap;

		break;

	case IRQ_DOMAIN_MAP_TREE:
@@ -622,20 +607,19 @@ struct irq_domain *irq_alloc_host(struct device_node *of_node, 
struct irq_domain *irq_find_host(struct device_node *node)

{

	struct irq_domain *h, *found = NULL;

	unsigned long flags;



	/* 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...

	 */

	raw_spin_lock_irqsave(&irq_big_lock, flags);

	mutex_lock(&irq_domain_mutex);

	list_for_each_entry(h, &irq_domain_list, link)

		if (h->ops->match(h, node)) {

			found = h;

			break;

		}

	raw_spin_unlock_irqrestore(&irq_big_lock, flags);

	mutex_unlock(&irq_domain_mutex);

	return found;

}

EXPORT_SYMBOL_GPL(irq_find_host);
@@ -659,33 +643,20 @@ void irq_set_virq_count(unsigned int count) 
static int irq_setup_virq(struct irq_domain *host, unsigned int virq,

			    irq_hw_number_t hwirq)

{

	int res;



	res = irq_alloc_desc_at(virq, 0);

	if (res != virq) {

		pr_debug("irq: -> allocating desc failed\n");

		goto error;

	}



	/* map it */

	smp_wmb();

	irq_map[virq].hwirq = hwirq;

	smp_mb();

	struct irq_data *irq_data = irq_get_irq_data(virq);



	irq_data->hwirq = hwirq;

	irq_data->domain = host;

	if (host->ops->map(host, virq, hwirq)) {

		pr_debug("irq: -> mapping failed, freeing\n");

		goto errdesc;

		irq_data->domain = NULL;

		irq_data->hwirq = 0;

		return -1;

	}



	irq_clear_status_flags(virq, IRQ_NOREQUEST);



	return 0;



errdesc:

	irq_free_descs(virq, 1);

error:

	irq_free_virt(virq, 1);

	return -1;

}



unsigned int irq_create_direct_mapping(struct irq_domain *host)
@@ -698,16 +669,24 @@ unsigned int irq_create_direct_mapping(struct irq_domain *host) 
	BUG_ON(host == NULL);

	WARN_ON(host->revmap_type != IRQ_DOMAIN_MAP_NOMAP);



	virq = irq_alloc_virt(host, 1, 0);

	virq = irq_alloc_desc_from(1, 0);

	if (virq == NO_IRQ) {

		pr_debug("irq: create_direct virq allocation failed\n");

		return NO_IRQ;

	}

	if (virq >= irq_virq_count) {

		pr_err("ERROR: no free irqs available below %i maximum\n",

			irq_virq_count);

		irq_free_desc(virq);

		return 0;

	}



	pr_debug("irq: create_direct obtained virq %d\n", virq);



	if (irq_setup_virq(host, virq, virq))

	if (irq_setup_virq(host, virq, virq)) {

		irq_free_desc(virq);

		return NO_IRQ;

	}



	return virq;

}
@@ -747,15 +726,22 @@ unsigned int irq_create_mapping(struct irq_domain *host, 
	} else {

		/* Allocate a virtual interrupt number */

		hint = hwirq % irq_virq_count;

		virq = irq_alloc_virt(host, 1, hint);

		if (hint == 0)

			hint = 1;

		virq = irq_alloc_desc_from(hint, 0);

		if (!virq)

			virq = irq_alloc_desc_from(1, 0);

		if (virq == NO_IRQ) {

			pr_debug("irq: -> virq allocation failed\n");

			return NO_IRQ;

		}

	}



	if (irq_setup_virq(host, virq, hwirq))

	if (irq_setup_virq(host, virq, hwirq)) {

		if (host->revmap_type != IRQ_DOMAIN_MAP_LEGACY)

			irq_free_desc(virq);

		return NO_IRQ;

	}



	pr_debug("irq: irq %lu on host %s mapped to virtual irq %u\n",

		hwirq, host->of_node ? host->of_node->full_name : "null", virq);
@@ -806,13 +792,14 @@ EXPORT_SYMBOL_GPL(irq_create_of_mapping); 


void irq_dispose_mapping(unsigned int virq)

{

	struct irq_data *irq_data = irq_get_irq_data(virq);

	struct irq_domain *host;

	irq_hw_number_t hwirq;



	if (virq == NO_IRQ)

	if (virq == NO_IRQ || !irq_data)

		return;



	host = irq_map[virq].host;

	host = irq_data->domain;

	if (WARN_ON(host == NULL))

		return;
@@ -834,7 +821,7 @@ void irq_dispose_mapping(unsigned int virq) 
	smp_mb();



	/* Clear reverse map */

	hwirq = irq_map[virq].hwirq;

	hwirq = irq_data->hwirq;

	switch(host->revmap_type) {

	case IRQ_DOMAIN_MAP_LINEAR:

		if (hwirq < host->revmap_data.linear.size)
@@ -848,12 +835,9 @@ void irq_dispose_mapping(unsigned int virq) 
	}



	/* Destroy map */

	smp_mb();

	irq_map[virq].hwirq = host->inval_irq;

	irq_data->hwirq = host->inval_irq;



	irq_free_descs(virq, 1);

	/* Free it */

	irq_free_virt(virq, 1);

	irq_free_desc(virq);

}

EXPORT_SYMBOL_GPL(irq_dispose_mapping);
@@ -874,16 +858,16 @@ unsigned int irq_find_mapping(struct irq_domain *host, 
		return hwirq;



	/* Slow path does a linear search of the map */

	if (hint < NUM_ISA_INTERRUPTS)

		hint = NUM_ISA_INTERRUPTS;

	if (hint == 0)

		hint = 1;

	i = hint;

	do {

		if (irq_map[i].host == host &&

		    irq_map[i].hwirq == hwirq)

		struct irq_data *data = irq_get_irq_data(i);

		if (data && (data->domain == host) && (data->hwirq == hwirq))

			return i;

		i++;

		if (i >= irq_virq_count)

			i = NUM_ISA_INTERRUPTS;

			i = 1;

	} while(i != hint);

	return NO_IRQ;

}
@@ -928,19 +912,17 @@ int irq_choose_cpu(const struct cpumask *mask) 
unsigned int irq_radix_revmap_lookup(struct irq_domain *host,

				     irq_hw_number_t hwirq)

{

	struct irq_map_entry *ptr;

	unsigned int virq;

	struct irq_data *irq_data;



	if (WARN_ON_ONCE(host->revmap_type != IRQ_DOMAIN_MAP_TREE))

		return irq_find_mapping(host, hwirq);



	/*

	 * The ptr returned references the static global irq_map.

	 * but freeing an irq can delete nodes along the path to

	 * Freeing an irq can delete nodes along the path to

	 * do the lookup via call_rcu.

	 */

	rcu_read_lock();

	ptr = radix_tree_lookup(&host->revmap_data.tree, hwirq);

	irq_data = radix_tree_lookup(&host->revmap_data.tree, hwirq);

	rcu_read_unlock();



	/*
@@ -948,24 +930,20 @@ unsigned int irq_radix_revmap_lookup(struct irq_domain *host, 
	 * Else fallback to linear lookup - this should not happen in practice

	 * as it means that we failed to insert the node in the radix tree.

	 */

	if (ptr)

		virq = ptr - irq_map;

	else

		virq = irq_find_mapping(host, hwirq);



	return virq;

	return irq_data ? irq_data->irq : irq_find_mapping(host, hwirq);

}



void irq_radix_revmap_insert(struct irq_domain *host, unsigned int virq,

			     irq_hw_number_t hwirq)

{

	struct irq_data *irq_data = irq_get_irq_data(virq);



	if (WARN_ON(host->revmap_type != IRQ_DOMAIN_MAP_TREE))

		return;



	if (virq != NO_IRQ) {

		mutex_lock(&revmap_trees_mutex);

		radix_tree_insert(&host->revmap_data.tree, hwirq,

				  &irq_map[virq]);

		radix_tree_insert(&host->revmap_data.tree, hwirq, irq_data);

		mutex_unlock(&revmap_trees_mutex);

	}

}
@@ -994,86 +972,6 @@ unsigned int irq_linear_revmap(struct irq_domain *host, 
	return revmap[hwirq];

}



unsigned int irq_alloc_virt(struct irq_domain *host,

			    unsigned int count,

			    unsigned int hint)

{

	unsigned long flags;

	unsigned int i, j, found = NO_IRQ;



	if (count == 0 || count > (irq_virq_count - NUM_ISA_INTERRUPTS))

		return NO_IRQ;



	raw_spin_lock_irqsave(&irq_big_lock, flags);



	/* Use hint for 1 interrupt if any */

	if (count == 1 && hint >= NUM_ISA_INTERRUPTS &&

	    hint < irq_virq_count && irq_map[hint].host == NULL) {

		found = hint;

		goto hint_found;

	}



	/* Look for count consecutive numbers in the allocatable

	 * (non-legacy) space

	 */

	for (i = NUM_ISA_INTERRUPTS, j = 0; i < irq_virq_count; i++) {

		if (irq_map[i].host != NULL)

			j = 0;

		else

			j++;



		if (j == count) {

			found = i - count + 1;

			break;

		}

	}

	if (found == NO_IRQ) {

		raw_spin_unlock_irqrestore(&irq_big_lock, flags);

		return NO_IRQ;

	}

 hint_found:

	for (i = found; i < (found + count); i++) {

		irq_map[i].hwirq = host->inval_irq;

		smp_wmb();

		irq_map[i].host = host;

	}

	raw_spin_unlock_irqrestore(&irq_big_lock, flags);

	return found;

}



void irq_free_virt(unsigned int virq, unsigned int count)

{

	unsigned long flags;

	unsigned int i;



	WARN_ON (virq < NUM_ISA_INTERRUPTS);

	WARN_ON (count == 0 || (virq + count) > irq_virq_count);



	if (virq < NUM_ISA_INTERRUPTS) {

		if (virq + count < NUM_ISA_INTERRUPTS)

			return;

		count  =- NUM_ISA_INTERRUPTS - virq;

		virq = NUM_ISA_INTERRUPTS;

	}



	if (count > irq_virq_count || virq > irq_virq_count - count) {

		if (virq > irq_virq_count)

			return;

		count = irq_virq_count - virq;

	}



	raw_spin_lock_irqsave(&irq_big_lock, flags);

	for (i = virq; i < (virq + count); i++) {

		struct irq_domain *host;



		host = irq_map[i].host;

		irq_map[i].hwirq = host->inval_irq;

		smp_wmb();

		irq_map[i].host = NULL;

	}

	raw_spin_unlock_irqrestore(&irq_big_lock, flags);

}



int arch_early_irq_init(void)

{

	return 0;
@@ -1103,7 +1001,7 @@ static int virq_debug_show(struct seq_file *m, void *private) 
			struct irq_chip *chip;



			seq_printf(m, "%5d  ", i);

			seq_printf(m, "0x%05lx  ", irq_map[i].hwirq);

			seq_printf(m, "0x%05lx  ", desc->irq_data.hwirq);



			chip = irq_desc_get_chip(desc);

			if (chip && chip->name)
@@ -1115,8 +1013,8 @@ static int virq_debug_show(struct seq_file *m, void *private) 
			data = irq_desc_get_chip_data(desc);

			seq_printf(m, "0x%16p  ", data);



			if (irq_map[i].host && irq_map[i].host->of_node)

				p = irq_map[i].host->of_node->full_name;

			if (desc->irq_data.domain->of_node)

				p = desc->irq_data.domain->of_node->full_name;

			else

				p = none;

			seq_printf(m, "%s\n", p);

CRA Git | Maintained and supported by SUSTech CRA and CCSE