clocksource: pass clocksource to read() callback
[linux-2.6.git] / arch / s390 / kernel / time.c
index b73bbf3..ef596d0 100644 (file)
@@ -12,6 +12,9 @@
  *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
  */
 
+#define KMSG_COMPONENT "time"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/sched.h>
@@ -20,6 +23,8 @@
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/interrupt.h>
+#include <linux/cpu.h>
+#include <linux/stop_machine.h>
 #include <linux/time.h>
 #include <linux/sysdev.h>
 #include <linux/delay.h>
@@ -47,9 +52,6 @@
 #define USECS_PER_JIFFY     ((unsigned long) 1000000/HZ)
 #define CLK_TICKS_PER_JIFFY ((unsigned long) USECS_PER_JIFFY << 12)
 
-/* The value of the TOD clock for 1.1.1970. */
-#define TOD_UNIX_EPOCH 0x7d91048bca000000ULL
-
 /*
  * Create a small time difference between the timer interrupts
  * on the different cpus to avoid lock contention.
 
 #define TICK_SIZE tick
 
+u64 sched_clock_base_cc = -1;  /* Force to data section. */
+
 static ext_int_info_t ext_int_info_cc;
 static ext_int_info_t ext_int_etr_cc;
-static u64 sched_clock_base_cc;
 
 static DEFINE_PER_CPU(struct clock_event_device, comparators);
 
@@ -155,7 +158,7 @@ void init_cpu_timer(void)
        cd->min_delta_ns        = 1;
        cd->max_delta_ns        = LONG_MAX;
        cd->rating              = 400;
-       cd->cpumask             = cpumask_of_cpu(cpu);
+       cd->cpumask             = cpumask_of(cpu);
        cd->set_next_event      = s390_next_event;
        cd->set_mode            = s390_set_mode;
 
@@ -190,25 +193,15 @@ static void timing_alert_interrupt(__u16 code)
 static void etr_reset(void);
 static void stp_reset(void);
 
-/*
- * Get the TOD clock running.
- */
-static u64 __init reset_tod_clock(void)
+unsigned long read_persistent_clock(void)
 {
-       u64 time;
+       struct timespec ts;
 
-       etr_reset();
-       stp_reset();
-       if (store_clock(&time) == 0)
-               return time;
-       /* TOD clock not running. Set the clock to Unix Epoch. */
-       if (set_clock(TOD_UNIX_EPOCH) != 0 || store_clock(&time) != 0)
-               panic("TOD clock not operational.");
-
-       return TOD_UNIX_EPOCH;
+       tod_to_timeval(get_clock() - TOD_UNIX_EPOCH, &ts);
+       return ts.tv_sec;
 }
 
-static cycle_t read_tod_clock(void)
+static cycle_t read_tod_clock(struct clocksource *cs)
 {
        return get_clock();
 }
