[PATCH] genirq: cleanup: misc code cleanups

Assorted code cleanups to the generic IRQ code.

Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

5 files changed, 66 insertions, 60 deletions

diff --git a/include/linux/irq.h b/include/linux/irq.h
index eac1273dc4e1..92c685414622 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -1,5 +1,5 @@
-#ifndef __irq_h
-#define __irq_h
+#ifndef _LINUX_IRQ_H
+#define _LINUX_IRQ_H
 
 /*
  * Please do not include this file in generic code.  There is currently
@@ -11,7 +11,7 @@
 
 #include <linux/smp.h>
 
-#if !defined(CONFIG_S390)
+#ifndef CONFIG_S390
 
 #include <linux/linkage.h>
 #include <linux/cache.h>
@@ -33,7 +33,7 @@
 #define IRQ_WAITING     32      /* IRQ not yet seen - for autodetection */
 #define IRQ_LEVEL       64      /* IRQ level triggered */
 #define IRQ_MASKED      128     /* IRQ masked - shouldn't be seen again */
-#if defined(ARCH_HAS_IRQ_PER_CPU)
+#ifdef ARCH_HAS_IRQ_PER_CPU
 # define IRQ_PER_CPU    256     /* IRQ is per CPU */
 # define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)
 #else
@@ -45,7 +45,7 @@
  * to describe about the low-level hardware. 
  */
 struct hw_interrupt_type {
-        const char * typename;
+        const char *typename;
         unsigned int (*startup)(unsigned int irq);
         void (*shutdown)(unsigned int irq);
         void (*enable)(unsigned int irq);
@@ -80,7 +80,7 @@ typedef struct irq_desc {
 #ifdef CONFIG_SMP
         cpumask_t affinity;
 #endif
-#if defined (CONFIG_GENERIC_PENDING_IRQ) || defined (CONFIG_IRQBALANCE)
+#if defined(CONFIG_GENERIC_PENDING_IRQ) || defined(CONFIG_IRQBALANCE)
         unsigned int move_irq;          /* Flag need to re-target intr dest*/
 #endif
 } ____cacheline_aligned irq_desc_t;
@@ -89,9 +89,10 @@ extern irq_desc_t irq_desc [NR_IRQS];
 
 #include <asm/hw_irq.h> /* the arch dependent stuff */
 
-extern int setup_irq(unsigned int irq, struct irqaction * new);
+extern int setup_irq(unsigned int irq, struct irqaction *new);
 
 #ifdef CONFIG_GENERIC_HARDIRQS
+
 #ifdef CONFIG_SMP
 static inline void set_native_irq_info(int irq, cpumask_t mask)
 {
@@ -105,7 +106,7 @@ static inline void set_native_irq_info(int irq, cpumask_t mask)
 
 #ifdef CONFIG_SMP
 
-#if defined (CONFIG_GENERIC_PENDING_IRQ) || defined (CONFIG_IRQBALANCE)
+#if defined(CONFIG_GENERIC_PENDING_IRQ) || defined(CONFIG_IRQBALANCE)
 extern cpumask_t pending_irq_cpumask[NR_IRQS];
 
 void set_pending_irq(unsigned int irq, cpumask_t mask);
@@ -127,7 +128,7 @@ static inline void set_irq_info(int irq, cpumask_t mask)
 {
 }
 
-#else // CONFIG_PCI_MSI
+#else /* CONFIG_PCI_MSI */
 
 static inline void move_irq(int irq)
 {
@@ -138,26 +139,36 @@ static inline void set_irq_info(int irq, cpumask_t mask)
 {
         set_native_irq_info(irq, mask);
 }
-#endif // CONFIG_PCI_MSI
 
-#else   // CONFIG_GENERIC_PENDING_IRQ || CONFIG_IRQBALANCE
+#endif /* CONFIG_PCI_MSI */
+
+#else /* CONFIG_GENERIC_PENDING_IRQ || CONFIG_IRQBALANCE */
+
+static inline void move_irq(int irq)
+{
+}
+
+static inline void move_native_irq(int irq)
+{
+}
+
+static inline void set_pending_irq(unsigned int irq, cpumask_t mask)
+{
+}
 
-#define move_irq(x)
-#define move_native_irq(x)
-#define set_pending_irq(x,y)
 static inline void set_irq_info(int irq, cpumask_t mask)
 {
         set_native_irq_info(irq, mask);
 }
 
-#endif // CONFIG_GENERIC_PENDING_IRQ
+#endif /* CONFIG_GENERIC_PENDING_IRQ */
 
-#else // CONFIG_SMP
+#else /* CONFIG_SMP */
 
 #define move_irq(x)
 #define move_native_irq(x)
 
-#endif // CONFIG_SMP
+#endif /* CONFIG_SMP */
 
 #ifdef CONFIG_IRQBALANCE
 extern void set_balance_irq_affinity(unsigned int irq, cpumask_t mask);
@@ -186,17 +197,16 @@ extern void init_irq_proc(void);
 #ifdef CONFIG_AUTO_IRQ_AFFINITY
 extern int select_smp_affinity(unsigned int irq);
 #else
-static inline int
-select_smp_affinity(unsigned int irq)
+static inline int select_smp_affinity(unsigned int irq)
 {
         return 1;
 }
 #endif
 
-#endif
+#endif /* CONFIG_GENERIC_HARDIRQS */
 
 extern hw_irq_controller no_irq_type;  /* needed in every arch ? */
 
-#endif
+#endif /* !CONFIG_S390 */
 
-#endif /* __irq_h */
+#endif /* _LINUX_IRQ_H */
diff --git a/kernel/irq/autoprobe.c b/kernel/irq/autoprobe.c
index d1f1e6f10a23..d6eab98a3173 100644
--- a/kernel/irq/autoprobe.c
+++ b/kernel/irq/autoprobe.c
@@ -27,7 +27,7 @@ static DEFINE_MUTEX(probing_active);
  */
 unsigned long probe_irq_on(void)
 {
-        unsigned long val;
+        unsigned long mask;
         irq_desc_t *desc;
         unsigned int i;
 
@@ -40,8 +40,8 @@ unsigned long probe_irq_on(void)
                 desc = irq_desc + i;
 
                 spin_lock_irq(&desc->lock);
-                if (!irq_desc[i].action)
-                        irq_desc[i].chip->startup(i);
+                if (!desc->action)
+                        desc->chip->startup(i);
                 spin_unlock_irq(&desc->lock);
         }
 
@@ -73,11 +73,11 @@ unsigned long probe_irq_on(void)
         /*
          * Now filter out any obviously spurious interrupts
          */
-        val = 0;
+        mask = 0;
         for (i = 0; i < NR_IRQS; i++) {
-                irq_desc_t *desc = irq_desc + i;
                 unsigned int status;
 
+                desc = irq_desc + i;
                 spin_lock_irq(&desc->lock);
                 status = desc->status;
 
@@ -88,14 +88,13 @@ unsigned long probe_irq_on(void)
                                 desc->chip->shutdown(i);
                         } else
                                 if (i < 32)
-                                        val |= 1 << i;
+                                        mask |= 1 << i;
                 }
                 spin_unlock_irq(&desc->lock);
         }
 
-        return val;
+        return mask;
 }
