s390: convert interrupt handling to use generic hardirq

With the introduction of PCI it became apparent that s390 should
convert to generic hardirqs as too many drivers do not have the
correct dependency for GENERIC_HARDIRQS. On the architecture
level s390 does not have irq lines. It has external interrupts,
I/O interrupts and adapter interrupts. This patch hard-codes all
external interrupts as irq #1, all I/O interrupts as irq #2 and
all adapter interrupts as irq #3. The additional information from
the lowcore associated with the interrupt is stored in the
pt_regs of the interrupt frame, where the interrupt handler can
pick it up. For PCI/MSI interrupts the adapter interrupt handler
scans the relevant bit fields and calls generic_handle_irq with
the virtual irq number for the MSI interrupt.

Reviewed-by: Sebastian Ott <sebott@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

3 files changed, 75 insertions, 106 deletions

diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S
index be7a408be7a1..5ca70b4b72cb 100644
--- a/arch/s390/kernel/entry.S
+++ b/arch/s390/kernel/entry.S
@@ -18,6 +18,7 @@
 #include <asm/unistd.h>
 #include <asm/page.h>
 #include <asm/sigp.h>
+#include <asm/irq.h>
 
 __PT_R0      =  __PT_GPRS
 __PT_R1      =  __PT_GPRS + 4
@@ -435,6 +436,11 @@ io_skip:
 io_loop:
         l       %r1,BASED(.Ldo_IRQ)
         lr      %r2,%r11                # pass pointer to pt_regs
+        lhi     %r3,IO_INTERRUPT
+        tm      __PT_INT_CODE+8(%r11),0x80      # adapter interrupt ?
+        jz      io_call
+        lhi     %r3,THIN_INTERRUPT
+io_call:
         basr    %r14,%r1                # call do_IRQ
         tm      __LC_MACHINE_FLAGS+2,0x10       # MACHINE_FLAG_LPAR
         jz      io_return
@@ -584,9 +590,10 @@ ext_skip:
         mvc     __PT_INT_CODE(4,%r11),__LC_EXT_CPU_ADDR
         mvc     __PT_INT_PARM(4,%r11),__LC_EXT_PARAMS
         TRACE_IRQS_OFF
+        l       %r1,BASED(.Ldo_IRQ)
         lr      %r2,%r11                # pass pointer to pt_regs
-        l       %r1,BASED(.Ldo_extint)
-        basr    %r14,%r1                # call do_extint
+        lhi     %r3,EXT_INTERRUPT
+        basr    %r14,%r1                # call do_IRQ
         j       io_return
 
 /*
@@ -902,7 +909,6 @@ cleanup_idle_wait:
 .Ldo_machine_check:     .long   s390_do_machine_check
 .Lhandle_mcck:          .long   s390_handle_mcck
 .Ldo_IRQ:               .long   do_IRQ
-.Ldo_extint:            .long   do_extint
 .Ldo_signal:            .long   do_signal
 .Ldo_notify_resume:     .long   do_notify_resume
 .Ldo_per_trap:          .long   do_per_trap
diff --git a/arch/s390/kernel/entry64.S b/arch/s390/kernel/entry64.S
index 1c039d0c24c7..980c7aa1cc5c 100644
--- a/arch/s390/kernel/entry64.S
+++ b/arch/s390/kernel/entry64.S
@@ -19,6 +19,7 @@
 #include <asm/unistd.h>
 #include <asm/page.h>
 #include <asm/sigp.h>
+#include <asm/irq.h>
 
 __PT_R0      =  __PT_GPRS
 __PT_R1      =  __PT_GPRS + 8
@@ -468,6 +469,11 @@ io_skip:
         xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
 io_loop:
         lgr     %r2,%r11                # pass pointer to pt_regs
+        lghi    %r3,IO_INTERRUPT
+        tm      __PT_INT_CODE+8(%r11),0x80      # adapter interrupt ?
+        jz      io_call
+        lghi    %r3,THIN_INTERRUPT
+io_call:
         brasl   %r14,do_IRQ
         tm      __LC_MACHINE_FLAGS+6,0x10       # MACHINE_FLAG_LPAR
         jz      io_return
@@ -623,7 +629,8 @@ ext_skip:
         TRACE_IRQS_OFF
         xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
         lgr     %r2,%r11                # pass pointer to pt_regs
-        brasl   %r14,do_extint
+        lghi    %r3,EXT_INTERRUPT
+        brasl   %r14,do_IRQ
         j       io_return
 
 /*
diff --git a/arch/s390/kernel/irq.c b/arch/s390/kernel/irq.c
index 54b0995514e8..b34ba0ea96a9 100644
--- a/arch/s390/kernel/irq.c
+++ b/arch/s390/kernel/irq.c
@@ -22,6 +22,7 @@
 #include <asm/cputime.h>
 #include <asm/lowcore.h>
 #include <asm/irq.h>
+#include <asm/hw_irq.h>
 #include "entry.h"
 
 DEFINE_PER_CPU_SHARED_ALIGNED(struct irq_stat, irq_stat);
@@ -42,9 +43,10 @@ struct irq_class {
  * Since the external and I/O interrupt fields are already sums we would end
  * up with having a sum which accounts each interrupt twice.
  */
