Merge branch 'core-memblock-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...

[karo-tx-linux.git] / kernel / irq / irqdesc.c

diff --git a/kernel/irq/irqdesc.c b/kernel/irq/irqdesc.c
index c9d5a1c1287474233dfbec72ba26e7e8a640ed01..9d917ff726759a931443e3b03693a558cc65b377 100644 (file)
--- a/kernel/irq/irqdesc.c
+++ b/kernel/irq/irqdesc.c
@@ -20,7 +20,7 @@
 /*
  * lockdep: we want to handle all irq_desc locks as a single lock-class:
  */
-struct lock_class_key irq_desc_lock_class;
+static struct lock_class_key irq_desc_lock_class;
 
 #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
 static void __init init_irq_default_affinity(void)
@@ -90,29 +90,12 @@ static void desc_set_defaults(unsigned int irq, struct irq_desc *desc, int node)
 int nr_irqs = NR_IRQS;
 EXPORT_SYMBOL_GPL(nr_irqs);
 
-DEFINE_RAW_SPINLOCK(sparse_irq_lock);
+static DEFINE_MUTEX(sparse_irq_lock);
 static DECLARE_BITMAP(allocated_irqs, NR_IRQS);
 
 #ifdef CONFIG_SPARSE_IRQ
 
-void __ref init_kstat_irqs(struct irq_desc *desc, int node, int nr)
-{
-       void *ptr;
-
-       ptr = kzalloc_node(nr * sizeof(*desc->kstat_irqs),
-                          GFP_ATOMIC, node);
-
-       /*
-        * don't overwite if can not get new one
-        * init_copy_kstat_irqs() could still use old one
-        */
-       if (ptr) {
-               printk(KERN_DEBUG "  alloc kstat_irqs on node %d\n", node);
-               desc->kstat_irqs = ptr;
-       }
-}
-
-static RADIX_TREE(irq_desc_tree, GFP_ATOMIC);
+static RADIX_TREE(irq_desc_tree, GFP_KERNEL);
 
 static void irq_insert_desc(unsigned int irq, struct irq_desc *desc)
 {
@@ -124,15 +107,6 @@ struct irq_desc *irq_to_desc(unsigned int irq)
        return radix_tree_lookup(&irq_desc_tree, irq);
 }
 
-void replace_irq_desc(unsigned int irq, struct irq_desc *desc)
-{
-       void **ptr;
-
-       ptr = radix_tree_lookup_slot(&irq_desc_tree, irq);
-       if (ptr)
-               radix_tree_replace_slot(ptr, desc);
-}
-
 static void delete_irq_desc(unsigned int irq)
 {
        radix_tree_delete(&irq_desc_tree, irq);
@@ -144,7 +118,7 @@ static void free_masks(struct irq_desc *desc)
 #ifdef CONFIG_GENERIC_PENDING_IRQ
        free_cpumask_var(desc->pending_mask);
 #endif
-       free_cpumask_var(desc->affinity);
+       free_cpumask_var(desc->irq_data.affinity);
 }
 #else
 static inline void free_masks(struct irq_desc *desc) { }