@@ -260,12 +253,13 @@ void update_vsyscall_tz(void)
  */
 void __init time_init(void)
 {
-       sched_clock_base_cc = reset_tod_clock();
+       struct timespec ts;
+       unsigned long flags;
+       cycle_t now;
 
-       /* set xtime */
-       tod_to_timeval(sched_clock_base_cc - TOD_UNIX_EPOCH, &xtime);
-        set_normalized_timespec(&wall_to_monotonic,
-                                -xtime.tv_sec, -xtime.tv_nsec);
+       /* Reset time synchronization interfaces. */
+       etr_reset();
+       stp_reset();
 
        /* request the clock comparator external interrupt */
        if (register_early_external_interrupt(0x1004,
@@ -273,21 +267,40 @@ void __init time_init(void)
                                              &ext_int_info_cc) != 0)
                 panic("Couldn't request external interrupt 0x1004");
 
-       if (clocksource_register(&clocksource_tod) != 0)
-               panic("Could not register TOD clock source");
-
        /* 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");
 
+       if (clocksource_register(&clocksource_tod) != 0)
+               panic("Could not register TOD clock source");
+
+       /*
+        * The TOD clock is an accurate clock. The xtime should be
+        * initialized in a way that the difference between TOD and
+        * xtime is reasonably small. Too bad that timekeeping_init
+        * sets xtime.tv_nsec to zero. In addition the clock source
+        * change from the jiffies clock source to the TOD clock
+        * source add another error of up to 1/HZ second. The same
+        * function sets wall_to_monotonic to a value that is too
+        * small for /proc/uptime to be accurate.
+        * Reset xtime and wall_to_monotonic to sane values.
+        */
+       write_seqlock_irqsave(&xtime_lock, flags);
+       now = get_clock();
+       tod_to_timeval(now - TOD_UNIX_EPOCH, &xtime);
+       clocksource_tod.cycle_last = now;
+       clocksource_tod.raw_time = xtime;
+       tod_to_timeval(sched_clock_base_cc - TOD_UNIX_EPOCH, &ts);
+       set_normalized_timespec(&wall_to_monotonic, -ts.tv_sec, -ts.tv_nsec);
+       write_sequnlock_irqrestore(&xtime_lock, flags);
+
        /* Enable TOD clock interrupts on the boot cpu. */
        init_cpu_timer();
 
-#ifdef CONFIG_VIRT_TIMER
+       /* Enable cpu timer interrupts on the boot cpu. */
        vtime_init();
-#endif
 }
 
 /*
@@ -319,8 +332,8 @@ static unsigned long long adjust_time(unsigned long long old,
        }
        sched_clock_base_cc += delta;
        if (adjust.offset != 0) {
-               printk(KERN_NOTICE "etr: time adjusted by %li micro-seconds\n",
-                      adjust.offset);
+               pr_notice("The ETR interface has adjusted the clock "
+                         "by %li microseconds\n", adjust.offset);
                adjust.modes = ADJ_OFFSET_SINGLESHOT;
                do_adjtimex(&adjust);
        }
@@ -328,6 +341,7 @@ static unsigned long long adjust_time(unsigned long long old,
 }
 
 static DEFINE_PER_CPU(atomic_t, clock_sync_word);
+static DEFINE_MUTEX(clock_sync_mutex);
 static unsigned long clock_sync_flags;
 
 #define CLOCK_SYNC_HAS_ETR     0
@@ -392,6 +406,31 @@ static void enable_sync_clock(void)
 }
 
 /*
+ * Function to check if the clock is in sync.
+ */
+static inline int check_sync_clock(void)
+{
+       atomic_t *sw_ptr;
+       int rc;
+
+       sw_ptr = &get_cpu_var(clock_sync_word);
+       rc = (atomic_read(sw_ptr) & 0x80000000U) != 0;
+       put_cpu_var(clock_sync_sync);
+       return rc;
+}
+
+/* Single threaded workqueue used for etr and stp sync events */
+static struct workqueue_struct *time_sync_wq;
+
+static void __init time_init_wq(void)
+{
+       if (time_sync_wq)
+               return;
+       time_sync_wq = create_singlethread_workqueue("timesync");
+       stop_machine_create();
+}
+
+/*
  * External Time Reference (ETR) code.
  */
 static int etr_port0_online;
@@ -456,6 +495,7 @@ static struct timer_list etr_timer;
 
 static void etr_timeout(unsigned long dummy);
 static void etr_work_fn(struct work_struct *work);
+static DEFINE_MUTEX(etr_work_mutex);
 static DECLARE_WORK(etr_work, etr_work_fn);
 
 /*
@@ -470,9 +510,11 @@ static void etr_reset(void)
        if (etr_setr(&etr_eacr) == 0) {
                etr_tolec = get_clock();
                set_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags);
+               if (etr_port0_online && etr_port1_online)
+                       set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
        } else if (etr_port0_online || etr_port1_online) {
-               printk(KERN_WARNING "Running on non ETR capable "
-                      "machine, only local mode available.\n");
+               pr_warning("The real or virtual hardware system does "
+                          "not provide an ETR interface\n");
                etr_port0_online = etr_port1_online = 0;
        }
 }
@@ -483,17 +525,18 @@ static int __init etr_init(void)
 
        if (!test_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags))
                return 0;
+       time_init_wq();
        /* Check if this machine has the steai instruction. */
        if (etr_steai(&aib, ETR_STEAI_STEPPING_PORT) == 0)
                etr_steai_available = 1;
        setup_timer(&etr_timer, etr_timeout, 0UL);
        if (etr_port0_online) {
                set_bit(ETR_EVENT_PORT0_CHANGE, &etr_events);
-               schedule_work(&etr_work);
+               queue_work(time_sync_wq, &etr_work);
        }
        if (etr_port1_online) {
                set_bit(ETR_EVENT_PORT1_CHANGE, &etr_events);
-               schedule_work(&etr_work);
+               queue_work(time_sync_wq, &etr_work);
        }
        return 0;
 }
