1 files changed, 18 insertions, 21 deletions

diff --git a/drivers/s390/char/sclp.c b/drivers/s390/char/sclp.c
index f6d72e1f2a38..eaa7e78186f9 100644
--- a/drivers/s390/char/sclp.c
+++ b/drivers/s390/char/sclp.c
@@ -7,6 +7,7 @@
  *            Martin Schwidefsky <schwidefsky@de.ibm.com>
  */
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/spinlock.h>
@@ -19,15 +20,12 @@
 #include <linux/completion.h>
 #include <linux/platform_device.h>
 #include <asm/types.h>
-#include <asm/s390_ext.h>
+#include <asm/irq.h>
 
 #include "sclp.h"
 
 #define SCLP_HEADER             "sclp: "
 
-/* Structure for register_early_external_interrupt. */
-static ext_int_info_t ext_int_info_hwc;
-
 /* Lock to protect internal data consistency. */
 static DEFINE_SPINLOCK(sclp_lock);
 
@@ -395,16 +393,17 @@ __sclp_find_req(u32 sccb)
 /* Handler for external interruption. Perform request post-processing.
  * Prepare read event data request if necessary. Start processing of next
  * request on queue. */
-static void
-sclp_interrupt_handler(__u16 code)
+static void sclp_interrupt_handler(unsigned int ext_int_code,
+                                   unsigned int param32, unsigned long param64)
 {
         struct sclp_req *req;
         u32 finished_sccb;
         u32 evbuf_pending;
 
+        kstat_cpu(smp_processor_id()).irqs[EXTINT_SCP]++;
         spin_lock(&sclp_lock);
-        finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
-        evbuf_pending = S390_lowcore.ext_params & 0x3;
+        finished_sccb = param32 & 0xfffffff8;
+        evbuf_pending = param32 & 0x3;
         if (finished_sccb) {
                 del_timer(&sclp_request_timer);
                 sclp_running_state = sclp_running_state_reset_pending;
@@ -468,7 +467,7 @@ sclp_sync_wait(void)
         cr0_sync &= 0xffff00a0;
         cr0_sync |= 0x00000200;
         __ctl_load(cr0_sync, 0, 0);
-        __raw_local_irq_stosm(0x01);
+        __arch_local_irq_stosm(0x01);
         /* Loop until driver state indicates finished request */
         while (sclp_running_state != sclp_running_state_idle) {
                 /* Check for expired request timer */
@@ -819,12 +818,13 @@ EXPORT_SYMBOL(sclp_reactivate);
 
 /* Handler for external interruption used during initialization. Modify
  * request state to done. */
-static void
-sclp_check_handler(__u16 code)
+static void sclp_check_handler(unsigned int ext_int_code,
+                               unsigned int param32, unsigned long param64)
 {
         u32 finished_sccb;
 
-        finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
+        kstat_cpu(smp_processor_id()).irqs[EXTINT_SCP]++;
+        finished_sccb = param32 & 0xfffffff8;
         /* Is this the interrupt we are waiting for? */
         if (finished_sccb == 0)
                 return;
@@ -866,8 +866,7 @@ sclp_check_interface(void)
 
         spin_lock_irqsave(&sclp_lock, flags);
         /* Prepare init mask command */
-        rc = register_early_external_interrupt(0x2401, sclp_check_handler,
-                                               &ext_int_info_hwc);
+        rc = register_external_interrupt(0x2401, sclp_check_handler);
         if (rc) {
                 spin_unlock_irqrestore(&sclp_lock, flags);
                 return rc;
@@ -885,12 +884,12 @@ sclp_check_interface(void)
                 spin_unlock_irqrestore(&sclp_lock, flags);
                 /* Enable service-signal interruption - needs to happen
                  * with IRQs enabled. */
-                ctl_set_bit(0, 9);
+                service_subclass_irq_register();
                 /* Wait for signal from interrupt or timeout */
                 sclp_sync_wait();
                 /* Disable service-signal interruption - needs to happen
                  * with IRQs enabled. */
-                ctl_clear_bit(0,9);
+                service_subclass_irq_unregister();
                 spin_lock_irqsave(&sclp_lock, flags);
                 del_timer(&sclp_request_timer);
                 if (sclp_init_req.status == SCLP_REQ_DONE &&
@@ -900,8 +899,7 @@ sclp_check_interface(void)
                 } else
                         rc = -EBUSY;
         }
-        unregister_early_external_interrupt(0x2401, sclp_check_handler,
-                                            &ext_int_info_hwc);
+        unregister_external_interrupt(0x2401, sclp_check_handler);
         spin_unlock_irqrestore(&sclp_lock, flags);
         return rc;
 }
@@ -1064,15 +1062,14 @@ sclp_init(void)
         if (rc)
                 goto fail_init_state_uninitialized;
         /* Register interrupt handler */
-        rc = register_early_external_interrupt(0x2401, sclp_interrupt_handler,
-                                               &ext_int_info_hwc);
+        rc = register_external_interrupt(0x2401, sclp_interrupt_handler);
         if (rc)
                 goto fail_unregister_reboot_notifier;
         sclp_init_state = sclp_init_state_initialized;
         spin_unlock_irqrestore(&sclp_lock, flags);
         /* Enable service-signal external interruption - needs to happen with
          * IRQs enabled. */
-        ctl_set_bit(0, 9);
+        service_subclass_irq_register();
         sclp_init_mask(1);
         return 0;