Merge commit 'v2.6.33-rc5' into secretlab/test-devicetree

10 files changed, 138 insertions, 142 deletions

diff --git a/kernel/irq/autoprobe.c b/kernel/irq/autoprobe.c
index 1de9700f416e..2295a31ef110 100644
--- a/kernel/irq/autoprobe.c
+++ b/kernel/irq/autoprobe.c
@@ -45,7 +45,7 @@ unsigned long probe_irq_on(void)
          * flush such a longstanding irq before considering it as spurious.
          */
         for_each_irq_desc_reverse(i, desc) {
-                spin_lock_irq(&desc->lock);
+                raw_spin_lock_irq(&desc->lock);
                 if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
                         /*
                          * An old-style architecture might still have
@@ -61,7 +61,7 @@ unsigned long probe_irq_on(void)
                                 desc->chip->set_type(i, IRQ_TYPE_PROBE);
                         desc->chip->startup(i);
                 }
-                spin_unlock_irq(&desc->lock);
+                raw_spin_unlock_irq(&desc->lock);
         }
 
         /* Wait for longstanding interrupts to trigger. */
@@ -73,13 +73,13 @@ unsigned long probe_irq_on(void)
          * happened in the previous stage, it may have masked itself)
          */
         for_each_irq_desc_reverse(i, desc) {
-                spin_lock_irq(&desc->lock);
+                raw_spin_lock_irq(&desc->lock);
                 if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
                         desc->status |= IRQ_AUTODETECT | IRQ_WAITING;
                         if (desc->chip->startup(i))
                                 desc->status |= IRQ_PENDING;
                 }
-                spin_unlock_irq(&desc->lock);
+                raw_spin_unlock_irq(&desc->lock);
         }
 
         /*
@@ -91,7 +91,7 @@ unsigned long probe_irq_on(void)
          * Now filter out any obviously spurious interrupts
          */
         for_each_irq_desc(i, desc) {
-                spin_lock_irq(&desc->lock);
+                raw_spin_lock_irq(&desc->lock);
                 status = desc->status;
 
                 if (status & IRQ_AUTODETECT) {
@@ -103,7 +103,7 @@ unsigned long probe_irq_on(void)
                                 if (i < 32)
                                         mask |= 1 << i;
                 }
-                spin_unlock_irq(&desc->lock);
+                raw_spin_unlock_irq(&desc->lock);
         }
 
         return mask;
@@ -129,7 +129,7 @@ unsigned int probe_irq_mask(unsigned long val)
         int i;
 
         for_each_irq_desc(i, desc) {
-                spin_lock_irq(&desc->lock);
+                raw_spin_lock_irq(&desc->lock);
                 status = desc->status;
 
                 if (status & IRQ_AUTODETECT) {
@@ -139,7 +139,7 @@ unsigned int probe_irq_mask(unsigned long val)
                         desc->status = status & ~IRQ_AUTODETECT;
                         desc->chip->shutdown(i);
                 }
-                spin_unlock_irq(&desc->lock);
+                raw_spin_unlock_irq(&desc->lock);
         }
         mutex_unlock(&probing_active);
 
@@ -171,7 +171,7 @@ int probe_irq_off(unsigned long val)
         unsigned int status;
 
         for_each_irq_desc(i, desc) {
-                spin_lock_irq(&desc->lock);
+                raw_spin_lock_irq(&desc->lock);
                 status = desc->status;
 
                 if (status & IRQ_AUTODETECT) {
@@ -183,7 +183,7 @@ int probe_irq_off(unsigned long val)
                         desc->status = status & ~IRQ_AUTODETECT;
                         desc->chip->shutdown(i);
                 }
-                spin_unlock_irq(&desc->lock);
+                raw_spin_unlock_irq(&desc->lock);
         }
         mutex_unlock(&probing_active);
 
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index c1660194d115..ecc3fa28f666 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -34,7 +34,7 @@ void dynamic_irq_init(unsigned int irq)
         }
 
         /* Ensure we don't have left over values from a previous use of this irq */
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         desc->status = IRQ_DISABLED;
         desc->chip = &no_irq_chip;
         desc->handle_irq = handle_bad_irq;
