Merge tag 'irqdomain-for-linus' of git://git.secretlab.ca/git/linux-2.6

Pull irq_domain support for all architectures from Grant Likely:
 "Generialize powerpc's irq_host as irq_domain

  This branch takes the PowerPC irq_host infrastructure (reverse mapping
  from Linux IRQ numbers to hardware irq numbering), generalizes it,
  renames it to irq_domain, and makes it available to all architectures.

  Originally the plan has been to create an all-new irq_domain
  implementation which addresses some of the powerpc shortcomings such
  as not handling 1:1 mappings well, but doing that proved to be far
  more difficult and invasive than generalizing the working code and
  refactoring it in-place.  So, this branch rips out the 'new'
  irq_domain and replaces it with the modified powerpc version (in a
  fully bisectable way of course).  It converts all users over to the
  new API and makes irq_domain selectable on any architecture.

  No architecture is forced to enable irq_domain, but the infrastructure
  is required for doing OpenFirmware style irq translations.  It will
  even work on SPARC even though SPARC has it's own mechanism for
  translating irqs at boot time.  MIPS, microblaze, embedded x86 and c6x
  are converted too.

  The resulting irq_domain code is probably still too verbose and can be
  optimized more, but that can be done incrementally and is a task for
  follow-on patches."

* tag 'irqdomain-for-linus' of git://git.secretlab.ca/git/linux-2.6: (31 commits)
  dt: fix twl4030 for non-dt compile on x86
  mfd: twl-core: Add IRQ_DOMAIN dependency
  devicetree: Add empty of_platform_populate() for !CONFIG_OF_ADDRESS (sparc)
  irq_domain: Centralize definition of irq_dispose_mapping()
  irq_domain/mips: Allow irq_domain on MIPS
  irq_domain/x86: Convert x86 (embedded) to use common irq_domain
  ppc-6xx: fix build failure in flipper-pic.c and hlwd-pic.c
  irq_domain/microblaze: Convert microblaze to use irq_domains
  irq_domain/powerpc: Replace custom xlate functions with library functions
  irq_domain/powerpc: constify irq_domain_ops
  irq_domain/c6x: Use library of xlate functions
  irq_domain/c6x: constify irq_domain structures
  irq_domain/c6x: Convert c6x to use generic irq_domain support.
  irq_domain: constify irq_domain_ops
  irq_domain: Create common xlate functions that device drivers can use
  irq_domain: Remove irq_domain_add_simple()
  irq_domain: Remove 'new' irq_domain in favour of the ppc one
  mfd: twl-core.c: Fix the number of interrupts managed by twl4030
  of/address: add empty static inlines for !CONFIG_OF
  irq_domain: Add support for base irq and hwirq in legacy mappings
  ...

1 files changed, 3 insertions, 614 deletions

diff --git a/arch/powerpc/kernel/irq.c b/arch/powerpc/kernel/irq.c
index 01e2877e8e04..bdfb3eee3e6f 100644
--- a/arch/powerpc/kernel/irq.c
+++ b/arch/powerpc/kernel/irq.c
@@ -490,409 +490,19 @@ void do_softirq(void)
         local_irq_restore(flags);
 }
 
