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: Grant 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: Olof Johansson <olof@lixom.net>
This commit is contained in:
Grant Likely
parent
bae1d8f199
commit
4bbdd45afd
2 changed files with 69 additions and 198 deletions
|
|
@ -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
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
of_node_put(host->of_node);
|
||||
kfree(host);
|
||||
return NULL;
|
||||
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)
|
||||
do {
|
||||
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);
|
||||
|
|
|
|||
Loading…
Reference in a new issue