genirq: Convert core code to irq_data

Convert all references in the core code to orq, chip, handler_data,
chip_data, msi_desc, affinity to irq_data.*

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Ingo Molnar <mingo@elte.hu>

10 files changed, 106 insertions, 105 deletions

diff --git a/kernel/irq/autoprobe.c b/kernel/irq/autoprobe.c
index 2295a31ef110..f9bf9b228033 100644
--- a/kernel/irq/autoprobe.c
+++ b/kernel/irq/autoprobe.c
@@ -57,9 +57,9 @@ unsigned long probe_irq_on(void)
                          * Some chips need to know about probing in
                          * progress:
                          */
-                        if (desc->chip->set_type)
-                                desc->chip->set_type(i, IRQ_TYPE_PROBE);
-                        desc->chip->startup(i);
+                        if (desc->irq_data.chip->set_type)
+                                desc->irq_data.chip->set_type(i, IRQ_TYPE_PROBE);
+                        desc->irq_data.chip->startup(i);
                 }
                 raw_spin_unlock_irq(&desc->lock);
         }
@@ -76,7 +76,7 @@ unsigned long probe_irq_on(void)
                 raw_spin_lock_irq(&desc->lock);
                 if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
                         desc->status |= IRQ_AUTODETECT | IRQ_WAITING;
-                        if (desc->chip->startup(i))
+                        if (desc->irq_data.chip->startup(i))
                                 desc->status |= IRQ_PENDING;
                 }
                 raw_spin_unlock_irq(&desc->lock);
@@ -98,7 +98,7 @@ unsigned long probe_irq_on(void)
                         /* It triggered already - consider it spurious. */
                         if (!(status & IRQ_WAITING)) {
                                 desc->status = status & ~IRQ_AUTODETECT;
-                                desc->chip->shutdown(i);
+                                desc->irq_data.chip->shutdown(i);
                         } else
                                 if (i < 32)
                                         mask |= 1 << i;
@@ -137,7 +137,7 @@ unsigned int probe_irq_mask(unsigned long val)
                                 mask |= 1 << i;
 
                         desc->status = status & ~IRQ_AUTODETECT;
-                        desc->chip->shutdown(i);
+                        desc->irq_data.chip->shutdown(i);
                 }
                 raw_spin_unlock_irq(&desc->lock);
         }
@@ -181,7 +181,7 @@ int probe_irq_off(unsigned long val)
                                 nr_of_irqs++;
                         }
                         desc->status = status & ~IRQ_AUTODETECT;
-                        desc->chip->shutdown(i);
+                        desc->irq_data.chip->shutdown(i);
                 }
                 raw_spin_unlock_irq(&desc->lock);
         }
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index 4ea775cc60f0..e0e93ff10afd 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -32,18 +32,18 @@ static void dynamic_irq_init_x(unsigned int irq, bool keep_chip_data)
         /* Ensure we don't have left over values from a previous use of this irq */
         raw_spin_lock_irqsave(&desc->lock, flags);
         desc->status = IRQ_DISABLED;
-        desc->chip = &no_irq_chip;
+        desc->irq_data.chip = &no_irq_chip;
         desc->handle_irq = handle_bad_irq;
         desc->depth = 1;
-        desc->msi_desc = NULL;
-        desc->handler_data = NULL;
+        desc->irq_data.msi_desc = NULL;
+        desc->irq_data.handler_data = NULL;
         if (!keep_chip_data)
-                desc->chip_data = NULL;
+                desc->irq_data.chip_data = NULL;
         desc->action = NULL;
         desc->irq_count = 0;
         desc->irqs_unhandled = 0;
 #ifdef CONFIG_SMP
-        cpumask_setall(desc->affinity);
+        cpumask_setall(desc->irq_data.affinity);
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         cpumask_clear(desc->pending_mask);
 #endif
@@ -64,7 +64,7 @@ void dynamic_irq_init(unsigned int irq)
  *      dynamic_irq_init_keep_chip_data - initialize a dynamically allocated irq
  *      @irq:   irq number to initialize
  *
- *      does not set irq_to_desc(irq)->chip_data to NULL
+ *      does not set irq_to_desc(irq)->irq_data.chip_data to NULL
  */
 void dynamic_irq_init_keep_chip_data(unsigned int irq)
 {
@@ -88,12 +88,12 @@ static void dynamic_irq_cleanup_x(unsigned int irq, bool keep_chip_data)
                         irq);
                 return;
         }