@@ -51,7 +51,7 @@ void dynamic_irq_init(unsigned int irq)
         cpumask_clear(desc->pending_mask);
 #endif
 #endif
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 }
 
 /**
@@ -68,9 +68,9 @@ void dynamic_irq_cleanup(unsigned int irq)
                 return;
         }
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         if (desc->action) {
-                spin_unlock_irqrestore(&desc->lock, flags);
+                raw_spin_unlock_irqrestore(&desc->lock, flags);
                 WARN(1, KERN_ERR "Destroying IRQ%d without calling free_irq\n",
                         irq);
                 return;
@@ -82,7 +82,7 @@ void dynamic_irq_cleanup(unsigned int irq)
         desc->chip = &no_irq_chip;
         desc->name = NULL;
         clear_kstat_irqs(desc);
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 }
 
 
@@ -104,10 +104,10 @@ int set_irq_chip(unsigned int irq, struct irq_chip *chip)
         if (!chip)
                 chip = &no_irq_chip;
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         irq_chip_set_defaults(chip);
         desc->chip = chip;
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         return 0;
 }
@@ -133,9 +133,9 @@ int set_irq_type(unsigned int irq, unsigned int type)
         if (type == IRQ_TYPE_NONE)
                 return 0;
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         ret = __irq_set_trigger(desc, irq, type);
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         return ret;
 }
 EXPORT_SYMBOL(set_irq_type);
@@ -158,19 +158,19 @@ int set_irq_data(unsigned int irq, void *data)
                 return -EINVAL;
         }
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         desc->handler_data = data;
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         return 0;
 }
 EXPORT_SYMBOL(set_irq_data);
 
 /**
- *      set_irq_data - set irq type data for an irq
+ *      set_irq_msi - set MSI descriptor data for an irq
  *      @irq:   Interrupt number
  *      @entry: Pointer to MSI descriptor data
  *
- *      Set the hardware irq controller data for an irq
+ *      Set the MSI descriptor entry for an irq
  */
 int set_irq_msi(unsigned int irq, struct msi_desc *entry)
 {
@@ -183,11 +183,11 @@ int set_irq_msi(unsigned int irq, struct msi_desc *entry)
                 return -EINVAL;
         }
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         desc->msi_desc = entry;
         if (entry)
                 entry->irq = irq;
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         return 0;
 }
 
@@ -214,9 +214,9 @@ int set_irq_chip_data(unsigned int irq, void *data)
                 return -EINVAL;
         }
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         desc->chip_data = data;
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         return 0;
 }
@@ -241,12 +241,12 @@ void set_irq_nested_thread(unsigned int irq, int nest)
         if (!desc)
                 return;
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         if (nest)
                 desc->status |= IRQ_NESTED_THREAD;
         else
                 desc->status &= ~IRQ_NESTED_THREAD;
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 }
 EXPORT_SYMBOL_GPL(set_irq_nested_thread);
 
@@ -343,7 +343,7 @@ void handle_nested_irq(unsigned int irq)
 
         might_sleep();
 
-        spin_lock_irq(&desc->lock);
+        raw_spin_lock_irq(&desc->lock);
 
         kstat_incr_irqs_this_cpu(irq, desc);
 
@@ -352,17 +352,17 @@ void handle_nested_irq(unsigned int irq)
                 goto out_unlock;
 
         desc->status |= IRQ_INPROGRESS;
-        spin_unlock_irq(&desc->lock);
+        raw_spin_unlock_irq(&desc->lock);
 
         action_ret = action->thread_fn(action->irq, action->dev_id);
         if (!noirqdebug)
                 note_interrupt(irq, desc, action_ret);
 
-        spin_lock_irq(&desc->lock);
+        raw_spin_lock_irq(&desc->lock);
         desc->status &= ~IRQ_INPROGRESS;
 
 out_unlock:
-        spin_unlock_irq(&desc->lock);
+        raw_spin_unlock_irq(&desc->lock);
 }
 EXPORT_SYMBOL_GPL(handle_nested_irq);
 
@@ -384,7 +384,7 @@ handle_simple_irq(unsigned int irq, struct irq_desc *desc)
         struct irqaction *action;
         irqreturn_t action_ret;
 
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
 
         if (unlikely(desc->status & IRQ_INPROGRESS))
                 goto out_unlock;
@@ -396,16 +396,16 @@ handle_simple_irq(unsigned int irq, struct irq_desc *desc)
                 goto out_unlock;
 
         desc->status |= IRQ_INPROGRESS;
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 
         action_ret = handle_IRQ_event(irq, action);
         if (!noirqdebug)
                 note_interrupt(irq, desc, action_ret);
 
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
         desc->status &= ~IRQ_INPROGRESS;
 out_unlock:
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 }
 
 /**
@@ -424,7 +424,7 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
         struct irqaction *action;
         irqreturn_t action_ret;
 
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
         mask_ack_irq(desc, irq);
 
         if (unlikely(desc->status & IRQ_INPROGRESS))
@@ -441,13 +441,13 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
                 goto out_unlock;
 
         desc->status |= IRQ_INPROGRESS;
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 
         action_ret = handle_IRQ_event(irq, action);
         if (!noirqdebug)
                 note_interrupt(irq, desc, action_ret);
 
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
         desc->status &= ~IRQ_INPROGRESS;
 
         if (unlikely(desc->status & IRQ_ONESHOT))
@@ -455,7 +455,7 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
         else if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
                 desc->chip->unmask(irq);
 out_unlock:
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 }
 EXPORT_SYMBOL_GPL(handle_level_irq);
 
@@ -475,7 +475,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
         struct irqaction *action;
         irqreturn_t action_ret;
 
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
 
         if (unlikely(desc->status & IRQ_INPROGRESS))
                 goto out;
@@ -497,18 +497,18 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
 
         desc->status |= IRQ_INPROGRESS;
         desc->status &= ~IRQ_PENDING;
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 
         action_ret = handle_IRQ_event(irq, action);
         if (!noirqdebug)
                 note_interrupt(irq, desc, action_ret);
 
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
         desc->status &= ~IRQ_INPROGRESS;
 out:
         desc->chip->eoi(irq);
 
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 }
 
 /**
@@ -530,7 +530,7 @@ out:
 void
 handle_edge_irq(unsigned int irq, struct irq_desc *desc)
 {
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
 
         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
 
@@ -576,21 +576,21 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
                 }
 
                 desc->status &= ~IRQ_PENDING;
-                spin_unlock(&desc->lock);
+                raw_spin_unlock(&desc->lock);
                 action_ret = handle_IRQ_event(irq, action);
                 if (!noirqdebug)
                         note_interrupt(irq, desc, action_ret);
-                spin_lock(&desc->lock);
+                raw_spin_lock(&desc->lock);
 
         } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
 
         desc->status &= ~IRQ_INPROGRESS;
 out_unlock:
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 }
 
 /**
- *      handle_percpu_IRQ - Per CPU local irq handler
+ *      handle_percpu_irq - Per CPU local irq handler
  *      @irq:   the interrupt number
  *      @desc:  the interrupt description structure for this irq
  *
@@ -643,7 +643,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
         }
 
         chip_bus_lock(irq, desc);
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
 
         /* Uninstall? */
         if (handle == handle_bad_irq) {
@@ -661,7 +661,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
                 desc->depth = 0;
                 desc->chip->startup(irq);
         }
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL_GPL(__set_irq_handler);
@@ -692,9 +692,9 @@ void __init set_irq_noprobe(unsigned int irq)
                 return;
         }
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         desc->status |= IRQ_NOPROBE;
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 }
 
 void __init set_irq_probe(unsigned int irq)