@@ -517,10 +560,9 @@ void etr_switch_to_local(void)
 {
        if (!etr_eacr.sl)
                return;
-       if (test_bit(CLOCK_SYNC_ETR, &clock_sync_flags))
-               disable_sync_clock(NULL);
+       disable_sync_clock(NULL);
        set_bit(ETR_EVENT_SWITCH_LOCAL, &etr_events);
-       schedule_work(&etr_work);
+       queue_work(time_sync_wq, &etr_work);
 }
 
 /*
@@ -533,10 +575,9 @@ void etr_sync_check(void)
 {
        if (!etr_eacr.es)
                return;
-       if (test_bit(CLOCK_SYNC_ETR, &clock_sync_flags))
-               disable_sync_clock(NULL);
+       disable_sync_clock(NULL);
        set_bit(ETR_EVENT_SYNC_CHECK, &etr_events);
-       schedule_work(&etr_work);
+       queue_work(time_sync_wq, &etr_work);
 }
 
 /*
@@ -560,13 +601,13 @@ static void etr_timing_alert(struct etr_irq_parm *intparm)
                 * Both ports are not up-to-date now.
                 */
                set_bit(ETR_EVENT_PORT_ALERT, &etr_events);
-       schedule_work(&etr_work);
+       queue_work(time_sync_wq, &etr_work);
 }
 
 static void etr_timeout(unsigned long dummy)
 {
        set_bit(ETR_EVENT_UPDATE, &etr_events);
-       schedule_work(&etr_work);
+       queue_work(time_sync_wq, &etr_work);
 }
 
 /*
@@ -673,14 +714,16 @@ static int etr_aib_follows(struct etr_aib *a1, struct etr_aib *a2, int p)
 }
 
 struct clock_sync_data {
+       atomic_t cpus;
        int in_sync;
        unsigned long long fixup_cc;
+       int etr_port;
+       struct etr_aib *etr_aib;
 };
 
-static void clock_sync_cpu_start(void *dummy)
+static void clock_sync_cpu(struct clock_sync_data *sync)
 {
-       struct clock_sync_data *sync = dummy;
-
+       atomic_dec(&sync->cpus);
        enable_sync_clock();
        /*
         * This looks like a busy wait loop but it isn't. etr_sync_cpus
@@ -706,39 +749,35 @@ static void clock_sync_cpu_start(void *dummy)
        fixup_clock_comparator(sync->fixup_cc);
 }
 
-static void clock_sync_cpu_end(void *dummy)
-{
-}
-
 /*
  * Sync the TOD clock using the port refered to by aibp. This port
  * has to be enabled and the other port has to be disabled. The
  * last eacr update has to be more than 1.6 seconds in the past.
  */
-static int etr_sync_clock(struct etr_aib *aib, int port)
+static int etr_sync_clock(void *data)
 {
-       struct etr_aib *sync_port;
-       struct clock_sync_data etr_sync;
+       static int first;
        unsigned long long clock, old_clock, delay, delta;
-       int follows;
+       struct clock_sync_data *etr_sync;
+       struct etr_aib *sync_port, *aib;
+       int port;
        int rc;
 
-       /* Check if the current aib is adjacent to the sync port aib. */
-       sync_port = (port == 0) ? &etr_port0 : &etr_port1;
-       follows = etr_aib_follows(sync_port, aib, port);
-       memcpy(sync_port, aib, sizeof(*aib));
-       if (!follows)
-               return -EAGAIN;
+       etr_sync = data;
 
-       /*
-        * Catch all other cpus and make them wait until we have
-        * successfully synced the clock. smp_call_function will
-        * return after all other cpus are in etr_sync_cpu_start.
-        */
-       memset(&etr_sync, 0, sizeof(etr_sync));
-       preempt_disable();
-       smp_call_function(clock_sync_cpu_start, &etr_sync, 0);
-       local_irq_disable();
+       if (xchg(&first, 1) == 1) {
+               /* Slave */
+               clock_sync_cpu(etr_sync);
+               return 0;
+       }
+
+       /* Wait until all other cpus entered the sync function. */
+       while (atomic_read(&etr_sync->cpus) != 0)
+               cpu_relax();
+
+       port = etr_sync->etr_port;
+       aib = etr_sync->etr_aib;
+       sync_port = (port == 0) ? &etr_port0 : &etr_port1;
        enable_sync_clock();
 
        /* Set clock to next OTE. */
@@ -755,16 +794,16 @@ static int etr_sync_clock(struct etr_aib *aib, int port)
                delay = (unsigned long long)
                        (aib->edf2.etv - sync_port->edf2.etv) << 32;
                delta = adjust_time(old_clock, clock, delay);
-               etr_sync.fixup_cc = delta;
+               etr_sync->fixup_cc = delta;
                fixup_clock_comparator(delta);
                /* Verify that the clock is properly set. */
                if (!etr_aib_follows(sync_port, aib, port)) {
                        /* Didn't work. */
                        disable_sync_clock(NULL);
-                       etr_sync.in_sync = -EAGAIN;
+                       etr_sync->in_sync = -EAGAIN;
                        rc = -EAGAIN;
                } else {
-                       etr_sync.in_sync = 1;
+                       etr_sync->in_sync = 1;
                        rc = 0;
                }
        } else {
@@ -772,12 +811,33 @@ static int etr_sync_clock(struct etr_aib *aib, int port)
                __ctl_clear_bit(0, 29);
                __ctl_clear_bit(14, 21);
                disable_sync_clock(NULL);
-               etr_sync.in_sync = -EAGAIN;
+               etr_sync->in_sync = -EAGAIN;
                rc = -EAGAIN;
        }