-        desc->msi_desc = NULL;
-        desc->handler_data = NULL;
+        desc->irq_data.msi_desc = NULL;
+        desc->irq_data.handler_data = NULL;
         if (!keep_chip_data)
-                desc->chip_data = NULL;
+                desc->irq_data.chip_data = NULL;
         desc->handle_irq = handle_bad_irq;
-        desc->chip = &no_irq_chip;
+        desc->irq_data.chip = &no_irq_chip;
         desc->name = NULL;
         clear_kstat_irqs(desc);
         raw_spin_unlock_irqrestore(&desc->lock, flags);
@@ -112,7 +112,7 @@ void dynamic_irq_cleanup(unsigned int irq)
  *      dynamic_irq_cleanup_keep_chip_data - cleanup a dynamically allocated irq
  *      @irq:   irq number to initialize
  *
- *      does not set irq_to_desc(irq)->chip_data to NULL
+ *      does not set irq_to_desc(irq)->irq_data.chip_data to NULL
  */
 void dynamic_irq_cleanup_keep_chip_data(unsigned int irq)
 {
@@ -140,7 +140,7 @@ int set_irq_chip(unsigned int irq, struct irq_chip *chip)
 
         raw_spin_lock_irqsave(&desc->lock, flags);
         irq_chip_set_defaults(chip);
-        desc->chip = chip;
+        desc->irq_data.chip = chip;
         raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         return 0;
@@ -193,7 +193,7 @@ int set_irq_data(unsigned int irq, void *data)
         }
 
         raw_spin_lock_irqsave(&desc->lock, flags);
-        desc->handler_data = data;
+        desc->irq_data.handler_data = data;
         raw_spin_unlock_irqrestore(&desc->lock, flags);
         return 0;
 }
@@ -218,7 +218,7 @@ int set_irq_msi(unsigned int irq, struct msi_desc *entry)
         }
 
         raw_spin_lock_irqsave(&desc->lock, flags);
-        desc->msi_desc = entry;
+        desc->irq_data.msi_desc = entry;
         if (entry)
                 entry->irq = irq;
         raw_spin_unlock_irqrestore(&desc->lock, flags);
@@ -243,13 +243,13 @@ int set_irq_chip_data(unsigned int irq, void *data)
                 return -EINVAL;
         }
 
-        if (!desc->chip) {
+        if (!desc->irq_data.chip) {
                 printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq);
                 return -EINVAL;
         }
 
         raw_spin_lock_irqsave(&desc->lock, flags);
-        desc->chip_data = data;
+        desc->irq_data.chip_data = data;
         raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         return 0;
@@ -291,7 +291,7 @@ static void default_enable(unsigned int irq)
 {
         struct irq_desc *desc = irq_to_desc(irq);
 
-        desc->chip->unmask(irq);
+        desc->irq_data.chip->unmask(irq);
         desc->status &= ~IRQ_MASKED;
 }
 
@@ -309,7 +309,7 @@ static unsigned int default_startup(unsigned int irq)
 {
         struct irq_desc *desc = irq_to_desc(irq);
 
-        desc->chip->enable(irq);
+        desc->irq_data.chip->enable(irq);
         return 0;
 }
 
@@ -320,7 +320,7 @@ static void default_shutdown(unsigned int irq)
 {
         struct irq_desc *desc = irq_to_desc(irq);
 
-        desc->chip->mask(irq);
+        desc->irq_data.chip->mask(irq);
         desc->status |= IRQ_MASKED;
 }
 