-
 EXPORT_SYMBOL(probe_irq_on);
 
 /**
@@ -184,6 +183,5 @@ int probe_irq_off(unsigned long val)
 
         return irq_found;
 }
-
 EXPORT_SYMBOL(probe_irq_off);
 
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 6b313ccf0edd..f9c33a86cbdf 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -18,7 +18,7 @@
  * Linux has a controller-independent interrupt architecture.
  * Every controller has a 'controller-template', that is used
  * by the main code to do the right thing. Each driver-visible
- * interrupt source is transparently wired to the apropriate
+ * interrupt source is transparently wired to the appropriate
  * controller. Thus drivers need not be aware of the
  * interrupt-controller.
  *
@@ -111,7 +111,7 @@ irqreturn_t handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
 fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs)
 {
         irq_desc_t *desc = irq_desc + irq;
-        struct irqaction * action;
+        struct irqaction *action;
         unsigned int status;
 
         kstat_this_cpu.irqs[irq]++;
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index c53662edc73d..261906ebdf04 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -40,7 +40,6 @@ void synchronize_irq(unsigned int irq)
         while (desc->status & IRQ_INPROGRESS)
                 cpu_relax();
 }
-
 EXPORT_SYMBOL(synchronize_irq);
 
 #endif
@@ -71,7 +70,6 @@ void disable_irq_nosync(unsigned int irq)
         }
         spin_unlock_irqrestore(&desc->lock, flags);
 }
-
 EXPORT_SYMBOL(disable_irq_nosync);
 
 /**
@@ -97,7 +95,6 @@ void disable_irq(unsigned int irq)
         if (desc->action)
                 synchronize_irq(irq);
 }
-
 EXPORT_SYMBOL(disable_irq);
 
 /**
@@ -139,7 +136,6 @@ void enable_irq(unsigned int irq)
         }
         spin_unlock_irqrestore(&desc->lock, flags);
 }
-
 EXPORT_SYMBOL(enable_irq);
 
 /*
@@ -166,7 +162,7 @@ int can_request_irq(unsigned int irq, unsigned long irqflags)
  * Internal function to register an irqaction - typically used to
  * allocate special interrupts that are part of the architecture.
  */