-       local_irq_enable();
-       smp_call_function(clock_sync_cpu_end, NULL, 0);
-       preempt_enable();
+       xchg(&first, 0);
+       return rc;
+}
+
+static int etr_sync_clock_stop(struct etr_aib *aib, int port)
+{
+       struct clock_sync_data etr_sync;
+       struct etr_aib *sync_port;
+       int follows;
+       int rc;
+
+       /* Check if the current aib is adjacent to the sync port aib. */
+       sync_port = (port == 0) ? &etr_port0 : &etr_port1;
+       follows = etr_aib_follows(sync_port, aib, port);
+       memcpy(sync_port, aib, sizeof(*aib));
+       if (!follows)
+               return -EAGAIN;
+       memset(&etr_sync, 0, sizeof(etr_sync));
+       etr_sync.etr_aib = aib;
+       etr_sync.etr_port = port;
+       get_online_cpus();
+       atomic_set(&etr_sync.cpus, num_online_cpus() - 1);
+       rc = stop_machine(etr_sync_clock, &etr_sync, &cpu_online_map);
+       put_online_cpus();
        return rc;
 }
 
@@ -879,7 +939,7 @@ static struct etr_eacr etr_handle_update(struct etr_aib *aib,
         * Do not try to get the alternate port aib if the clock
         * is not in sync yet.
         */
-       if (!test_bit(CLOCK_SYNC_STP, &clock_sync_flags) && !eacr.es)
+       if (!check_sync_clock())
                return eacr;
 
        /*
@@ -934,7 +994,7 @@ static void etr_update_eacr(struct etr_eacr eacr)
 }
 
 /*
- * ETR tasklet. In this function you'll find the main logic. In
+ * ETR work. In this function you'll find the main logic. In
  * particular this is the only function that calls etr_update_eacr(),
  * it "controls" the etr control register.
  */
@@ -945,6 +1005,9 @@ static void etr_work_fn(struct work_struct *work)
        struct etr_aib aib;
        int sync_port;
 
+       /* prevent multiple execution. */
+       mutex_lock(&etr_work_mutex);
+
        /* Create working copy of etr_eacr. */
        eacr = etr_eacr;
 
@@ -959,8 +1022,7 @@ static void etr_work_fn(struct work_struct *work)
                on_each_cpu(disable_sync_clock, NULL, 1);
                del_timer_sync(&etr_timer);
                etr_update_eacr(eacr);
-               clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
-               return;
+               goto out_unlock;
        }
 
        /* Store aib to get the current ETR status word. */
@@ -1033,21 +1095,16 @@ static void etr_work_fn(struct work_struct *work)
                /* Both ports not usable. */
                eacr.es = eacr.sl = 0;
                sync_port = -1;
-               clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
        }
 
-       if (!test_bit(CLOCK_SYNC_ETR, &clock_sync_flags))
-               eacr.es = 0;
-
        /*
         * If the clock is in sync just update the eacr and return.
         * If there is no valid sync port wait for a port update.
         */
