[S390] stp support.

Add support for clock synchronization with the server time protocol.

Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>

5 files changed, 582 insertions, 153 deletions

diff --git a/arch/s390/kernel/time.c b/arch/s390/kernel/time.c
index 7aec676fefd5..7418bebb547f 100644
--- a/arch/s390/kernel/time.c
+++ b/arch/s390/kernel/time.c
@@ -3,7 +3,7 @@
  *    Time of day based timer functions.
  *
  *  S390 version
- *    Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Copyright IBM Corp. 1999, 2008
  *    Author(s): Hartmut Penner (hp@de.ibm.com),
  *               Martin Schwidefsky (schwidefsky@de.ibm.com),
  *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
@@ -31,6 +31,7 @@
 #include <linux/notifier.h>
 #include <linux/clocksource.h>
 #include <linux/clockchips.h>
+#include <linux/bootmem.h>
 #include <asm/uaccess.h>
 #include <asm/delay.h>
 #include <asm/s390_ext.h>
@@ -162,7 +163,7 @@ void init_cpu_timer(void)
         /* Enable clock comparator timer interrupt. */
         __ctl_set_bit(0,11);
 
-        /* Always allow ETR external interrupts, even without an ETR. */
+        /* Always allow the timing alert external interrupt. */
         __ctl_set_bit(0, 4);
 }
 
@@ -170,8 +171,21 @@ static void clock_comparator_interrupt(__u16 code)
 {
 }
 
+static void etr_timing_alert(struct etr_irq_parm *);
+static void stp_timing_alert(struct stp_irq_parm *);
+
+static void timing_alert_interrupt(__u16 code)
+{
+        if (S390_lowcore.ext_params & 0x00c40000)
+                etr_timing_alert((struct etr_irq_parm *)
+                                 &S390_lowcore.ext_params);
+        if (S390_lowcore.ext_params & 0x00038000)
+                stp_timing_alert((struct stp_irq_parm *)
+                                 &S390_lowcore.ext_params);
+}
+
 static void etr_reset(void);
-static void etr_ext_handler(__u16);
+static void stp_reset(void);
 
 /*
  * Get the TOD clock running.
@@ -181,6 +195,7 @@ static u64 __init reset_tod_clock(void)
         u64 time;
 
         etr_reset();
+        stp_reset();
         if (store_clock(&time) == 0)
                 return time;
         /* TOD clock not running. Set the clock to Unix Epoch. */
@@ -231,8 +246,9 @@ void __init time_init(void)
         if (clocksource_register(&clocksource_tod) != 0)
                 panic("Could not register TOD clock source");
 
-        /* request the etr external interrupt */
-        if (register_early_external_interrupt(0x1406, etr_ext_handler,
+        /* request the timing alert external interrupt */
+        if (register_early_external_interrupt(0x1406,
+                                              timing_alert_interrupt,
                                               &ext_int_etr_cc) != 0)
                 panic("Couldn't request external interrupt 0x1406");
 
@@ -245,10 +261,112 @@ void __init time_init(void)
 }
 
 /*
+ * The time is "clock". old is what we think the time is.
+ * Adjust the value by a multiple of jiffies and add the delta to ntp.
+ * "delay" is an approximation how long the synchronization took. If
+ * the time correction is positive, then "delay" is subtracted from
+ * the time difference and only the remaining part is passed to ntp.
+ */
+static unsigned long long adjust_time(unsigned long long old,
+                                      unsigned long long clock,
+                                      unsigned long long delay)
+{
+        unsigned long long delta, ticks;
+        struct timex adjust;
+
+        if (clock > old) {
+                /* It is later than we thought. */
+                delta = ticks = clock - old;
+                delta = ticks = (delta < delay) ? 0 : delta - delay;
+                delta -= do_div(ticks, CLK_TICKS_PER_JIFFY);
+                adjust.offset = ticks * (1000000 / HZ);
+        } else {
+                /* It is earlier than we thought. */
+                delta = ticks = old - clock;
+                delta -= do_div(ticks, CLK_TICKS_PER_JIFFY);
+                delta = -delta;
+                adjust.offset = -ticks * (1000000 / HZ);
+        }
+        jiffies_timer_cc += delta;
+        if (adjust.offset != 0) {
+                printk(KERN_NOTICE "etr: time adjusted by %li micro-seconds\n",
+                       adjust.offset);
+                adjust.modes = ADJ_OFFSET_SINGLESHOT;
+                do_adjtimex(&adjust);
+        }
+        return delta;
+}
+
+static DEFINE_PER_CPU(atomic_t, clock_sync_word);
+static unsigned long clock_sync_flags;
+
+#define CLOCK_SYNC_HAS_ETR      0
+#define CLOCK_SYNC_HAS_STP      1
+#define CLOCK_SYNC_ETR          2
+#define CLOCK_SYNC_STP          3
+
+/*
+ * The synchronous get_clock function. It will write the current clock
+ * value to the clock pointer and return 0 if the clock is in sync with
+ * the external time source. If the clock mode is local it will return
+ * -ENOSYS and -EAGAIN if the clock is not in sync with the external
+ * reference.
+ */
+int get_sync_clock(unsigned long long *clock)
+{
+        atomic_t *sw_ptr;
+        unsigned int sw0, sw1;
+
+        sw_ptr = &get_cpu_var(clock_sync_word);
+        sw0 = atomic_read(sw_ptr);
+        *clock = get_clock();
+        sw1 = atomic_read(sw_ptr);
+        put_cpu_var(clock_sync_sync);
+        if (sw0 == sw1 && (sw0 & 0x80000000U))
+                /* Success: time is in sync. */
+                return 0;
+        if (!test_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags) &&
+            !test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
+                return -ENOSYS;
+        if (!test_bit(CLOCK_SYNC_ETR, &clock_sync_flags) &&
+            !test_bit(CLOCK_SYNC_STP, &clock_sync_flags))
+                return -EACCES;
+        return -EAGAIN;
+}
+EXPORT_SYMBOL(get_sync_clock);
+
+/*
+ * Make get_sync_clock return -EAGAIN.
+ */
+static void disable_sync_clock(void *dummy)
+{
+        atomic_t *sw_ptr = &__get_cpu_var(clock_sync_word);
+        /*
+         * Clear the in-sync bit 2^31. All get_sync_clock calls will
+         * fail until the sync bit is turned back on. In addition
+         * increase the "sequence" counter to avoid the race of an
+         * etr event and the complete recovery against get_sync_clock.
+         */
+        atomic_clear_mask(0x80000000, sw_ptr);
+        atomic_inc(sw_ptr);
+}
+
+/*
+ * Make get_sync_clock return 0 again.
+ * Needs to be called from a context disabled for preemption.
+ */
+static void enable_sync_clock(void)
+{
+        atomic_t *sw_ptr = &__get_cpu_var(clock_sync_word);
+        atomic_set_mask(0x80000000, sw_ptr);
+}
+
+/*
  * External Time Reference (ETR) code.