@@ -707,7 +707,7 @@ void __init set_irq_probe(unsigned int irq)
                 return;
         }
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         desc->status &= ~IRQ_NOPROBE;
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 }
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 17c71bb565c6..814940e7f485 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -80,7 +80,7 @@ static struct irq_desc irq_desc_init = {
         .chip       = &no_irq_chip,
         .handle_irq = handle_bad_irq,
         .depth      = 1,
-        .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
+        .lock       = __RAW_SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
 };
 
 void __ref init_kstat_irqs(struct irq_desc *desc, int node, int nr)
@@ -108,7 +108,7 @@ static void init_one_irq_desc(int irq, struct irq_desc *desc, int node)
 {
         memcpy(desc, &irq_desc_init, sizeof(struct irq_desc));
 
-        spin_lock_init(&desc->lock);
+        raw_spin_lock_init(&desc->lock);
         desc->irq = irq;
 #ifdef CONFIG_SMP
         desc->node = node;
@@ -130,7 +130,7 @@ static void init_one_irq_desc(int irq, struct irq_desc *desc, int node)
 /*
  * Protect the sparse_irqs:
  */
-DEFINE_SPINLOCK(sparse_irq_lock);
+DEFINE_RAW_SPINLOCK(sparse_irq_lock);
 
 struct irq_desc **irq_desc_ptrs __read_mostly;
 
@@ -141,7 +141,7 @@ static struct irq_desc irq_desc_legacy[NR_IRQS_LEGACY] __cacheline_aligned_in_sm
                 .chip       = &no_irq_chip,
                 .handle_irq = handle_bad_irq,
                 .depth      = 1,
-                .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
+                .lock       = __RAW_SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
         }
 };
 
@@ -212,7 +212,7 @@ struct irq_desc * __ref irq_to_desc_alloc_node(unsigned int irq, int node)
         if (desc)
                 return desc;
 
-        spin_lock_irqsave(&sparse_irq_lock, flags);
+        raw_spin_lock_irqsave(&sparse_irq_lock, flags);
 
         /* We have to check it to avoid races with another CPU */
         desc = irq_desc_ptrs[irq];
@@ -234,7 +234,7 @@ struct irq_desc * __ref irq_to_desc_alloc_node(unsigned int irq, int node)
         irq_desc_ptrs[irq] = desc;
 
 out_unlock:
-        spin_unlock_irqrestore(&sparse_irq_lock, flags);
+        raw_spin_unlock_irqrestore(&sparse_irq_lock, flags);
 
         return desc;
 }
@@ -247,7 +247,7 @@ struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
                 .chip = &no_irq_chip,
                 .handle_irq = handle_bad_irq,
                 .depth = 1,
-                .lock = __SPIN_LOCK_UNLOCKED(irq_desc->lock),
+                .lock = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),
         }
 };
 
@@ -473,7 +473,7 @@ unsigned int __do_IRQ(unsigned int irq)
                 return 1;
         }
 
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
         if (desc->chip->ack)
                 desc->chip->ack(irq);
         /*
@@ -517,13 +517,13 @@ unsigned int __do_IRQ(unsigned int irq)
         for (;;) {
                 irqreturn_t action_ret;
 
-                spin_unlock(&desc->lock);
+                raw_spin_unlock(&desc->lock);
 
                 action_ret = handle_IRQ_event(irq, action);
                 if (!noirqdebug)
                         note_interrupt(irq, desc, action_ret);
 
-                spin_lock(&desc->lock);
+                raw_spin_lock(&desc->lock);
                 if (likely(!(desc->status & IRQ_PENDING)))
                         break;
                 desc->status &= ~IRQ_PENDING;
@@ -536,7 +536,7 @@ out:
          * disabled while the handler was running.
          */
         desc->chip->end(irq);
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 
         return 1;
 }
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index 1b5d742c6a77..b2821f070a3d 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -18,7 +18,7 @@ extern void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume);
 extern struct lock_class_key irq_desc_lock_class;
 extern void init_kstat_irqs(struct irq_desc *desc, int node, int nr);
 extern void clear_kstat_irqs(struct irq_desc *desc);