-       if (test_bit(CLOCK_SYNC_STP, &clock_sync_flags) ||
-           eacr.es || sync_port < 0) {
+       if (check_sync_clock() || sync_port < 0) {
                etr_update_eacr(eacr);
                etr_set_tolec_timeout(now);
-               return;
+               goto out_unlock;
        }
 
        /*
@@ -1065,16 +1122,16 @@ static void etr_work_fn(struct work_struct *work)
         * and set up a timer to try again after 0.5 seconds
         */
        etr_update_eacr(eacr);
-       set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
        if (now < etr_tolec + (1600000 << 12) ||
-           etr_sync_clock(&aib, sync_port) != 0) {
+           etr_sync_clock_stop(&aib, sync_port) != 0) {
                /* Sync failed. Try again in 1/2 second. */
                eacr.es = 0;
                etr_update_eacr(eacr);
-               clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
                etr_set_sync_timeout();
        } else
                etr_set_tolec_timeout(now);
+out_unlock:
+       mutex_unlock(&etr_work_mutex);
 }
 
 /*
@@ -1151,19 +1208,30 @@ static ssize_t etr_online_store(struct sys_device *dev,
                return -EINVAL;
        if (!test_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags))
                return -EOPNOTSUPP;
+       mutex_lock(&clock_sync_mutex);
        if (dev == &etr_port0_dev) {
                if (etr_port0_online == value)
-                       return count;   /* Nothing to do. */
+                       goto out;       /* Nothing to do. */
                etr_port0_online = value;
+               if (etr_port0_online && etr_port1_online)
+                       set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
+               else
+                       clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
                set_bit(ETR_EVENT_PORT0_CHANGE, &etr_events);
-               schedule_work(&etr_work);
+               queue_work(time_sync_wq, &etr_work);
        } else {
                if (etr_port1_online == value)
-                       return count;   /* Nothing to do. */
+                       goto out;       /* Nothing to do. */
                etr_port1_online = value;
+               if (etr_port0_online && etr_port1_online)
+                       set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
+               else
+                       clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
                set_bit(ETR_EVENT_PORT1_CHANGE, &etr_events);
-               schedule_work(&etr_work);
+               queue_work(time_sync_wq, &etr_work);
        }
+out:
+       mutex_unlock(&clock_sync_mutex);
        return count;
 }
 
@@ -1363,7 +1431,9 @@ static struct stp_sstpi stp_info;
 static void *stp_page;
 
 static void stp_work_fn(struct work_struct *work);
+static DEFINE_MUTEX(stp_work_mutex);
 static DECLARE_WORK(stp_work, stp_work_fn);
+static struct timer_list stp_timer;
 
 static int __init early_parse_stp(char *p)
 {
@@ -1387,17 +1457,28 @@ static void __init stp_reset(void)
        if (rc == 0)
                set_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags);
        else if (stp_online) {
-               printk(KERN_WARNING "Running on non STP capable machine.\n");
+               pr_warning("The real or virtual hardware system does "
+                          "not provide an STP interface\n");
                free_bootmem((unsigned long) stp_page, PAGE_SIZE);
                stp_page = NULL;
                stp_online = 0;
        }
 }
 
+static void stp_timeout(unsigned long dummy)
+{
+       queue_work(time_sync_wq, &stp_work);
+}
+
 static int __init stp_init(void)
 {
-       if (test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags) && stp_online)
-               schedule_work(&stp_work);
+       if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
+               return 0;
+       setup_timer(&stp_timer, stp_timeout, 0UL);
+       time_init_wq();
+       if (!stp_online)
+               return 0;
+       queue_work(time_sync_wq, &stp_work);
        return 0;
 }
 
@@ -1414,7 +1495,7 @@ arch_initcall(stp_init);
 static void stp_timing_alert(struct stp_irq_parm *intparm)
 {
        if (intparm->tsc || intparm->lac || intparm->tcpc)
-               schedule_work(&stp_work);
+               queue_work(time_sync_wq, &stp_work);
 }
 
 /*
@@ -1425,10 +1506,8 @@ static void stp_timing_alert(struct stp_irq_parm *intparm)
  */
 void stp_sync_check(void)
 {
-       if (!test_bit(CLOCK_SYNC_STP, &clock_sync_flags))
-               return;
        disable_sync_clock(NULL);
-       schedule_work(&stp_work);
+       queue_work(time_sync_wq, &stp_work);
 }
 
 /*
@@ -1439,50 +1518,32 @@ void stp_sync_check(void)
  */
 void stp_island_check(void)
 {
-       if (!test_bit(CLOCK_SYNC_STP, &clock_sync_flags))
-               return;
        disable_sync_clock(NULL);
-       schedule_work(&stp_work);
+       queue_work(time_sync_wq, &stp_work);
 }
 
