#ifndef _ASM_IRQ_H
 #define _ASM_IRQ_H
 
-#ifdef __KERNEL__
 #include <linux/hardirq.h>
 
-/*
- * the definition of irqs has changed in 2.5.46:
- * NR_IRQS is no longer the number of i/o
- * interrupts (65536), but rather the number
- * of interrupt classes (2).
- * Only external and i/o interrupts make much sense here (CH).
- */
-
 enum interruption_class {
        EXTERNAL_INTERRUPT,
        IO_INTERRUPT,
-
+       EXTINT_CLK,
+       EXTINT_IPI,
+       EXTINT_TMR,
+       EXTINT_TLA,
+       EXTINT_PFL,
+       EXTINT_DSD,
+       EXTINT_VRT,
+       EXTINT_SCP,
+       EXTINT_IUC,
+       NMI_NMI,
        NR_IRQS,
 };
 
-#endif /* __KERNEL__ */
-#endif
+#endif /* _ASM_IRQ_H */
 
 /*
- *  arch/s390/kernel/irq.c
- *
- *    Copyright IBM Corp. 2004,2007
+ *    Copyright IBM Corp. 2004,2010
  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
  *              Thomas Spatzier (tspat@de.ibm.com)
  *
 #include <linux/proc_fs.h>
 #include <linux/profile.h>
 
+struct irq_class {
+       char *name;
+       char *desc;
+};
+
+static const struct irq_class intrclass_names[] = {
+       {.name = "EXT" },
+       {.name = "I/O" },
+       {.name = "CLK", .desc = "[EXT] Clock Comparator" },
+       {.name = "IPI", .desc = "[EXT] Signal Processor" },
+       {.name = "TMR", .desc = "[EXT] CPU Timer" },
+       {.name = "TAL", .desc = "[EXT] Timing Alert" },
+       {.name = "PFL", .desc = "[EXT] Pseudo Page Fault" },
+       {.name = "DSD", .desc = "[EXT] DASD Diag" },
+       {.name = "VRT", .desc = "[EXT] Virtio" },
+       {.name = "SCP", .desc = "[EXT] Service Call" },
+       {.name = "IUC", .desc = "[EXT] IUCV" },
+       {.name = "NMI", .desc = "[NMI] Machine Check" },
+};
+
 /*
  * show_interrupts is needed by /proc/interrupts.
  */
 int show_interrupts(struct seq_file *p, void *v)
 {
-       static const char *intrclass_names[] = { "EXT", "I/O", };
        int i = *(loff_t *) v, j;
 
        get_online_cpus();
        }
 
        if (i < NR_IRQS) {
-               seq_printf(p, "%s: ", intrclass_names[i]);
+               seq_printf(p, "%s: ", intrclass_names[i].name);
 #ifndef CONFIG_SMP
                seq_printf(p, "%10u ", kstat_irqs(i));
 #else
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
+               if (intrclass_names[i].desc)
+                       seq_printf(p, "  %s", intrclass_names[i].desc);
                 seq_putc(p, '\n');
-
         }
        put_online_cpus();
         return 0;
 
  *              Heiko Carstens <heiko.carstens@de.ibm.com>,
  */
 
+#include <linux/kernel_stat.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/hardirq.h>
        nmi_enter();
        s390_idle_check(regs, S390_lowcore.mcck_clock,
                        S390_lowcore.mcck_enter_timer);