-extern spinlock_t sparse_irq_lock;
+extern raw_spinlock_t sparse_irq_lock;
 
 #ifdef CONFIG_SPARSE_IRQ
 /* irq_desc_ptrs allocated at boot time */
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index bde4c667d24d..eb6078ca60c7 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -46,9 +46,9 @@ void synchronize_irq(unsigned int irq)
                         cpu_relax();
 
                 /* Ok, that indicated we're done: double-check carefully. */
-                spin_lock_irqsave(&desc->lock, flags);
+                raw_spin_lock_irqsave(&desc->lock, flags);
                 status = desc->status;
-                spin_unlock_irqrestore(&desc->lock, flags);
+                raw_spin_unlock_irqrestore(&desc->lock, flags);
 
                 /* Oops, that failed? */
         } while (status & IRQ_INPROGRESS);
@@ -114,7 +114,7 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
         if (!desc->chip->set_affinity)
                 return -EINVAL;
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
 
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         if (desc->status & IRQ_MOVE_PCNTXT) {
@@ -134,7 +134,7 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
         }
 #endif
         desc->status |= IRQ_AFFINITY_SET;
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         return 0;
 }
 
@@ -181,11 +181,11 @@ int irq_select_affinity_usr(unsigned int irq)
         unsigned long flags;
         int ret;
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         ret = setup_affinity(irq, desc);
         if (!ret)
                 irq_set_thread_affinity(desc);
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         return ret;
 }
@@ -231,9 +231,9 @@ void disable_irq_nosync(unsigned int irq)
                 return;
 
         chip_bus_lock(irq, desc);
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         __disable_irq(desc, irq, false);
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL(disable_irq_nosync);
@@ -308,9 +308,9 @@ void enable_irq(unsigned int irq)
                 return;
 
         chip_bus_lock(irq, desc);
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         __enable_irq(desc, irq, false);
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL(enable_irq);
@@ -347,7 +347,7 @@ int set_irq_wake(unsigned int irq, unsigned int on)
         /* wakeup-capable irqs can be shared between drivers that
          * don't need to have the same sleep mode behaviors.
          */
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         if (on) {
                 if (desc->wake_depth++ == 0) {
                         ret = set_irq_wake_real(irq, on);
@@ -368,7 +368,7 @@ int set_irq_wake(unsigned int irq, unsigned int on)
                 }
         }
 
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         return ret;
 }
 EXPORT_SYMBOL(set_irq_wake);
@@ -484,12 +484,12 @@ static int irq_wait_for_interrupt(struct irqaction *action)
 static void irq_finalize_oneshot(unsigned int irq, struct irq_desc *desc)
 {
         chip_bus_lock(irq, desc);
-        spin_lock_irq(&desc->lock);
+        raw_spin_lock_irq(&desc->lock);
         if (!(desc->status & IRQ_DISABLED) && (desc->status & IRQ_MASKED)) {
                 desc->status &= ~IRQ_MASKED;
                 desc->chip->unmask(irq);
         }
-        spin_unlock_irq(&desc->lock);
+        raw_spin_unlock_irq(&desc->lock);
         chip_bus_sync_unlock(irq, desc);
 }
 
@@ -514,9 +514,9 @@ irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
                 return;
         }
 
-        spin_lock_irq(&desc->lock);
+        raw_spin_lock_irq(&desc->lock);
         cpumask_copy(mask, desc->affinity);
-        spin_unlock_irq(&desc->lock);
+        raw_spin_unlock_irq(&desc->lock);
 
         set_cpus_allowed_ptr(current, mask);
         free_cpumask_var(mask);
@@ -545,7 +545,7 @@ static int irq_thread(void *data)
 
                 atomic_inc(&desc->threads_active);
 