@@ -152,9 +126,8 @@ static inline void free_masks(struct irq_desc *desc) { }
 
 static struct irq_desc *alloc_desc(int irq, int node)
 {
-       /* Temporary hack until we can switch to GFP_KERNEL */
-       gfp_t gfp = gfp_allowed_mask == GFP_BOOT_MASK ? GFP_NOWAIT : GFP_ATOMIC;
        struct irq_desc *desc;
+       gfp_t gfp = GFP_KERNEL;
 
        desc = kzalloc_node(sizeof(*desc), gfp, node);
        if (!desc)
@@ -185,13 +158,12 @@ err_desc:
 static void free_desc(unsigned int irq)
 {
        struct irq_desc *desc = irq_to_desc(irq);
-       unsigned long flags;
 
        unregister_irq_proc(irq, desc);
 
-       raw_spin_lock_irqsave(&sparse_irq_lock, flags);
+       mutex_lock(&sparse_irq_lock);
        delete_irq_desc(irq);
-       raw_spin_unlock_irqrestore(&sparse_irq_lock, flags);
+       mutex_unlock(&sparse_irq_lock);
 
        free_masks(desc);
        kfree(desc->kstat_irqs);
@@ -201,16 +173,15 @@ static void free_desc(unsigned int irq)
 static int alloc_descs(unsigned int start, unsigned int cnt, int node)
 {
        struct irq_desc *desc;
-       unsigned long flags;
        int i;
 
        for (i = 0; i < cnt; i++) {
                desc = alloc_desc(start + i, node);
                if (!desc)
                        goto err;
-               raw_spin_lock_irqsave(&sparse_irq_lock, flags);
+               mutex_lock(&sparse_irq_lock);
                irq_insert_desc(start + i, desc);
-               raw_spin_unlock_irqrestore(&sparse_irq_lock, flags);
+               mutex_unlock(&sparse_irq_lock);
        }
        return start;
 
@@ -218,9 +189,9 @@ err:
        for (i--; i >= 0; i--)
                free_desc(start + i);
 
-       raw_spin_lock_irqsave(&sparse_irq_lock, flags);
+       mutex_lock(&sparse_irq_lock);
        bitmap_clear(allocated_irqs, start, cnt);
-       raw_spin_unlock_irqrestore(&sparse_irq_lock, flags);
+       mutex_unlock(&sparse_irq_lock);
        return -ENOMEM;
 }
 
@@ -317,7 +288,6 @@ static inline int alloc_descs(unsigned int start, unsigned int cnt, int node)
  */
 void irq_free_descs(unsigned int from, unsigned int cnt)
 {
-       unsigned long flags;
        int i;
 
        if (from >= nr_irqs || (from + cnt) > nr_irqs)
@@ -326,9 +296,9 @@ void irq_free_descs(unsigned int from, unsigned int cnt)
        for (i = 0; i < cnt; i++)
                free_desc(from + i);
 
-       raw_spin_lock_irqsave(&sparse_irq_lock, flags);
+       mutex_lock(&sparse_irq_lock);
        bitmap_clear(allocated_irqs, from, cnt);
-       raw_spin_unlock_irqrestore(&sparse_irq_lock, flags);
+       mutex_unlock(&sparse_irq_lock);
 }
 
 /**
@@ -343,13 +313,12 @@ void irq_free_descs(unsigned int from, unsigned int cnt)
 int __ref
 irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node)
 {
-       unsigned long flags;
        int start, ret;
 
        if (!cnt)
                return -EINVAL;
 
-       raw_spin_lock_irqsave(&sparse_irq_lock, flags);
+       mutex_lock(&sparse_irq_lock);
 
        start = bitmap_find_next_zero_area(allocated_irqs, nr_irqs, from, cnt, 0);
        ret = -EEXIST;
@@ -361,11 +330,11 @@ irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node)
                goto err;
 
        bitmap_set(allocated_irqs, start, cnt);
-       raw_spin_unlock_irqrestore(&sparse_irq_lock, flags);
+       mutex_unlock(&sparse_irq_lock);
        return alloc_descs(start, cnt, node);
 
 err:
-       raw_spin_unlock_irqrestore(&sparse_irq_lock, flags);
+       mutex_unlock(&sparse_irq_lock);
        return ret;
 }
 
@@ -378,20 +347,19 @@ err:
  */
 int irq_reserve_irqs(unsigned int from, unsigned int cnt)
 {
-       unsigned long flags;
        unsigned int start;
        int ret = 0;
 
        if (!cnt || (from + cnt) > nr_irqs)
                return -EINVAL;
 
-       raw_spin_lock_irqsave(&sparse_irq_lock, flags);
+       mutex_lock(&sparse_irq_lock);
        start = bitmap_find_next_zero_area(allocated_irqs, nr_irqs, from, cnt, 0);
        if (start == from)
                bitmap_set(allocated_irqs, start, cnt);
        else
                ret = -EEXIST;
-       raw_spin_unlock_irqrestore(&sparse_irq_lock, flags);
+       mutex_unlock(&sparse_irq_lock);
        return ret;
 }