-static const struct irq_class irqclass_main_desc[NR_IRQS] = {
-        [EXTERNAL_INTERRUPT] = {.name = "EXT"},
-        [IO_INTERRUPT]       = {.name = "I/O"}
+static const struct irq_class irqclass_main_desc[NR_IRQS_BASE] = {
+        [EXT_INTERRUPT]  = {.name = "EXT"},
+        [IO_INTERRUPT]   = {.name = "I/O"},
+        [THIN_INTERRUPT] = {.name = "AIO"},
 };
 
 /*
@@ -86,6 +88,28 @@ static const struct irq_class irqclass_sub_desc[NR_ARCH_IRQS] = {
         [CPU_RST]    = {.name = "RST", .desc = "[CPU] CPU Restart"},
 };
 
+void __init init_IRQ(void)
+{
+        irq_reserve_irqs(0, THIN_INTERRUPT);
+        init_cio_interrupts();
+        init_airq_interrupts();
+        init_ext_interrupts();
+}
+
+void do_IRQ(struct pt_regs *regs, int irq)
+{
+        struct pt_regs *old_regs;
+
+        old_regs = set_irq_regs(regs);
+        irq_enter();
+        if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
+                /* Serve timer interrupts first. */
+                clock_comparator_work();
+        generic_handle_irq(irq);
+        irq_exit();
+        set_irq_regs(old_regs);
+}
+
 /*
  * show_interrupts is needed by /proc/interrupts.
  */
@@ -100,27 +124,36 @@ int show_interrupts(struct seq_file *p, void *v)
                 for_each_online_cpu(cpu)
                         seq_printf(p, "CPU%d       ", cpu);
                 seq_putc(p, '\n');
+                goto out;
         }
         if (irq < NR_IRQS) {
+                if (irq >= NR_IRQS_BASE)
+                        goto out;
                 seq_printf(p, "%s: ", irqclass_main_desc[irq].name);
                 for_each_online_cpu(cpu)
-                        seq_printf(p, "%10u ", kstat_cpu(cpu).irqs[irq]);
+                        seq_printf(p, "%10u ", kstat_irqs_cpu(irq, cpu));
                 seq_putc(p, '\n');
-                goto skip_arch_irqs;
+                goto out;
         }
         for (irq = 0; irq < NR_ARCH_IRQS; irq++) {
                 seq_printf(p, "%s: ", irqclass_sub_desc[irq].name);
                 for_each_online_cpu(cpu)
-                        seq_printf(p, "%10u ", per_cpu(irq_stat, cpu).irqs[irq]);
+                        seq_printf(p, "%10u ",
+                                   per_cpu(irq_stat, cpu).irqs[irq]);
                 if (irqclass_sub_desc[irq].desc)
                         seq_printf(p, "  %s", irqclass_sub_desc[irq].desc);
                 seq_putc(p, '\n');
         }
-skip_arch_irqs:
+out:
         put_online_cpus();
         return 0;
 }
 
+int arch_show_interrupts(struct seq_file *p, int prec)
+{
+        return 0;
+}
+
 /*
  * Switch to the asynchronous interrupt stack for softirq execution.
  */
@@ -159,14 +192,6 @@ asmlinkage void do_softirq(void)
         local_irq_restore(flags);
 }
 
-#ifdef CONFIG_PROC_FS
-void init_irq_proc(void)
-{
-        if (proc_mkdir("irq", NULL))
-                create_prof_cpu_mask();
-}
-#endif
-
 /*
  * ext_int_hash[index] is the list head for all external interrupts that hash
  * to this index.
@@ -183,14 +208,6 @@ struct ext_int_info {
 /* ext_int_hash_lock protects the handler lists for external interrupts */
 DEFINE_SPINLOCK(ext_int_hash_lock);
 