-                spin_lock_irq(&desc->lock);
+                raw_spin_lock_irq(&desc->lock);
                 if (unlikely(desc->status & IRQ_DISABLED)) {
                         /*
                          * CHECKME: We might need a dedicated
@@ -555,9 +555,9 @@ static int irq_thread(void *data)
                          * retriggers the interrupt itself --- tglx
                          */
                         desc->status |= IRQ_PENDING;
-                        spin_unlock_irq(&desc->lock);
+                        raw_spin_unlock_irq(&desc->lock);
                 } else {
-                        spin_unlock_irq(&desc->lock);
+                        raw_spin_unlock_irq(&desc->lock);
 
                         action->thread_fn(action->irq, action->dev_id);
 
@@ -679,7 +679,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
         /*
          * The following block of code has to be executed atomically
          */
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         old_ptr = &desc->action;
         old = *old_ptr;
         if (old) {
@@ -775,7 +775,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 __enable_irq(desc, irq, false);
         }
 
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         /*
          * Strictly no need to wake it up, but hung_task complains
@@ -802,7 +802,7 @@ mismatch:
         ret = -EBUSY;
 
 out_thread:
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         if (new->thread) {
                 struct task_struct *t = new->thread;
 
@@ -844,7 +844,7 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
         if (!desc)
                 return NULL;
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
 
         /*
          * There can be multiple actions per IRQ descriptor, find the right
@@ -856,7 +856,7 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
 
                 if (!action) {
                         WARN(1, "Trying to free already-free IRQ %d\n", irq);
-                        spin_unlock_irqrestore(&desc->lock, flags);
+                        raw_spin_unlock_irqrestore(&desc->lock, flags);
 
                         return NULL;
                 }
@@ -884,7 +884,7 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
                         desc->chip->disable(irq);
         }
 
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         unregister_handler_proc(irq, action);
 
@@ -1067,7 +1067,7 @@ int request_threaded_irq(unsigned int irq, irq_handler_t handler,
                 kfree(action);
 
 #ifdef CONFIG_DEBUG_SHIRQ
-        if (irqflags & IRQF_SHARED) {
+        if (!retval && (irqflags & IRQF_SHARED)) {
                 /*
                  * It's a shared IRQ -- the driver ought to be prepared for it
                  * to happen immediately, so let's make sure....
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index fcb6c96f2627..241962280836 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -27,7 +27,7 @@ void move_masked_irq(int irq)
         if (!desc->chip->set_affinity)
                 return;
 
-        assert_spin_locked(&desc->lock);
+        assert_raw_spin_locked(&desc->lock);
 
         /*
          * If there was a valid mask to work with, please
diff --git a/kernel/irq/numa_migrate.c b/kernel/irq/numa_migrate.c
index 3fd30197da2e..26bac9d8f860 100644
--- a/kernel/irq/numa_migrate.c
+++ b/kernel/irq/numa_migrate.c
@@ -42,7 +42,7 @@ static bool init_copy_one_irq_desc(int irq, struct irq_desc *old_desc,
                                 "for migration.\n", irq);
                 return false;
         }
-        spin_lock_init(&desc->lock);
+        raw_spin_lock_init(&desc->lock);
         desc->node = node;
         lockdep_set_class(&desc->lock, &irq_desc_lock_class);
         init_copy_kstat_irqs(old_desc, desc, node, nr_cpu_ids);
@@ -67,7 +67,7 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
 
         irq = old_desc->irq;
 
-        spin_lock_irqsave(&sparse_irq_lock, flags);
+        raw_spin_lock_irqsave(&sparse_irq_lock, flags);
 
         /* We have to check it to avoid races with another CPU */
         desc = irq_desc_ptrs[irq];
@@ -91,7 +91,7 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
         }
 
         irq_desc_ptrs[irq] = desc;
-        spin_unlock_irqrestore(&sparse_irq_lock, flags);
+        raw_spin_unlock_irqrestore(&sparse_irq_lock, flags);
 
         /* free the old one */
         free_one_irq_desc(old_desc, desc);
@@ -100,7 +100,7 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
         return desc;
 
 out_unlock:
-        spin_unlock_irqrestore(&sparse_irq_lock, flags);
+        raw_spin_unlock_irqrestore(&sparse_irq_lock, flags);
 
         return desc;
 }