-int setup_irq(unsigned int irq, struct irqaction * new)
+int setup_irq(unsigned int irq, struct irqaction *new)
 {
         struct irq_desc *desc = irq_desc + irq;
         struct irqaction *old, **p;
@@ -198,9 +194,10 @@ int setup_irq(unsigned int irq, struct irqaction * new)
         /*
          * The following block of code has to be executed atomically
          */
-        spin_lock_irqsave(&desc->lock,flags);
+        spin_lock_irqsave(&desc->lock, flags);
         p = &desc->action;
-        if ((old = *p) != NULL) {
+        old = *p;
+        if (old) {
                 /* Can't share interrupts unless both agree to */
                 if (!(old->flags & new->flags & SA_SHIRQ))
                         goto mismatch;
@@ -233,7 +230,7 @@ int setup_irq(unsigned int irq, struct irqaction * new)
                 else
                         desc->chip->enable(irq);
         }
-        spin_unlock_irqrestore(&desc->lock,flags);
+        spin_unlock_irqrestore(&desc->lock, flags);
 
         new->irq = irq;
         register_irq_proc(irq);
@@ -276,10 +273,10 @@ void free_irq(unsigned int irq, void *dev_id)
                 return;
 
         desc = irq_desc + irq;
-        spin_lock_irqsave(&desc->lock,flags);
+        spin_lock_irqsave(&desc->lock, flags);
         p = &desc->action;
         for (;;) {
-                struct irqaction * action = *p;
+                struct irqaction *action = *p;
 
                 if (action) {
                         struct irqaction **pp = p;
@@ -304,7 +301,7 @@ void free_irq(unsigned int irq, void *dev_id)
                                 else
                                         desc->chip->disable(irq);
                         }
-                        spin_unlock_irqrestore(&desc->lock,flags);
+                        spin_unlock_irqrestore(&desc->lock, flags);
                         unregister_handler_proc(irq, action);
 
                         /* Make sure it's not being used on another CPU */
@@ -312,12 +309,11 @@ void free_irq(unsigned int irq, void *dev_id)
                         kfree(action);
                         return;
                 }
-                printk(KERN_ERR "Trying to free free IRQ%d\n",irq);
-                spin_unlock_irqrestore(&desc->lock,flags);
+                printk(KERN_ERR "Trying to free free IRQ%d\n", irq);
+                spin_unlock_irqrestore(&desc->lock, flags);
                 return;
         }
 }