-
-/*
- * 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_host *host;
-};
-
-static LIST_HEAD(irq_hosts);
-static DEFINE_RAW_SPINLOCK(irq_big_lock);
-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_host *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_host *host)
-{
-        return irq_map[virq].host == host;
-}
-EXPORT_SYMBOL_GPL(virq_is_host);
-
-static int default_irq_host_match(struct irq_host *h, struct device_node *np)
-{
-        return h->of_node != NULL && h->of_node == np;
-}
-
-struct irq_host *irq_alloc_host(struct device_node *of_node,
-                                unsigned int revmap_type,
-                                unsigned int revmap_arg,
-                                struct irq_host_ops *ops,
-                                irq_hw_number_t inval_irq)
-{
-        struct irq_host *host;
-        unsigned int size = sizeof(struct irq_host);
-        unsigned int i;
-        unsigned int *rmap;
-        unsigned long flags;
-
-        /* Allocate structure and revmap table if using linear mapping */
-        if (revmap_type == IRQ_HOST_MAP_LINEAR)
-                size += revmap_arg * sizeof(unsigned int);
-        host = kzalloc(size, GFP_KERNEL);
-        if (host == NULL)
-                return NULL;
-
-        /* Fill structure */
-        host->revmap_type = revmap_type;
-        host->inval_irq = inval_irq;
-        host->ops = ops;
-        host->of_node = of_node_get(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
-         */
-        if (revmap_type == IRQ_HOST_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;
-                }
-                irq_map[0].host = host;
-        }
-
-        list_add(&host->link, &irq_hosts);
-        raw_spin_unlock_irqrestore(&irq_big_lock, flags);
-
-        /* Additional setups per revmap type */
-        switch(revmap_type) {
-        case IRQ_HOST_MAP_LEGACY:
-                /* 0 is always the invalid number for legacy */
-                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();
-
-                        /* Legacy flags are left to default at this point,
-                         * one can then use irq_create_mapping() to
-                         * explicitly change them
-                         */
-                        ops->map(host, i, i);
-
-                        /* Clear norequest flags */
-                        irq_clear_status_flags(i, IRQ_NOREQUEST);
-                }
-                break;
-        case IRQ_HOST_MAP_LINEAR:
-                rmap = (unsigned int *)(host + 1);
-                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_HOST_MAP_TREE:
-                INIT_RADIX_TREE(&host->revmap_data.tree, GFP_KERNEL);
-                break;
-        default:
-                break;
-        }
-
-        pr_debug("irq: Allocated host of type %d @0x%p\n", revmap_type, host);
-
-        return host;
-}
-
-struct irq_host *irq_find_host(struct device_node *node)
-{
-        struct irq_host *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);
-        list_for_each_entry(h, &irq_hosts, link)
-                if (h->ops->match(h, node)) {
-                        found = h;
-                        break;
-                }
-        raw_spin_unlock_irqrestore(&irq_big_lock, flags);
-        return found;
-}
-EXPORT_SYMBOL_GPL(irq_find_host);
-
-void irq_set_default_host(struct irq_host *host)
-{
-        pr_debug("irq: Default host set to @0x%p\n", host);
-
-        irq_default_host = host;
-}
-
-void irq_set_virq_count(unsigned int count)
-{
-        pr_debug("irq: Trying to set virq count to %d\n", count);
-
-        BUG_ON(count < NUM_ISA_INTERRUPTS);
-        if (count < NR_IRQS)
-                irq_virq_count = count;
-}
-
-static int irq_setup_virq(struct irq_host *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();
-
-        if (host->ops->map(host, virq, hwirq)) {
-                pr_debug("irq: -> mapping failed, freeing\n");
-                goto errdesc;
-        }
-
-        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_host *host)
-{
-        unsigned int virq;
-
-        if (host == NULL)
-                host = irq_default_host;
-
-        BUG_ON(host == NULL);
-        WARN_ON(host->revmap_type != IRQ_HOST_MAP_NOMAP);
-
-        virq = irq_alloc_virt(host, 1, 0);
-        if (virq == NO_IRQ) {
-                pr_debug("irq: create_direct virq allocation failed\n");
-                return NO_IRQ;
-        }
-
-        pr_debug("irq: create_direct obtained virq %d\n", virq);
-
-        if (irq_setup_virq(host, virq, virq))
-                return NO_IRQ;
-
-        return virq;
-}
-
-unsigned int irq_create_mapping(struct irq_host *host,
-                                irq_hw_number_t hwirq)
-{
-        unsigned int virq, hint;
-
-        pr_debug("irq: irq_create_mapping(0x%p, 0x%lx)\n", host, hwirq);
-
-        /* Look for default host if nececssary */
-        if (host == NULL)
-                host = irq_default_host;
-        if (host == NULL) {
-                printk(KERN_WARNING "irq_create_mapping called for"
-                       " NULL host, hwirq=%lx\n", hwirq);
-                WARN_ON(1);
-                return NO_IRQ;
-        }
-        pr_debug("irq: -> using host @%p\n", host);
-
-        /* Check if mapping already exists */
-        virq = irq_find_mapping(host, hwirq);
-        if (virq != NO_IRQ) {
-                pr_debug("irq: -> existing mapping on virq %d\n", virq);
-                return virq;
-        }
-
-        /* Get a virtual interrupt number */
-        if (host->revmap_type == IRQ_HOST_MAP_LEGACY) {
-                /* Handle legacy */
-                virq = (unsigned int)hwirq;
-                if (virq == 0 || virq >= NUM_ISA_INTERRUPTS)
-                        return NO_IRQ;
-                return virq;
-        } else {
-                /* Allocate a virtual interrupt number */
-                hint = hwirq % irq_virq_count;
-                virq = irq_alloc_virt(host, 1, hint);
-                if (virq == NO_IRQ) {
-                        pr_debug("irq: -> virq allocation failed\n");
-                        return NO_IRQ;
-                }
-        }
-
-        if (irq_setup_virq(host, virq, hwirq))
-                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);
-
-        return virq;
-}
-EXPORT_SYMBOL_GPL(irq_create_mapping);
-
-unsigned int irq_create_of_mapping(struct device_node *controller,
-                                   const u32 *intspec, unsigned int intsize)
-{
-        struct irq_host *host;
-        irq_hw_number_t hwirq;
-        unsigned int type = IRQ_TYPE_NONE;
-        unsigned int virq;
-
-        if (controller == NULL)
-                host = irq_default_host;
-        else
-                host = irq_find_host(controller);
-        if (host == NULL) {
-                printk(KERN_WARNING "irq: no irq host found for %s !\n",
-                       controller->full_name);
-                return NO_IRQ;
-        }
-
-        /* If host has no translation, then we assume interrupt line */
-        if (host->ops->xlate == NULL)
-                hwirq = intspec[0];
-        else {
-                if (host->ops->xlate(host, controller, intspec, intsize,
-                                     &hwirq, &type))
-                        return NO_IRQ;
-        }
-
-        /* Create mapping */
-        virq = irq_create_mapping(host, hwirq);
-        if (virq == NO_IRQ)
-                return virq;
-
-        /* Set type if specified and different than the current one */
-        if (type != IRQ_TYPE_NONE &&
-            type != (irqd_get_trigger_type(irq_get_irq_data(virq))))
-                irq_set_irq_type(virq, type);
-        return virq;
-}
-EXPORT_SYMBOL_GPL(irq_create_of_mapping);
-
-void irq_dispose_mapping(unsigned int virq)
-{
-        struct irq_host *host;
-        irq_hw_number_t hwirq;
-
-        if (virq == NO_IRQ)
-                return;
-
-        host = irq_map[virq].host;
-        if (WARN_ON(host == NULL))
-                return;
-
-        /* Never unmap legacy interrupts */
-        if (host->revmap_type == IRQ_HOST_MAP_LEGACY)
-                return;
-
-        irq_set_status_flags(virq, IRQ_NOREQUEST);
-
-        /* remove chip and handler */
-        irq_set_chip_and_handler(virq, NULL, NULL);
-
-        /* Make sure it's completed */
-        synchronize_irq(virq);
-
-        /* Tell the PIC about it */
-        if (host->ops->unmap)
-                host->ops->unmap(host, virq);
-        smp_mb();
-
-        /* Clear reverse map */
-        hwirq = irq_map[virq].hwirq;
-        switch(host->revmap_type) {
-        case IRQ_HOST_MAP_LINEAR:
-                if (hwirq < host->revmap_data.linear.size)
-                        host->revmap_data.linear.revmap[hwirq] = NO_IRQ;
-                break;
-        case IRQ_HOST_MAP_TREE:
-                mutex_lock(&revmap_trees_mutex);
-                radix_tree_delete(&host->revmap_data.tree, hwirq);
-                mutex_unlock(&revmap_trees_mutex);
-                break;
-        }
-
-        /* Destroy map */
-        smp_mb();
-        irq_map[virq].hwirq = host->inval_irq;
-
-        irq_free_descs(virq, 1);
-        /* Free it */
-        irq_free_virt(virq, 1);
-}
-EXPORT_SYMBOL_GPL(irq_dispose_mapping);
-
-unsigned int irq_find_mapping(struct irq_host *host,
-                              irq_hw_number_t hwirq)
-{
-        unsigned int i;
-        unsigned int hint = hwirq % irq_virq_count;
-
-        /* Look for default host if nececssary */
-        if (host == NULL)
-                host = irq_default_host;
-        if (host == NULL)
-                return NO_IRQ;
-
-        /* legacy -> bail early */
-        if (host->revmap_type == IRQ_HOST_MAP_LEGACY)
-                return hwirq;
-
-        /* Slow path does a linear search of the map */
-        if (hint < NUM_ISA_INTERRUPTS)
-                hint = NUM_ISA_INTERRUPTS;
-        i = hint;
-        do  {
-                if (irq_map[i].host == host &&
-                    irq_map[i].hwirq == hwirq)
-                        return i;
-                i++;
-                if (i >= irq_virq_count)
-                        i = NUM_ISA_INTERRUPTS;
-        } while(i != hint);
-        return NO_IRQ;
-}
-EXPORT_SYMBOL_GPL(irq_find_mapping);
-
 #ifdef CONFIG_SMP
 int irq_choose_cpu(const struct cpumask *mask)
 {
@@ -929,232 +539,11 @@ int irq_choose_cpu(const struct cpumask *mask)
 }
 #endif
 