-/*
- * STP tasklet. Check for the STP state and take over the clock
- * synchronization if the STP clock source is usable.
- */
-static void stp_work_fn(struct work_struct *work)
+
+static int stp_sync_clock(void *data)
 {
-       struct clock_sync_data stp_sync;
+       static int first;
        unsigned long long old_clock, delta;
+       struct clock_sync_data *stp_sync;
        int rc;
 
-       if (!stp_online) {
-               chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000);
-               return;
+       stp_sync = data;
+
+       if (xchg(&first, 1) == 1) {
+               /* Slave */
+               clock_sync_cpu(stp_sync);
+               return 0;
        }
 
-       rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0xb0e0);
-       if (rc)
-               return;
+       /* Wait until all other cpus entered the sync function. */
+       while (atomic_read(&stp_sync->cpus) != 0)
+               cpu_relax();
 
-       rc = chsc_sstpi(stp_page, &stp_info, sizeof(struct stp_sstpi));
-       if (rc || stp_info.c == 0)
-               return;
-
-       /*
-        * Catch all other cpus and make them wait until we have
-        * successfully synced the clock. smp_call_function will
-        * return after all other cpus are in clock_sync_cpu_start.
-        */
-       memset(&stp_sync, 0, sizeof(stp_sync));
-       preempt_disable();
-       smp_call_function(clock_sync_cpu_start, &stp_sync, 0);
-       local_irq_disable();
        enable_sync_clock();
 
-       set_bit(CLOCK_SYNC_STP, &clock_sync_flags);
-       if (test_and_clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags))
-               schedule_work(&etr_work);
-
        rc = 0;
        if (stp_info.todoff[0] || stp_info.todoff[1] ||
            stp_info.todoff[2] || stp_info.todoff[3] ||
@@ -1500,16 +1561,58 @@ static void stp_work_fn(struct work_struct *work)
        }
        if (rc) {
                disable_sync_clock(NULL);
-               stp_sync.in_sync = -EAGAIN;
-               clear_bit(CLOCK_SYNC_STP, &clock_sync_flags);
-               if (etr_port0_online || etr_port1_online)
-                       schedule_work(&etr_work);
+               stp_sync->in_sync = -EAGAIN;
        } else
-               stp_sync.in_sync = 1;
+               stp_sync->in_sync = 1;
+       xchg(&first, 0);
+       return 0;
+}
+
+/*
+ * STP work. Check for the STP state and take over the clock
+ * synchronization if the STP clock source is usable.
+ */
+static void stp_work_fn(struct work_struct *work)
+{
+       struct clock_sync_data stp_sync;
+       int rc;
+
+       /* prevent multiple execution. */
+       mutex_lock(&stp_work_mutex);
 
-       local_irq_enable();
-       smp_call_function(clock_sync_cpu_end, NULL, 0);
-       preempt_enable();
+       if (!stp_online) {
+               chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000);
+               del_timer_sync(&stp_timer);
+               goto out_unlock;
+       }
+
+       rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0xb0e0);
+       if (rc)
+               goto out_unlock;
+
+       rc = chsc_sstpi(stp_page, &stp_info, sizeof(struct stp_sstpi));
+       if (rc || stp_info.c == 0)
+               goto out_unlock;
+
+       /* Skip synchronization if the clock is already in sync. */
+       if (check_sync_clock())
+               goto out_unlock;
+
+       memset(&stp_sync, 0, sizeof(stp_sync));
+       get_online_cpus();
+       atomic_set(&stp_sync.cpus, num_online_cpus() - 1);
+       stop_machine(stp_sync_clock, &stp_sync, &cpu_online_map);
+       put_online_cpus();
+
+       if (!check_sync_clock())
+               /*
+                * There is a usable clock but the synchonization failed.
+                * Retry after a second.
+                */
+               mod_timer(&stp_timer, jiffies + HZ);
+
+out_unlock:
+       mutex_unlock(&stp_work_mutex);
 }
 
 /*
@@ -1617,8 +1720,14 @@ static ssize_t stp_online_store(struct sysdev_class *class,
                return -EINVAL;
        if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
                return -EOPNOTSUPP;
+       mutex_lock(&clock_sync_mutex);
        stp_online = value;
-       schedule_work(&stp_work);
+       if (stp_online)
+               set_bit(CLOCK_SYNC_STP, &clock_sync_flags);
+       else
+               clear_bit(CLOCK_SYNC_STP, &clock_sync_flags);
+       queue_work(time_sync_wq, &stp_work);
+       mutex_unlock(&clock_sync_mutex);
        return count;
 }