-static void __init init_external_interrupts(void)
-{
-        int idx;
-
-        for (idx = 0; idx < ARRAY_SIZE(ext_int_hash); idx++)
-                INIT_LIST_HEAD(&ext_int_hash[idx]);
-}
-
 static inline int ext_hash(u16 code)
 {
         return (code + (code >> 9)) & 0xff;
@@ -234,20 +251,13 @@ int unregister_external_interrupt(u16 code, ext_int_handler_t handler)
 }
 EXPORT_SYMBOL(unregister_external_interrupt);
 
-void __irq_entry do_extint(struct pt_regs *regs)
+static irqreturn_t do_ext_interrupt(int irq, void *dummy)
 {
+        struct pt_regs *regs = get_irq_regs();
         struct ext_code ext_code;
-        struct pt_regs *old_regs;
         struct ext_int_info *p;
         int index;
 
-        old_regs = set_irq_regs(regs);
-        irq_enter();
-        if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator) {
-                /* Serve timer interrupts first. */
-                clock_comparator_work();
-        }
-        kstat_incr_irqs_this_cpu(EXTERNAL_INTERRUPT, NULL);
         ext_code = *(struct ext_code *) &regs->int_code;
         if (ext_code.code != 0x1004)
                 __get_cpu_var(s390_idle).nohz_delay = 1;
@@ -259,13 +269,25 @@ void __irq_entry do_extint(struct pt_regs *regs)
                         p->handler(ext_code, regs->int_parm,
                                    regs->int_parm_long);
         rcu_read_unlock();
-        irq_exit();
-        set_irq_regs(old_regs);
+
+        return IRQ_HANDLED;
 }
 
-void __init init_IRQ(void)
+static struct irqaction external_interrupt = {
+        .name    = "EXT",
+        .handler = do_ext_interrupt,
+};
+
+void __init init_ext_interrupts(void)
 {
-        init_external_interrupts();
+        int idx;
+
+        for (idx = 0; idx < ARRAY_SIZE(ext_int_hash); idx++)
+                INIT_LIST_HEAD(&ext_int_hash[idx]);
+
+        irq_set_chip_and_handler(EXT_INTERRUPT,
+                                 &dummy_irq_chip, handle_percpu_irq);
+        setup_irq(EXT_INTERRUPT, &external_interrupt);
 }
 
 static DEFINE_SPINLOCK(sc_irq_lock);
@@ -313,69 +335,3 @@ void measurement_alert_subclass_unregister(void)
         spin_unlock(&ma_subclass_lock);
 }
 EXPORT_SYMBOL(measurement_alert_subclass_unregister);
-
-#ifdef CONFIG_SMP
-void synchronize_irq(unsigned int irq)
-{
-        /*
-         * Not needed, the handler is protected by a lock and IRQs that occur
-         * after the handler is deleted are just NOPs.
-         */
-}
-EXPORT_SYMBOL_GPL(synchronize_irq);
-#endif
-
-#ifndef CONFIG_PCI
-
-/* Only PCI devices have dynamically-defined IRQ handlers */
-
-int request_irq(unsigned int irq, irq_handler_t handler,
-                unsigned long irqflags, const char *devname, void *dev_id)
-{
-        return -EINVAL;
-}
-EXPORT_SYMBOL_GPL(request_irq);
-
-void free_irq(unsigned int irq, void *dev_id)
-{
-        WARN_ON(1);
-}
-EXPORT_SYMBOL_GPL(free_irq);
-
-void enable_irq(unsigned int irq)
-{
-        WARN_ON(1);
-}
-EXPORT_SYMBOL_GPL(enable_irq);
-
-void disable_irq(unsigned int irq)
-{
-        WARN_ON(1);
-}
-EXPORT_SYMBOL_GPL(disable_irq);
-
-#endif /* !CONFIG_PCI */
-
-void disable_irq_nosync(unsigned int irq)
-{
-        disable_irq(irq);
-}
-EXPORT_SYMBOL_GPL(disable_irq_nosync);
-
-unsigned long probe_irq_on(void)
-{
-        return 0;
-}
-EXPORT_SYMBOL_GPL(probe_irq_on);
-
-int probe_irq_off(unsigned long val)
-{
-        return 0;
-}
-EXPORT_SYMBOL_GPL(probe_irq_off);
-
-unsigned int probe_irq_mask(unsigned long val)
-{
-        return val;
-}
-EXPORT_SYMBOL_GPL(probe_irq_mask);