-unsigned int irq_radix_revmap_lookup(struct irq_host *host,
-                                     irq_hw_number_t hwirq)
-{
-        struct irq_map_entry *ptr;
-        unsigned int virq;
-
-        if (WARN_ON_ONCE(host->revmap_type != IRQ_HOST_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
-         * do the lookup via call_rcu.
-         */
-        rcu_read_lock();
-        ptr = radix_tree_lookup(&host->revmap_data.tree, hwirq);
-        rcu_read_unlock();
-
-        /*
-         * If found in radix tree, then fine.
-         * 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;
-}
-
-void irq_radix_revmap_insert(struct irq_host *host, unsigned int virq,
-                             irq_hw_number_t hwirq)
-{
-        if (WARN_ON(host->revmap_type != IRQ_HOST_MAP_TREE))
-                return;
-
-        if (virq != NO_IRQ) {
-                mutex_lock(&revmap_trees_mutex);
-                radix_tree_insert(&host->revmap_data.tree, hwirq,
-                                  &irq_map[virq]);
-                mutex_unlock(&revmap_trees_mutex);
-        }
-}
-
-unsigned int irq_linear_revmap(struct irq_host *host,
-                               irq_hw_number_t hwirq)
-{
-        unsigned int *revmap;
-
-        if (WARN_ON_ONCE(host->revmap_type != IRQ_HOST_MAP_LINEAR))
-                return irq_find_mapping(host, hwirq);
-
-        /* Check revmap bounds */
-        if (unlikely(hwirq >= host->revmap_data.linear.size))
-                return irq_find_mapping(host, hwirq);
-
-        /* Check if revmap was allocated */
-        revmap = host->revmap_data.linear.revmap;
-        if (unlikely(revmap == NULL))
-                return irq_find_mapping(host, hwirq);
-
-        /* Fill up revmap with slow path if no mapping found */
-        if (unlikely(revmap[hwirq] == NO_IRQ))
-                revmap[hwirq] = irq_find_mapping(host, hwirq);
-
-        return revmap[hwirq];
-}
-
-unsigned int irq_alloc_virt(struct irq_host *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_host *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;
 }
 
-#ifdef CONFIG_VIRQ_DEBUG
-static int virq_debug_show(struct seq_file *m, void *private)
-{
-        unsigned long flags;
-        struct irq_desc *desc;
-        const char *p;
-        static const char none[] = "none";
-        void *data;
-        int i;
-
-        seq_printf(m, "%-5s  %-7s  %-15s  %-18s  %s\n", "virq", "hwirq",
-                      "chip name", "chip data", "host name");
-
-        for (i = 1; i < nr_irqs; i++) {
-                desc = irq_to_desc(i);
-                if (!desc)
-                        continue;
-
-                raw_spin_lock_irqsave(&desc->lock, flags);
-
-                if (desc->action && desc->action->handler) {
-                        struct irq_chip *chip;
-
-                        seq_printf(m, "%5d  ", i);
-                        seq_printf(m, "0x%05lx  ", irq_map[i].hwirq);
-
-                        chip = irq_desc_get_chip(desc);
-                        if (chip && chip->name)
-                                p = chip->name;
-                        else
-                                p = none;
-                        seq_printf(m, "%-15s  ", p);
-
-                        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;
-                        else
-                                p = none;
-                        seq_printf(m, "%s\n", p);
-                }
-
-                raw_spin_unlock_irqrestore(&desc->lock, flags);
-        }
-
-        return 0;
-}
-
-static int virq_debug_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, virq_debug_show, inode->i_private);
-}
-
-static const struct file_operations virq_debug_fops = {
-        .open = virq_debug_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-
-static int __init irq_debugfs_init(void)
-{
-        if (debugfs_create_file("virq_mapping", S_IRUGO, powerpc_debugfs_root,
-                                 NULL, &virq_debug_fops) == NULL)
-                return -ENOMEM;
-
-        return 0;
-}
-__initcall(irq_debugfs_init);
-#endif /* CONFIG_VIRQ_DEBUG */
-
 #ifdef CONFIG_PPC64
 static int __init setup_noirqdistrib(char *str)
 {