-
+       kstat_cpu(smp_processor_id()).irqs[NMI_NMI]++;
        mci = (struct mci *) &S390_lowcore.mcck_interruption_code;
        mcck = &__get_cpu_var(cpu_mcck);
        umode = user_mode(regs);
 
 {
        unsigned long bits;
 
+       kstat_cpu(smp_processor_id()).irqs[EXTINT_IPI]++;
        /*
         * handle bit signal external calls
         *
 
 #define KMSG_COMPONENT "time"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/kernel_stat.h>
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/sched.h>
                                       unsigned int param32,
                                       unsigned long param64)
 {
+       kstat_cpu(smp_processor_id()).irqs[EXTINT_CLK]++;
        if (S390_lowcore.clock_comparator == -1ULL)
                set_clock_comparator(S390_lowcore.clock_comparator);
 }
 static void timing_alert_interrupt(unsigned int ext_int_code,
                                   unsigned int param32, unsigned long param64)
 {
+       kstat_cpu(smp_processor_id()).irqs[EXTINT_TLA]++;
        if (param32 & 0x00c40000)
                etr_timing_alert((struct etr_irq_parm *) ¶m32);
        if (param32 & 0x00038000)
 
        struct list_head cb_list;       /* the callback queue */
        __u64 elapsed, next;
 
+       kstat_cpu(smp_processor_id()).irqs[EXTINT_TMR]++;
        INIT_LIST_HEAD(&cb_list);
        vq = &__get_cpu_var(virt_cpu_timer);
 
 
  *    Copyright (C) 1995  Linus Torvalds
  */
 
+#include <linux/kernel_stat.h>
 #include <linux/perf_event.h>
 #include <linux/signal.h>
 #include <linux/sched.h>
        struct task_struct *tsk;
        __u16 subcode;
 
+       kstat_cpu(smp_processor_id()).irqs[EXTINT_PFL]++;
        /*
         * Get the external interruption subcode & pfault
         * initial/completion signal bit. VM stores this 
 
 
 #define KMSG_COMPONENT "dasd"
 
+#include <linux/kernel_stat.h>
 #include <linux/stddef.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
        addr_t ip;
        int rc;
 
+       kstat_cpu(smp_processor_id()).irqs[EXTINT_DSD]++;
        switch (ext_int_code >> 24) {
        case DASD_DIAG_CODE_31BIT:
                ip = (addr_t) param32;
 
  *           Martin Schwidefsky <schwidefsky@de.ibm.com>
  */
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/spinlock.h>
 #include <linux/suspend.h>
 #include <linux/completion.h>
 #include <linux/platform_device.h>
-#include <asm/types.h>
 #include <asm/s390_ext.h>
+#include <asm/types.h>
+#include <asm/irq.h>
 
 #include "sclp.h"
 
        u32 finished_sccb;
        u32 evbuf_pending;
 
+       kstat_cpu(smp_processor_id()).irqs[EXTINT_SCP]++;
        spin_lock(&sclp_lock);
        finished_sccb = param32 & 0xfffffff8;
        evbuf_pending = param32 & 0x3;
 {
        u32 finished_sccb;
 
+       kstat_cpu(smp_processor_id()).irqs[EXTINT_SCP]++;
        finished_sccb = param32 & 0xfffffff8;
        /* Is this the interrupt we are waiting for? */
        if (finished_sccb == 0)
 
  *    Author(s): Christian Borntraeger <borntraeger@de.ibm.com>
  */
 
+#include <linux/kernel_stat.h>
 #include <linux/init.h>
 #include <linux/bootmem.h>
 #include <linux/err.h>
 #include <asm/kvm_virtio.h>
 #include <asm/setup.h>
 #include <asm/s390_ext.h>
+#include <asm/irq.h>
 
 #define VIRTIO_SUBCODE_64 0x0D00
 
        u16 subcode;
        u32 param;
 
+       kstat_cpu(smp_processor_id()).irqs[EXTINT_VRT]++;
        subcode = ext_int_code >> 16;
        if ((subcode & 0xff00) != VIRTIO_SUBCODE_64)
                return;
 
 #define KMSG_COMPONENT "iucv"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/spinlock.h>
        struct iucv_irq_data *p;
        struct iucv_irq_list *work;
 
+       kstat_cpu(smp_processor_id()).irqs[EXTINT_IUC]++;
        p = iucv_irq_data[smp_processor_id()];
        if (p->ippathid >= iucv_max_pathid) {
                WARN_ON(p->ippathid >= iucv_max_pathid);