@@ -350,28 +350,28 @@ void irq_chip_set_defaults(struct irq_chip *chip)
 
 static inline void mask_ack_irq(struct irq_desc *desc, int irq)
 {
-        if (desc->chip->mask_ack)
-                desc->chip->mask_ack(irq);
+        if (desc->irq_data.chip->mask_ack)
+                desc->irq_data.chip->mask_ack(irq);
         else {
-                desc->chip->mask(irq);
-                if (desc->chip->ack)
-                        desc->chip->ack(irq);
+                desc->irq_data.chip->mask(irq);
+                if (desc->irq_data.chip->ack)
+                        desc->irq_data.chip->ack(irq);
         }
         desc->status |= IRQ_MASKED;
 }
 
 static inline void mask_irq(struct irq_desc *desc, int irq)
 {
-        if (desc->chip->mask) {
-                desc->chip->mask(irq);
+        if (desc->irq_data.chip->mask) {
+                desc->irq_data.chip->mask(irq);
                 desc->status |= IRQ_MASKED;
         }
 }
 
 static inline void unmask_irq(struct irq_desc *desc, int irq)
 {
-        if (desc->chip->unmask) {
-                desc->chip->unmask(irq);
+        if (desc->irq_data.chip->unmask) {
+                desc->irq_data.chip->unmask(irq);
                 desc->status &= ~IRQ_MASKED;
         }
 }
@@ -552,7 +552,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
         raw_spin_lock(&desc->lock);
         desc->status &= ~IRQ_INPROGRESS;
 out:
-        desc->chip->eoi(irq);
+        desc->irq_data.chip->eoi(irq);
 
         raw_spin_unlock(&desc->lock);
 }
@@ -594,8 +594,8 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
         kstat_incr_irqs_this_cpu(irq, desc);
 
         /* Start handling the irq */
-        if (desc->chip->ack)
-                desc->chip->ack(irq);
+        if (desc->irq_data.chip->ack)
+                desc->irq_data.chip->ack(irq);
 
         /* Mark the IRQ currently in progress.*/
         desc->status |= IRQ_INPROGRESS;
@@ -648,15 +648,15 @@ handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
 
         kstat_incr_irqs_this_cpu(irq, desc);
 
-        if (desc->chip->ack)
-                desc->chip->ack(irq);
+        if (desc->irq_data.chip->ack)
+                desc->irq_data.chip->ack(irq);
 
         action_ret = handle_IRQ_event(irq, desc->action);
         if (!noirqdebug)
                 note_interrupt(irq, desc, action_ret);
 
-        if (desc->chip->eoi)
-                desc->chip->eoi(irq);
+        if (desc->irq_data.chip->eoi)
+                desc->irq_data.chip->eoi(irq);
 }
 
 void
@@ -674,7 +674,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
 
         if (!handle)
                 handle = handle_bad_irq;
-        else if (desc->chip == &no_irq_chip) {
+        else if (desc->irq_data.chip == &no_irq_chip) {
                 printk(KERN_WARNING "Trying to install %sinterrupt handler "
                        "for IRQ%d\n", is_chained ? "chained " : "", irq);
                 /*
@@ -684,7 +684,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
                  * prevent us to setup the interrupt at all. Switch it to
                  * dummy_irq_chip for easy transition.
                  */
-                desc->chip = &dummy_irq_chip;
+                desc->irq_data.chip = &dummy_irq_chip;
         }
 
         chip_bus_lock(irq, desc);
@@ -692,7 +692,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
 
         /* Uninstall? */
         if (handle == handle_bad_irq) {
-                if (desc->chip != &no_irq_chip)
+                if (desc->irq_data.chip != &no_irq_chip)
                         mask_ack_irq(desc, irq);
                 desc->status |= IRQ_DISABLED;
                 desc->depth = 1;
@@ -704,7 +704,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
                 desc->status &= ~IRQ_DISABLED;
                 desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
                 desc->depth = 0;
-                desc->chip->startup(irq);
+                desc->irq_data.chip->startup(irq);
         }
         raw_spin_unlock_irqrestore(&desc->lock, flags);
         chip_bus_sync_unlock(irq, desc);
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 099d4fc368c3..fc27d76e83ef 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -105,7 +105,7 @@ static void init_one_irq_desc(int irq, struct irq_desc *desc, int node)
         raw_spin_lock_init(&desc->lock);
         desc->irq_data.irq = irq;
 #ifdef CONFIG_SMP
-        desc->node = node;
+        desc->irq_data.node = node;
 #endif
         lockdep_set_class(&desc->lock, &irq_desc_lock_class);
         init_kstat_irqs(desc, node, nr_cpu_ids);
@@ -185,7 +185,7 @@ int __init early_irq_init(void)
                 desc[i].irq_data.irq = i;
                 desc[i].irq_data.chip = &no_irq_chip;
 #ifdef CONFIG_SMP
-                desc[i].node = node;
+                desc[i].irq_data.node = node;
 #endif
                 desc[i].kstat_irqs = kstat_irqs_legacy + i * nr_cpu_ids;
                 lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
@@ -456,20 +456,20 @@ unsigned int __do_IRQ(unsigned int irq)
                 /*
                  * No locking required for CPU-local interrupts:
                  */
-                if (desc->chip->ack)
-                        desc->chip->ack(irq);
+                if (desc->irq_data.chip->ack)
+                        desc->irq_data.chip->ack(irq);
                 if (likely(!(desc->status & IRQ_DISABLED))) {
                         action_ret = handle_IRQ_event(irq, desc->action);
                         if (!noirqdebug)
                                 note_interrupt(irq, desc, action_ret);
                 }
-                desc->chip->end(irq);
+                desc->irq_data.chip->end(irq);
                 return 1;
         }
 
         raw_spin_lock(&desc->lock);