-
 EXPORT_SYMBOL(free_irq);
 
 /**
@@ -351,9 +347,9 @@ EXPORT_SYMBOL(free_irq);
  */
 int request_irq(unsigned int irq,
                 irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                unsigned long irqflags, const char * devname, void *dev_id)
+                unsigned long irqflags, const char *devname, void *dev_id)
 {
-        struct irqaction * action;
+        struct irqaction *action;
         int retval;
 
         /*
@@ -388,6 +384,5 @@ int request_irq(unsigned int irq,
 
         return retval;
 }
-
 EXPORT_SYMBOL(request_irq);
 
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index ea3ceed362da..5eae7bf3c347 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -16,22 +16,20 @@ static int irqfixup __read_mostly;
 /*
  * Recovery handler for misrouted interrupts.
  */
-
 static int misrouted_irq(int irq, struct pt_regs *regs)
 {
         int i;
-        irq_desc_t *desc;
         int ok = 0;
         int work = 0;   /* Did we do work for a real IRQ */
 
-        for(i = 1; i < NR_IRQS; i++) {
+        for (i = 1; i < NR_IRQS; i++) {
+                struct irq_desc *desc = irq_desc + i;
                 struct irqaction *action;
 
                 if (i == irq)   /* Already tried */
                         continue;
-                desc = &irq_desc[i];
+
                 spin_lock(&desc->lock);
-                action = desc->action;
                 /* Already running on another processor */
                 if (desc->status & IRQ_INPROGRESS) {
                         /*
@@ -45,7 +43,9 @@ static int misrouted_irq(int irq, struct pt_regs *regs)
                 }
                 /* Honour the normal IRQ locking */
                 desc->status |= IRQ_INPROGRESS;
+                action = desc->action;
                 spin_unlock(&desc->lock);
+
                 while (action) {
                         /* Only shared IRQ handlers are safe to call */
                         if (action->flags & SA_SHIRQ) {
@@ -62,9 +62,8 @@ static int misrouted_irq(int irq, struct pt_regs *regs)
 
                 /*
                  * While we were looking for a fixup someone queued a real
-                 * IRQ clashing with our walk
+                 * IRQ clashing with our walk:
                  */
-
                 while ((desc->status & IRQ_PENDING) && action) {
                         /*
                          * Perform real IRQ processing for the IRQ we deferred
@@ -80,7 +79,7 @@ static int misrouted_irq(int irq, struct pt_regs *regs)
                  * If we did actual work for the real IRQ line we must let the
                  * IRQ controller clean up too
                  */
-                if(work)
+                if (work)
                         desc->chip->end(i);
                 spin_unlock(&desc->lock);
         }
@@ -113,6 +112,7 @@ __report_bad_irq(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret)
         }
         dump_stack();
         printk(KERN_ERR "handlers:\n");
+
         action = desc->action;
         while (action) {
                 printk(KERN_ERR "[<%p>]", action->handler);
@@ -123,7 +123,8 @@ __report_bad_irq(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret)
         }
 }
 
-static void report_bad_irq(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret)
+static void
+report_bad_irq(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret)
 {
         static int count = 100;
 
@@ -134,7 +135,7 @@ static void report_bad_irq(unsigned int irq, irq_desc_t *desc, irqreturn_t actio
 }
 
 void note_interrupt(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret,
-                        struct pt_regs *regs)
+                    struct pt_regs *regs)
 {
         if (unlikely(action_ret != IRQ_HANDLED)) {
                 desc->irqs_unhandled++;
@@ -177,6 +178,7 @@ int __init noirqdebug_setup(char *str)
 {
         noirqdebug = 1;
         printk(KERN_INFO "IRQ lockup detection disabled\n");
+
         return 1;
 }
 
@@ -187,6 +189,7 @@ static int __init irqfixup_setup(char *str)
         irqfixup = 1;
         printk(KERN_WARNING "Misrouted IRQ fixup support enabled.\n");
         printk(KERN_WARNING "This may impact system performance.\n");
+
         return 1;
 }