diff --git a/kernel/irq/pm.c b/kernel/irq/pm.c
index a0bb09e79867..0d4005d85b03 100644
--- a/kernel/irq/pm.c
+++ b/kernel/irq/pm.c
@@ -28,9 +28,9 @@ void suspend_device_irqs(void)
         for_each_irq_desc(irq, desc) {
                 unsigned long flags;
 
-                spin_lock_irqsave(&desc->lock, flags);
+                raw_spin_lock_irqsave(&desc->lock, flags);
                 __disable_irq(desc, irq, true);
-                spin_unlock_irqrestore(&desc->lock, flags);
+                raw_spin_unlock_irqrestore(&desc->lock, flags);
         }
 
         for_each_irq_desc(irq, desc)
@@ -56,9 +56,9 @@ void resume_device_irqs(void)
                 if (!(desc->status & IRQ_SUSPENDED))
                         continue;
 
-                spin_lock_irqsave(&desc->lock, flags);
+                raw_spin_lock_irqsave(&desc->lock, flags);
                 __enable_irq(desc, irq, true);
-                spin_unlock_irqrestore(&desc->lock, flags);
+                raw_spin_unlock_irqrestore(&desc->lock, flags);
         }
 }
 EXPORT_SYMBOL_GPL(resume_device_irqs);
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index 692363dd591f..6f50eccc79c0 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -136,7 +136,7 @@ out:
 
 static int default_affinity_open(struct inode *inode, struct file *file)
 {
-        return single_open(file, default_affinity_show, NULL);
+        return single_open(file, default_affinity_show, PDE(inode)->data);
 }
 
 static const struct file_operations default_affinity_proc_fops = {
@@ -148,18 +148,28 @@ static const struct file_operations default_affinity_proc_fops = {
 };
 #endif
 
-static int irq_spurious_read(char *page, char **start, off_t off,
-                                  int count, int *eof, void *data)
+static int irq_spurious_proc_show(struct seq_file *m, void *v)
 {
-        struct irq_desc *desc = irq_to_desc((long) data);
-        return sprintf(page, "count %u\n"
-                             "unhandled %u\n"
-                             "last_unhandled %u ms\n",
-                        desc->irq_count,
-                        desc->irqs_unhandled,
-                        jiffies_to_msecs(desc->last_unhandled));
+        struct irq_desc *desc = irq_to_desc((long) m->private);
+
+        seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
+                   desc->irq_count, desc->irqs_unhandled,
+                   jiffies_to_msecs(desc->last_unhandled));
+        return 0;
+}
+
+static int irq_spurious_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, irq_spurious_proc_show, NULL);
 }
 
+static const struct file_operations irq_spurious_proc_fops = {
+        .open           = irq_spurious_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 #define MAX_NAMELEN 128
 
 static int name_unique(unsigned int irq, struct irqaction *new_action)
@@ -169,7 +179,7 @@ static int name_unique(unsigned int irq, struct irqaction *new_action)
         unsigned long flags;
         int ret = 1;
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         for (action = desc->action ; action; action = action->next) {
                 if ((action != new_action) && action->name &&
                                 !strcmp(new_action->name, action->name)) {
@@ -177,7 +187,7 @@ static int name_unique(unsigned int irq, struct irqaction *new_action)
                         break;
                 }
         }
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         return ret;
 }
 
@@ -204,7 +214,6 @@ void register_handler_proc(unsigned int irq, struct irqaction *action)
 void register_irq_proc(unsigned int irq, struct irq_desc *desc)
 {
         char name [MAX_NAMELEN];
-        struct proc_dir_entry *entry;
 
         if (!root_irq_dir || (desc->chip == &no_irq_chip) || desc->dir)
                 return;
@@ -214,6 +223,8 @@ void register_irq_proc(unsigned int irq, struct irq_desc *desc)
 
         /* create /proc/irq/1234 */
         desc->dir = proc_mkdir(name, root_irq_dir);
+        if (!desc->dir)
+                return;
 
 #ifdef CONFIG_SMP
         /* create /proc/irq/<irq>/smp_affinity */
@@ -221,11 +232,8 @@ void register_irq_proc(unsigned int irq, struct irq_desc *desc)
                          &irq_affinity_proc_fops, (void *)(long)irq);
 #endif
 