-        if (desc->chip->ack)
-                desc->chip->ack(irq);
+        if (desc->irq_data.chip->ack)
+                desc->irq_data.chip->ack(irq);
         /*
          * REPLAY is when Linux resends an IRQ that was dropped earlier
          * WAITING is used by probe to mark irqs that are being tested
@@ -529,7 +529,7 @@ out:
          * The ->end() handler has to deal with interrupts which got
          * disabled while the handler was running.
          */
-        desc->chip->end(irq);
+        desc->irq_data.chip->end(irq);
         raw_spin_unlock(&desc->lock);
 
         return 1;
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index c63f3bc88f0b..a805a00cfd28 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -43,14 +43,14 @@ extern void irq_set_thread_affinity(struct irq_desc *desc);
 /* Inline functions for support of irq chips on slow busses */
 static inline void chip_bus_lock(unsigned int irq, struct irq_desc *desc)
 {
-        if (unlikely(desc->chip->bus_lock))
-                desc->chip->bus_lock(irq);
+        if (unlikely(desc->irq_data.chip->bus_lock))
+                desc->irq_data.chip->bus_lock(irq);
 }
 
 static inline void chip_bus_sync_unlock(unsigned int irq, struct irq_desc *desc)
 {
-        if (unlikely(desc->chip->bus_sync_unlock))
-                desc->chip->bus_sync_unlock(irq);
+        if (unlikely(desc->irq_data.chip->bus_sync_unlock))
+                desc->irq_data.chip->bus_sync_unlock(irq);
 }
 
 /*
@@ -67,8 +67,8 @@ static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc)
                 irq, desc, desc->depth, desc->irq_count, desc->irqs_unhandled);
         printk("->handle_irq():  %p, ", desc->handle_irq);
         print_symbol("%s\n", (unsigned long)desc->handle_irq);
-        printk("->chip(): %p, ", desc->chip);
-        print_symbol("%s\n", (unsigned long)desc->chip);
+        printk("->irq_data.chip(): %p, ", desc->irq_data.chip);
+        print_symbol("%s\n", (unsigned long)desc->irq_data.chip);
         printk("->action(): %p\n", desc->action);
         if (desc->action) {
                 printk("->action->handler(): %p, ", desc->action->handler);
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index c3003e9d91a3..4dfb19521d9f 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -73,8 +73,8 @@ int irq_can_set_affinity(unsigned int irq)
 {
         struct irq_desc *desc = irq_to_desc(irq);
 
-        if (CHECK_IRQ_PER_CPU(desc->status) || !desc->chip ||
-            !desc->chip->set_affinity)
+        if (CHECK_IRQ_PER_CPU(desc->status) || !desc->irq_data.chip ||
+            !desc->irq_data.chip->set_affinity)
                 return 0;
 
         return 1;
@@ -111,15 +111,15 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
         struct irq_desc *desc = irq_to_desc(irq);
         unsigned long flags;
 
-        if (!desc->chip->set_affinity)
+        if (!desc->irq_data.chip->set_affinity)
                 return -EINVAL;
 
         raw_spin_lock_irqsave(&desc->lock, flags);
 
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         if (desc->status & IRQ_MOVE_PCNTXT) {
-                if (!desc->chip->set_affinity(irq, cpumask)) {
-                        cpumask_copy(desc->affinity, cpumask);
+                if (!desc->irq_data.chip->set_affinity(irq, cpumask)) {
+                        cpumask_copy(desc->irq_data.affinity, cpumask);
                         irq_set_thread_affinity(desc);
                 }
         }
@@ -128,8 +128,8 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
                 cpumask_copy(desc->pending_mask, cpumask);
         }
 #else
-        if (!desc->chip->set_affinity(irq, cpumask)) {
-                cpumask_copy(desc->affinity, cpumask);
+        if (!desc->irq_data.chip->set_affinity(irq, cpumask)) {
+                cpumask_copy(desc->irq_data.affinity, cpumask);
                 irq_set_thread_affinity(desc);
         }
 #endif
@@ -168,16 +168,16 @@ static int setup_affinity(unsigned int irq, struct irq_desc *desc)
          * one of the targets is online.
          */
         if (desc->status & (IRQ_AFFINITY_SET | IRQ_NO_BALANCING)) {
-                if (cpumask_any_and(desc->affinity, cpu_online_mask)
+                if (cpumask_any_and(desc->irq_data.affinity, cpu_online_mask)
                     < nr_cpu_ids)
                         goto set_affinity;
                 else
                         desc->status &= ~IRQ_AFFINITY_SET;
         }
 
-        cpumask_and(desc->affinity, cpu_online_mask, irq_default_affinity);
+        cpumask_and(desc->irq_data.affinity, cpu_online_mask, irq_default_affinity);
 set_affinity:
-        desc->chip->set_affinity(irq, desc->affinity);
+        desc->irq_data.chip->set_affinity(irq, desc->irq_data.affinity);
 
         return 0;
 }
@@ -223,7 +223,7 @@ void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend)
 
         if (!desc->depth++) {
                 desc->status |= IRQ_DISABLED;
-                desc->chip->disable(irq);
+                desc->irq_data.chip->disable(irq);
         }
 }
 
@@ -313,7 +313,7 @@ void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume)
  *      IRQ line is re-enabled.
  *
  *      This function may be called from IRQ context only when
- *      desc->chip->bus_lock and desc->chip->bus_sync_unlock are NULL !
+ *      desc->irq_data.chip->bus_lock and desc->chip->bus_sync_unlock are NULL !
  */
 void enable_irq(unsigned int irq)
 {
@@ -336,8 +336,8 @@ static int set_irq_wake_real(unsigned int irq, unsigned int on)
         struct irq_desc *desc = irq_to_desc(irq);
         int ret = -ENXIO;
 
-        if (desc->chip->set_wake)
-                ret = desc->chip->set_wake(irq, on);
+        if (desc->irq_data.chip->set_wake)
+                ret = desc->irq_data.chip->set_wake(irq, on);
 
         return ret;
 }
@@ -432,7 +432,7 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
                 unsigned long flags)
 {
         int ret;
-        struct irq_chip *chip = desc->chip;
+        struct irq_chip *chip = desc->irq_data.chip;
 
         if (!chip || !chip->set_type) {
                 /*
@@ -457,8 +457,8 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
                 desc->status &= ~(IRQ_LEVEL | IRQ_TYPE_SENSE_MASK);
                 desc->status |= flags;
 
-                if (chip != desc->chip)
-                        irq_chip_set_defaults(desc->chip);
+                if (chip != desc->irq_data.chip)
+                        irq_chip_set_defaults(desc->irq_data.chip);
         }
 
         return ret;
@@ -528,7 +528,7 @@ again:
 
         if (!(desc->status & IRQ_DISABLED) && (desc->status & IRQ_MASKED)) {
                 desc->status &= ~IRQ_MASKED;
-                desc->chip->unmask(irq);
+                desc->irq_data.chip->unmask(irq);
         }
         raw_spin_unlock_irq(&desc->lock);
         chip_bus_sync_unlock(irq, desc);
@@ -556,7 +556,7 @@ irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
         }
 
         raw_spin_lock_irq(&desc->lock);
-        cpumask_copy(mask, desc->affinity);
+        cpumask_copy(mask, desc->irq_data.affinity);
         raw_spin_unlock_irq(&desc->lock);
 
         set_cpus_allowed_ptr(current, mask);
@@ -657,7 +657,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
         if (!desc)
                 return -EINVAL;
 
-        if (desc->chip == &no_irq_chip)
+        if (desc->irq_data.chip == &no_irq_chip)
                 return -ENOSYS;
         /*
          * Some drivers like serial.c use request_irq() heavily,
@@ -752,7 +752,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
         }
 
         if (!shared) {
-                irq_chip_set_defaults(desc->chip);
+                irq_chip_set_defaults(desc->irq_data.chip);
 
                 init_waitqueue_head(&desc->wait_for_threads);
 
@@ -779,7 +779,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 if (!(desc->status & IRQ_NOAUTOEN)) {
                         desc->depth = 0;
                         desc->status &= ~IRQ_DISABLED;
-                        desc->chip->startup(irq);
+                        desc->irq_data.chip->startup(irq);
                 } else
                         /* Undo nested disables: */
                         desc->depth = 1;
@@ -912,17 +912,17 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
 
         /* Currently used only by UML, might disappear one day: */
 #ifdef CONFIG_IRQ_RELEASE_METHOD
-        if (desc->chip->release)
-                desc->chip->release(irq, dev_id);
+        if (desc->irq_data.chip->release)
+                desc->irq_data.chip->release(irq, dev_id);
 #endif
 
         /* If this was the last handler, shut down the IRQ line: */
         if (!desc->action) {
                 desc->status |= IRQ_DISABLED;
-                if (desc->chip->shutdown)
-                        desc->chip->shutdown(irq);
+                if (desc->irq_data.chip->shutdown)
+                        desc->irq_data.chip->shutdown(irq);
                 else
-                        desc->chip->disable(irq);
+                        desc->irq_data.chip->disable(irq);
         }
 
 #ifdef CONFIG_SMP
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index 241962280836..f923c37e651a 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -24,7 +24,7 @@ void move_masked_irq(int irq)
         if (unlikely(cpumask_empty(desc->pending_mask)))
                 return;
 
-        if (!desc->chip->set_affinity)
+        if (!desc->irq_data.chip->set_affinity)
                 return;
 
         assert_raw_spin_locked(&desc->lock);
@@ -43,8 +43,8 @@ void move_masked_irq(int irq)
          */
         if (likely(cpumask_any_and(desc->pending_mask, cpu_online_mask)
                    < nr_cpu_ids))
-                if (!desc->chip->set_affinity(irq, desc->pending_mask)) {
-                        cpumask_copy(desc->affinity, desc->pending_mask);
+                if (!desc->irq_data.chip->set_affinity(irq, desc->pending_mask)) {
+                        cpumask_copy(desc->irq_data.affinity, desc->pending_mask);
                         irq_set_thread_affinity(desc);
                 }
 
@@ -61,8 +61,8 @@ void move_native_irq(int irq)
         if (unlikely(desc->status & IRQ_DISABLED))
                 return;
 
-        desc->chip->mask(irq);
+        desc->irq_data.chip->mask(irq);
         move_masked_irq(irq);
-        desc->chip->unmask(irq);
+        desc->irq_data.chip->unmask(irq);
 }
 
diff --git a/kernel/irq/numa_migrate.c b/kernel/irq/numa_migrate.c
index 65d3845665ac..e7f1f16402c1 100644
--- a/kernel/irq/numa_migrate.c
+++ b/kernel/irq/numa_migrate.c
@@ -44,7 +44,7 @@ static bool init_copy_one_irq_desc(int irq, struct irq_desc *old_desc,
                 return false;
         }
         raw_spin_lock_init(&desc->lock);
-        desc->node = node;
+        desc->irq_data.node = node;
         lockdep_set_class(&desc->lock, &irq_desc_lock_class);
         init_copy_kstat_irqs(old_desc, desc, node, nr_cpu_ids);
         init_copy_desc_masks(old_desc, desc);
@@ -66,7 +66,7 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
         unsigned int irq;
         unsigned long flags;
 
-        irq = old_desc->irq;
+        irq = old_desc->irq_data.irq;
 
         raw_spin_lock_irqsave(&sparse_irq_lock, flags);
 
@@ -109,10 +109,10 @@ out_unlock:
 struct irq_desc *move_irq_desc(struct irq_desc *desc, int node)
 {
         /* those static or target node is -1, do not move them */
-        if (desc->irq < NR_IRQS_LEGACY || node == -1)
+        if (desc->irq_data.irq < NR_IRQS_LEGACY || node == -1)
                 return desc;
 
-        if (desc->node != node)
+        if (desc->irq_data.node != node)
                 desc = __real_move_irq_desc(desc, node);
 
         return desc;
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index 09a2ee540bd2..9b0da94b5b2b 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -21,7 +21,7 @@ static struct proc_dir_entry *root_irq_dir;
 static int irq_affinity_proc_show(struct seq_file *m, void *v)
 {
         struct irq_desc *desc = irq_to_desc((long)m->private);
-        const struct cpumask *mask = desc->affinity;
+        const struct cpumask *mask = desc->irq_data.affinity;
 
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         if (desc->status & IRQ_MOVE_PENDING)
@@ -65,7 +65,7 @@ static ssize_t irq_affinity_proc_write(struct file *file,
         cpumask_var_t new_value;
         int err;
 
-        if (!irq_to_desc(irq)->chip->set_affinity || no_irq_affinity ||
+        if (!irq_to_desc(irq)->irq_data.chip->set_affinity || no_irq_affinity ||
             irq_balancing_disabled(irq))
                 return -EIO;
 
@@ -185,7 +185,7 @@ static int irq_node_proc_show(struct seq_file *m, void *v)
 {
         struct irq_desc *desc = irq_to_desc((long) m->private);
 
-        seq_printf(m, "%d\n", desc->node);
+        seq_printf(m, "%d\n", desc->irq_data.node);
         return 0;
 }
 
@@ -269,7 +269,7 @@ void register_irq_proc(unsigned int irq, struct irq_desc *desc)
 {
         char name [MAX_NAMELEN];
 
-        if (!root_irq_dir || (desc->chip == &no_irq_chip) || desc->dir)
+        if (!root_irq_dir || (desc->irq_data.chip == &no_irq_chip) || desc->dir)
                 return;
 
         memset(name, 0, MAX_NAMELEN);
diff --git a/kernel/irq/resend.c b/kernel/irq/resend.c
index 090c3763f3a2..47c56a097928 100644
--- a/kernel/irq/resend.c
+++ b/kernel/irq/resend.c
@@ -60,7 +60,7 @@ void check_irq_resend(struct irq_desc *desc, unsigned int irq)
         /*
          * Make sure the interrupt is enabled, before resending it:
          */
-        desc->chip->enable(irq);
+        desc->irq_data.chip->enable(irq);
 
         /*
          * We do not resend level type interrupts. Level type
@@ -70,7 +70,8 @@ void check_irq_resend(struct irq_desc *desc, unsigned int irq)
         if ((status & (IRQ_LEVEL | IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
                 desc->status = (status & ~IRQ_PENDING) | IRQ_REPLAY;
 
-                if (!desc->chip->retrigger || !desc->chip->retrigger(irq)) {
+                if (!desc->irq_data.chip->retrigger ||
+                    !desc->irq_data.chip->retrigger(irq)) {
 #ifdef CONFIG_HARDIRQS_SW_RESEND
                         /* Set it pending and activate the softirq: */
                         set_bit(irq, irqs_resend);
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index 89fb90ae534f..36c2c9289e2b 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -78,8 +78,8 @@ static int try_one_irq(int irq, struct irq_desc *desc)
          * If we did actual work for the real IRQ line we must let the
          * IRQ controller clean up too
          */
-        if (work && desc->chip && desc->chip->end)
-                desc->chip->end(irq);
+        if (work && desc->irq_data.chip && desc->irq_data.chip->end)
+                desc->irq_data.chip->end(irq);
         raw_spin_unlock(&desc->lock);
 
         return ok;
@@ -254,7 +254,7 @@ void note_interrupt(unsigned int irq, struct irq_desc *desc,
                 printk(KERN_EMERG "Disabling IRQ #%d\n", irq);
                 desc->status |= IRQ_DISABLED | IRQ_SPURIOUS_DISABLED;
                 desc->depth++;
-                desc->chip->disable(irq);
+                desc->irq_data.chip->disable(irq);
 
                 mod_timer(&poll_spurious_irq_timer,
                           jiffies + POLL_SPURIOUS_IRQ_INTERVAL);