-        entry = create_proc_entry("spurious", 0444, desc->dir);
-        if (entry) {
-                entry->data = (void *)(long)irq;
-                entry->read_proc = irq_spurious_read;
-        }
+        proc_create_data("spurious", 0444, desc->dir,
+                         &irq_spurious_proc_fops, (void *)(long)irq);
 }
 
 #undef MAX_NAMELEN
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index bd7273e6282e..89fb90ae534f 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -28,7 +28,7 @@ static int try_one_irq(int irq, struct irq_desc *desc)
         struct irqaction *action;
         int ok = 0, work = 0;
 
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
         /* Already running on another processor */
         if (desc->status & IRQ_INPROGRESS) {
                 /*
@@ -37,13 +37,13 @@ static int try_one_irq(int irq, struct irq_desc *desc)
                  */
                 if (desc->action && (desc->action->flags & IRQF_SHARED))
                         desc->status |= IRQ_PENDING;
-                spin_unlock(&desc->lock);
+                raw_spin_unlock(&desc->lock);
                 return ok;
         }
         /* Honour the normal IRQ locking */
         desc->status |= IRQ_INPROGRESS;
         action = desc->action;
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 
         while (action) {
                 /* Only shared IRQ handlers are safe to call */
@@ -56,7 +56,7 @@ static int try_one_irq(int irq, struct irq_desc *desc)
         }
         local_irq_disable();
         /* Now clean up the flags */
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
         action = desc->action;
 
         /*
@@ -68,9 +68,9 @@ static int try_one_irq(int irq, struct irq_desc *desc)
                  * Perform real IRQ processing for the IRQ we deferred
                  */
                 work = 1;
-                spin_unlock(&desc->lock);
+                raw_spin_unlock(&desc->lock);
                 handle_IRQ_event(irq, action);
-                spin_lock(&desc->lock);
+                raw_spin_lock(&desc->lock);
                 desc->status &= ~IRQ_PENDING;
         }
         desc->status &= ~IRQ_INPROGRESS;
@@ -80,7 +80,7 @@ static int try_one_irq(int irq, struct irq_desc *desc)
          */
         if (work && desc->chip && desc->chip->end)
                 desc->chip->end(irq);
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 
         return ok;
 }
@@ -104,7 +104,7 @@ static int misrouted_irq(int irq)
         return ok;
 }
 
-static void poll_all_shared_irqs(void)
+static void poll_spurious_irqs(unsigned long dummy)
 {
         struct irq_desc *desc;
         int i;
@@ -125,23 +125,11 @@ static void poll_all_shared_irqs(void)
                 try_one_irq(i, desc);
                 local_irq_enable();
         }
-}
-
-static void poll_spurious_irqs(unsigned long dummy)
-{
-        poll_all_shared_irqs();
 
         mod_timer(&poll_spurious_irq_timer,
                   jiffies + POLL_SPURIOUS_IRQ_INTERVAL);
 }
 
-#ifdef CONFIG_DEBUG_SHIRQ
-void debug_poll_all_shared_irqs(void)
-{
-        poll_all_shared_irqs();
-}
-#endif
-
 /*
  * If 99,900 of the previous 100,000 interrupts have not been handled
  * then assume that the IRQ is stuck in some manner. Drop a diagnostic
@@ -232,7 +220,7 @@ void note_interrupt(unsigned int irq, struct irq_desc *desc,
                 /*
                  * If we are seeing only the odd spurious IRQ caused by
                  * bus asynchronicity then don't eventually trigger an error,
-                 * otherwise the couter becomes a doomsday timer for otherwise
+                 * otherwise the counter becomes a doomsday timer for otherwise
                  * working systems
                  */
                 if (time_after(jiffies, desc->last_unhandled + HZ/10))