18 files changed, 92 insertions, 123 deletions

diff --git a/arch/alpha/kernel/rtc.c b/arch/alpha/kernel/rtc.c
index c8d284d8521f..f535a3fd0f60 100644
--- a/arch/alpha/kernel/rtc.c
+++ b/arch/alpha/kernel/rtc.c
@@ -116,7 +116,7 @@ alpha_rtc_set_time(struct device *dev, struct rtc_time *tm)
 }
 
 static int
-alpha_rtc_set_mmss(struct device *dev, unsigned long nowtime)
+alpha_rtc_set_mmss(struct device *dev, time64_t nowtime)
 {
         int retval = 0;
         int real_seconds, real_minutes, cmos_minutes;
@@ -211,7 +211,7 @@ alpha_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 static const struct rtc_class_ops alpha_rtc_ops = {
         .read_time = alpha_rtc_read_time,
         .set_time = alpha_rtc_set_time,
-        .set_mmss = alpha_rtc_set_mmss,
+        .set_mmss64 = alpha_rtc_set_mmss,
         .ioctl = alpha_rtc_ioctl,
 };
 
@@ -276,7 +276,7 @@ do_remote_mmss(void *data)
 }
 
 static int
-remote_set_mmss(struct device *dev, unsigned long now)
+remote_set_mmss(struct device *dev, time64_t now)
 {
         union remote_data x;
         if (smp_processor_id() != boot_cpuid) {
@@ -290,7 +290,7 @@ remote_set_mmss(struct device *dev, unsigned long now)
 static const struct rtc_class_ops remote_rtc_ops = {
         .read_time = remote_read_time,
         .set_time = remote_set_time,
-        .set_mmss = remote_set_mmss,
+        .set_mmss64 = remote_set_mmss,
         .ioctl = alpha_rtc_ioctl,
 };
 #endif
diff --git a/arch/arm/common/bL_switcher.c b/arch/arm/common/bL_switcher.c
index 6eaddc47c43d..37dc0fe1093f 100644
--- a/arch/arm/common/bL_switcher.c
+++ b/arch/arm/common/bL_switcher.c
@@ -151,8 +151,6 @@ static int bL_switch_to(unsigned int new_cluster_id)
         unsigned int mpidr, this_cpu, that_cpu;
         unsigned int ob_mpidr, ob_cpu, ob_cluster, ib_mpidr, ib_cpu, ib_cluster;
         struct completion inbound_alive;
-        struct tick_device *tdev;
-        enum clock_event_mode tdev_mode;
         long volatile *handshake_ptr;
         int ipi_nr, ret;
 
@@ -219,13 +217,7 @@ static int bL_switch_to(unsigned int new_cluster_id)
         /* redirect GIC's SGIs to our counterpart */
         gic_migrate_target(bL_gic_id[ib_cpu][ib_cluster]);
 
-        tdev = tick_get_device(this_cpu);
-        if (tdev && !cpumask_equal(tdev->evtdev->cpumask, cpumask_of(this_cpu)))
-                tdev = NULL;
-        if (tdev) {
-                tdev_mode = tdev->evtdev->mode;
-                clockevents_set_mode(tdev->evtdev, CLOCK_EVT_MODE_SHUTDOWN);
-        }
+        tick_suspend_local();
 
         ret = cpu_pm_enter();
 
@@ -251,11 +243,7 @@ static int bL_switch_to(unsigned int new_cluster_id)
 
         ret = cpu_pm_exit();
 
-        if (tdev) {
-                clockevents_set_mode(tdev->evtdev, tdev_mode);
-                clockevents_program_event(tdev->evtdev,
-                                          tdev->evtdev->next_event, 1);
-        }
+        tick_resume_local();
 
         trace_cpu_migrate_finish(ktime_get_real_ns(), ib_mpidr);
         local_fiq_enable();
diff --git a/arch/arm/include/asm/mach/time.h b/arch/arm/include/asm/mach/time.h
index 90c12e1e695c..0f79e4dec7f9 100644
--- a/arch/arm/include/asm/mach/time.h
+++ b/arch/arm/include/asm/mach/time.h
@@ -12,8 +12,7 @@
 
 extern void timer_tick(void);
 
-struct timespec;
-typedef void (*clock_access_fn)(struct timespec *);
+typedef void (*clock_access_fn)(struct timespec64 *);
 extern int register_persistent_clock(clock_access_fn read_boot,
                                      clock_access_fn read_persistent);
 
diff --git a/arch/arm/kernel/time.c b/arch/arm/kernel/time.c
index 0cc7e58c47cc..a66e37e211a9 100644
--- a/arch/arm/kernel/time.c
+++ b/arch/arm/kernel/time.c
@@ -76,7 +76,7 @@ void timer_tick(void)
 }
 #endif
 
-static void dummy_clock_access(struct timespec *ts)
+static void dummy_clock_access(struct timespec64 *ts)
 {
         ts->tv_sec = 0;
         ts->tv_nsec = 0;
@@ -85,12 +85,12 @@ static void dummy_clock_access(struct timespec *ts)
 static clock_access_fn __read_persistent_clock = dummy_clock_access;
 static clock_access_fn __read_boot_clock = dummy_clock_access;;
 
-void read_persistent_clock(struct timespec *ts)
+void read_persistent_clock64(struct timespec64 *ts)
 {
         __read_persistent_clock(ts);
 }
 
-void read_boot_clock(struct timespec *ts)
+void read_boot_clock64(struct timespec64 *ts)
 {
         __read_boot_clock(ts);
 }
diff --git a/arch/arm/mach-omap2/cpuidle44xx.c b/arch/arm/mach-omap2/cpuidle44xx.c
index 01e398a868bc..57d429830e09 100644
--- a/arch/arm/mach-omap2/cpuidle44xx.c
+++ b/arch/arm/mach-omap2/cpuidle44xx.c
@@ -14,7 +14,7 @@
 #include <linux/cpuidle.h>
 #include <linux/cpu_pm.h>
 #include <linux/export.h>
-#include <linux/clockchips.h>
+#include <linux/tick.h>
 
 #include <asm/cpuidle.h>
 #include <asm/proc-fns.h>
@@ -84,7 +84,6 @@ static int omap_enter_idle_coupled(struct cpuidle_device *dev,
 {
         struct idle_statedata *cx = state_ptr + index;
         u32 mpuss_can_lose_context = 0;
-        int cpu_id = smp_processor_id();
 
         /*
          * CPU0 has to wait and stay ON until CPU1 is OFF state.
@@ -112,7 +111,7 @@ static int omap_enter_idle_coupled(struct cpuidle_device *dev,
         mpuss_can_lose_context = (cx->mpu_state == PWRDM_POWER_RET) &&
                                  (cx->mpu_logic_state == PWRDM_POWER_OFF);
 
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &cpu_id);
+        tick_broadcast_enter();
 
         /*
          * Call idle CPU PM enter notifier chain so that
@@ -169,7 +168,7 @@ static int omap_enter_idle_coupled(struct cpuidle_device *dev,
         if (dev->cpu == 0 && mpuss_can_lose_context)
                 cpu_cluster_pm_exit();
 
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &cpu_id);
+        tick_broadcast_exit();
 
 fail:
         cpuidle_coupled_parallel_barrier(dev, &abort_barrier);
@@ -184,8 +183,7 @@ fail:
  */
 static void omap_setup_broadcast_timer(void *arg)
 {
-        int cpu = smp_processor_id();
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ON, &cpu);
+        tick_broadcast_enable();
 }
 
 static struct cpuidle_driver omap4_idle_driver = {
diff --git a/arch/arm/mach-tegra/cpuidle-tegra114.c b/arch/arm/mach-tegra/cpuidle-tegra114.c
index f2b586d7b15d..155807fa6fdd 100644
--- a/arch/arm/mach-tegra/cpuidle-tegra114.c
+++ b/arch/arm/mach-tegra/cpuidle-tegra114.c
@@ -15,7 +15,7 @@
  */
 
 #include <asm/firmware.h>
-#include <linux/clockchips.h>
+#include <linux/tick.h>
 #include <linux/cpuidle.h>
 #include <linux/cpu_pm.h>
 #include <linux/kernel.h>
@@ -44,7 +44,7 @@ static int tegra114_idle_power_down(struct cpuidle_device *dev,
         tegra_set_cpu_in_lp2();
         cpu_pm_enter();
 
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &dev->cpu);
+        tick_broadcast_enter();
 
         call_firmware_op(prepare_idle);
 
@@ -52,7 +52,7 @@ static int tegra114_idle_power_down(struct cpuidle_device *dev,
         if (call_firmware_op(do_idle, 0) == -ENOSYS)
                 cpu_suspend(0, tegra30_sleep_cpu_secondary_finish);
 
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &dev->cpu);
+        tick_broadcast_exit();
 
         cpu_pm_exit();
         tegra_clear_cpu_in_lp2();
diff --git a/arch/arm/mach-tegra/cpuidle-tegra20.c b/arch/arm/mach-tegra/cpuidle-tegra20.c
index 4f25a7c7ca0f..48844ae6c3a1 100644
--- a/arch/arm/mach-tegra/cpuidle-tegra20.c
+++ b/arch/arm/mach-tegra/cpuidle-tegra20.c
@@ -20,7 +20,7 @@
  */
 
 #include <linux/clk/tegra.h>
-#include <linux/clockchips.h>
+#include <linux/tick.h>
 #include <linux/cpuidle.h>
 #include <linux/cpu_pm.h>
 #include <linux/kernel.h>
@@ -136,11 +136,11 @@ static bool tegra20_cpu_cluster_power_down(struct cpuidle_device *dev,
         if (tegra20_reset_cpu_1() || !tegra_cpu_rail_off_ready())
                 return false;
 
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &dev->cpu);
+        tick_broadcast_enter();
 
         tegra_idle_lp2_last();
 
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &dev->cpu);
+        tick_broadcast_exit();
 
         if (cpu_online(1))
                 tegra20_wake_cpu1_from_reset();
@@ -153,13 +153,13 @@ static bool tegra20_idle_enter_lp2_cpu_1(struct cpuidle_device *dev,
                                          struct cpuidle_driver *drv,
                                          int index)
 {
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &dev->cpu);
+        tick_broadcast_enter();
 
         cpu_suspend(0, tegra20_sleep_cpu_secondary_finish);
 
         tegra20_cpu_clear_resettable();
 
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &dev->cpu);
+        tick_broadcast_exit();
 
         return true;
 }
diff --git a/arch/arm/mach-tegra/cpuidle-tegra30.c b/arch/arm/mach-tegra/cpuidle-tegra30.c
index f8815ed65d9d..84d809a3cba3 100644
--- a/arch/arm/mach-tegra/cpuidle-tegra30.c
+++ b/arch/arm/mach-tegra/cpuidle-tegra30.c
@@ -20,7 +20,7 @@
  */
 
 #include <linux/clk/tegra.h>
-#include <linux/clockchips.h>
+#include <linux/tick.h>
 #include <linux/cpuidle.h>
 #include <linux/cpu_pm.h>
 #include <linux/kernel.h>
@@ -76,11 +76,11 @@ static bool tegra30_cpu_cluster_power_down(struct cpuidle_device *dev,
                 return false;
         }
 
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &dev->cpu);
+        tick_broadcast_enter();
 
         tegra_idle_lp2_last();
 
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &dev->cpu);
+        tick_broadcast_exit();
 
         return true;
 }
@@ -90,13 +90,13 @@ static bool tegra30_cpu_core_power_down(struct cpuidle_device *dev,
                                         struct cpuidle_driver *drv,
                                         int index)
 {
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &dev->cpu);
+        tick_broadcast_enter();
 
         smp_wmb();
 
         cpu_suspend(0, tegra30_sleep_cpu_secondary_finish);
 
-        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &dev->cpu);
+        tick_broadcast_exit();
 
         return true;
 }
diff --git a/arch/arm/plat-omap/counter_32k.c b/arch/arm/plat-omap/counter_32k.c
index 61b4d705c267..2438b96004c1 100644
--- a/arch/arm/plat-omap/counter_32k.c
+++ b/arch/arm/plat-omap/counter_32k.c
@@ -44,24 +44,20 @@ static u64 notrace omap_32k_read_sched_clock(void)
 }
 
 /**
- * omap_read_persistent_clock -  Return time from a persistent clock.
+ * omap_read_persistent_clock64 -  Return time from a persistent clock.
  *
  * Reads the time from a source which isn't disabled during PM, the
  * 32k sync timer.  Convert the cycles elapsed since last read into
- * nsecs and adds to a monotonically increasing timespec.
+ * nsecs and adds to a monotonically increasing timespec64.
  */
-static struct timespec persistent_ts;
+static struct timespec64 persistent_ts;
 static cycles_t cycles;
 static unsigned int persistent_mult, persistent_shift;
-static DEFINE_SPINLOCK(read_persistent_clock_lock);
 
-static void omap_read_persistent_clock(struct timespec *ts)
+static void omap_read_persistent_clock64(struct timespec64 *ts)
 {
         unsigned long long nsecs;
         cycles_t last_cycles;
-        unsigned long flags;
-
-        spin_lock_irqsave(&read_persistent_clock_lock, flags);
 
         last_cycles = cycles;
         cycles = sync32k_cnt_reg ? readl_relaxed(sync32k_cnt_reg) : 0;
@@ -69,11 +65,9 @@ static void omap_read_persistent_clock(struct timespec *ts)
         nsecs = clocksource_cyc2ns(cycles - last_cycles,
                                         persistent_mult, persistent_shift);
 
-        timespec_add_ns(&persistent_ts, nsecs);
+        timespec64_add_ns(&persistent_ts, nsecs);
 
         *ts = persistent_ts;
-
-        spin_unlock_irqrestore(&read_persistent_clock_lock, flags);
 }
 
 /**
@@ -103,7 +97,7 @@ int __init omap_init_clocksource_32k(void __iomem *vbase)
 
         /*
          * 120000 rough estimate from the calculations in
-         * __clocksource_updatefreq_scale.
+         * __clocksource_update_freq_scale.
          */
         clocks_calc_mult_shift(&persistent_mult, &persistent_shift,
                         32768, NSEC_PER_SEC, 120000);
@@ -116,7 +110,7 @@ int __init omap_init_clocksource_32k(void __iomem *vbase)
         }
 
         sched_clock_register(omap_32k_read_sched_clock, 32, 32768);
-        register_persistent_clock(NULL, omap_read_persistent_clock);
+        register_persistent_clock(NULL, omap_read_persistent_clock64);
         pr_info("OMAP clocksource: 32k_counter at 32768 Hz\n");
 
         return 0;
diff --git a/arch/arm64/kernel/vdso.c b/arch/arm64/kernel/vdso.c
index 32aeea083d93..ec37ab3f524f 100644
--- a/arch/arm64/kernel/vdso.c
+++ b/arch/arm64/kernel/vdso.c
@@ -200,7 +200,7 @@ up_fail:
 void update_vsyscall(struct timekeeper *tk)
 {
         struct timespec xtime_coarse;
-        u32 use_syscall = strcmp(tk->tkr.clock->name, "arch_sys_counter");
+        u32 use_syscall = strcmp(tk->tkr_mono.clock->name, "arch_sys_counter");
 
         ++vdso_data->tb_seq_count;
         smp_wmb();
@@ -213,11 +213,11 @@ void update_vsyscall(struct timekeeper *tk)
         vdso_data->wtm_clock_nsec               = tk->wall_to_monotonic.tv_nsec;
 
         if (!use_syscall) {
-                vdso_data->cs_cycle_last        = tk->tkr.cycle_last;
+                vdso_data->cs_cycle_last        = tk->tkr_mono.cycle_last;
                 vdso_data->xtime_clock_sec      = tk->xtime_sec;
-                vdso_data->xtime_clock_nsec     = tk->tkr.xtime_nsec;
-                vdso_data->cs_mult              = tk->tkr.mult;
-                vdso_data->cs_shift             = tk->tkr.shift;
+                vdso_data->xtime_clock_nsec     = tk->tkr_mono.xtime_nsec;
+                vdso_data->cs_mult              = tk->tkr_mono.mult;
+                vdso_data->cs_shift             = tk->tkr_mono.shift;
         }
 
         smp_wmb();
diff --git a/arch/mips/lasat/sysctl.c b/arch/mips/lasat/sysctl.c
index 3b7f65cc4218..cf9b4633257e 100644
--- a/arch/mips/lasat/sysctl.c
+++ b/arch/mips/lasat/sysctl.c
@@ -75,11 +75,11 @@ static int rtctmp;
 int proc_dolasatrtc(struct ctl_table *table, int write,
                        void *buffer, size_t *lenp, loff_t *ppos)
 {
-        struct timespec ts;
+        struct timespec64 ts;
         int r;
 
         if (!write) {
-                read_persistent_clock(&ts);
+                read_persistent_clock64(&ts);
                 rtctmp = ts.tv_sec;
                 /* check for time < 0 and set to 0 */
                 if (rtctmp < 0)
diff --git a/arch/s390/kernel/time.c b/arch/s390/kernel/time.c
index 20660dddb2d6..170ddd2018b3 100644
--- a/arch/s390/kernel/time.c
+++ b/arch/s390/kernel/time.c
@@ -215,20 +215,20 @@ void update_vsyscall(struct timekeeper *tk)
 {
         u64 nsecps;
 
-        if (tk->tkr.clock != &clocksource_tod)
+        if (tk->tkr_mono.clock != &clocksource_tod)
                 return;
 
         /* Make userspace gettimeofday spin until we're done. */
         ++vdso_data->tb_update_count;
         smp_wmb();
-        vdso_data->xtime_tod_stamp = tk->tkr.cycle_last;
+        vdso_data->xtime_tod_stamp = tk->tkr_mono.cycle_last;
         vdso_data->xtime_clock_sec = tk->xtime_sec;
-        vdso_data->xtime_clock_nsec = tk->tkr.xtime_nsec;
+        vdso_data->xtime_clock_nsec = tk->tkr_mono.xtime_nsec;
         vdso_data->wtom_clock_sec =
                 tk->xtime_sec + tk->wall_to_monotonic.tv_sec;
-        vdso_data->wtom_clock_nsec = tk->tkr.xtime_nsec +
-                + ((u64) tk->wall_to_monotonic.tv_nsec << tk->tkr.shift);
-        nsecps = (u64) NSEC_PER_SEC << tk->tkr.shift;
+        vdso_data->wtom_clock_nsec = tk->tkr_mono.xtime_nsec +
+                + ((u64) tk->wall_to_monotonic.tv_nsec << tk->tkr_mono.shift);
+        nsecps = (u64) NSEC_PER_SEC << tk->tkr_mono.shift;
         while (vdso_data->wtom_clock_nsec >= nsecps) {
                 vdso_data->wtom_clock_nsec -= nsecps;
                 vdso_data->wtom_clock_sec++;
@@ -236,7 +236,7 @@ void update_vsyscall(struct timekeeper *tk)
 
         vdso_data->xtime_coarse_sec = tk->xtime_sec;
         vdso_data->xtime_coarse_nsec =
-                (long)(tk->tkr.xtime_nsec >> tk->tkr.shift);
+                (long)(tk->tkr_mono.xtime_nsec >> tk->tkr_mono.shift);
         vdso_data->wtom_coarse_sec =
                 vdso_data->xtime_coarse_sec + tk->wall_to_monotonic.tv_sec;
         vdso_data->wtom_coarse_nsec =
@@ -246,8 +246,8 @@ void update_vsyscall(struct timekeeper *tk)
                 vdso_data->wtom_coarse_sec++;
         }
 
-        vdso_data->tk_mult = tk->tkr.mult;
-        vdso_data->tk_shift = tk->tkr.shift;
+        vdso_data->tk_mult = tk->tkr_mono.mult;
+        vdso_data->tk_shift = tk->tkr_mono.shift;
         smp_wmb();
         ++vdso_data->tb_update_count;
 }
@@ -283,7 +283,7 @@ void __init time_init(void)
         if (register_external_irq(EXT_IRQ_TIMING_ALERT, timing_alert_interrupt))
                 panic("Couldn't request external interrupt 0x1406");
 
-        if (clocksource_register(&clocksource_tod) != 0)
+        if (__clocksource_register(&clocksource_tod) != 0)
                 panic("Could not register TOD clock source");
 
         /* Enable TOD clock interrupts on the boot cpu. */
diff --git a/arch/sparc/kernel/time_32.c b/arch/sparc/kernel/time_32.c
index 2f80d23a0a44..18147a5523d9 100644
--- a/arch/sparc/kernel/time_32.c
+++ b/arch/sparc/kernel/time_32.c
@@ -181,17 +181,13 @@ static struct clocksource timer_cs = {
         .rating = 100,
         .read   = timer_cs_read,
         .mask   = CLOCKSOURCE_MASK(64),
-        .shift  = 2,
         .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
 static __init int setup_timer_cs(void)
 {
         timer_cs_enabled = 1;
-        timer_cs.mult = clocksource_hz2mult(sparc_config.clock_rate,
-                                            timer_cs.shift);
-
-        return clocksource_register(&timer_cs);
+        return clocksource_register_hz(&timer_cs, sparc_config.clock_rate);
 }
 
 #ifdef CONFIG_SMP
diff --git a/arch/tile/kernel/time.c b/arch/tile/kernel/time.c
index d412b0856c0a..00178ecf9aea 100644
--- a/arch/tile/kernel/time.c
+++ b/arch/tile/kernel/time.c
@@ -257,34 +257,34 @@ void update_vsyscall_tz(void)
 
 void update_vsyscall(struct timekeeper *tk)
 {
-        if (tk->tkr.clock != &cycle_counter_cs)
+        if (tk->tkr_mono.clock != &cycle_counter_cs)
                 return;
 
         write_seqcount_begin(&vdso_data->tb_seq);
 
-        vdso_data->cycle_last           = tk->tkr.cycle_last;
-        vdso_data->mask                 = tk->tkr.mask;
-        vdso_data->mult                 = tk->tkr.mult;
-        vdso_data->shift                = tk->tkr.shift;
+        vdso_data->cycle_last           = tk->tkr_mono.cycle_last;
+        vdso_data->mask                 = tk->tkr_mono.mask;
+        vdso_data->mult                 = tk->tkr_mono.mult;
+        vdso_data->shift                = tk->tkr_mono.shift;
 
         vdso_data->wall_time_sec        = tk->xtime_sec;
-        vdso_data->wall_time_snsec      = tk->tkr.xtime_nsec;
+        vdso_data->wall_time_snsec      = tk->tkr_mono.xtime_nsec;
 
         vdso_data->monotonic_time_sec   = tk->xtime_sec
                                         + tk->wall_to_monotonic.tv_sec;
-        vdso_data->monotonic_time_snsec = tk->tkr.xtime_nsec
+        vdso_data->monotonic_time_snsec = tk->tkr_mono.xtime_nsec
                                         + ((u64)tk->wall_to_monotonic.tv_nsec
-                                                << tk->tkr.shift);
+                                                << tk->tkr_mono.shift);
         while (vdso_data->monotonic_time_snsec >=
-                                        (((u64)NSEC_PER_SEC) << tk->tkr.shift)) {
+                                        (((u64)NSEC_PER_SEC) << tk->tkr_mono.shift)) {
                 vdso_data->monotonic_time_snsec -=
-                                        ((u64)NSEC_PER_SEC) << tk->tkr.shift;
+                                        ((u64)NSEC_PER_SEC) << tk->tkr_mono.shift;
                 vdso_data->monotonic_time_sec++;
         }
 
         vdso_data->wall_time_coarse_sec = tk->xtime_sec;
-        vdso_data->wall_time_coarse_nsec = (long)(tk->tkr.xtime_nsec >>
-                                                 tk->tkr.shift);
+        vdso_data->wall_time_coarse_nsec = (long)(tk->tkr_mono.xtime_nsec >>
+                                                 tk->tkr_mono.shift);
 
         vdso_data->monotonic_time_coarse_sec =
                 vdso_data->wall_time_coarse_sec + tk->wall_to_monotonic.tv_sec;
diff --git a/arch/x86/kernel/process.c b/arch/x86/kernel/process.c
index a388bb883128..7af7b6478637 100644
--- a/arch/x86/kernel/process.c
+++ b/arch/x86/kernel/process.c
@@ -9,7 +9,7 @@
 #include <linux/sched.h>
 #include <linux/module.h>
 #include <linux/pm.h>
-#include <linux/clockchips.h>
+#include <linux/tick.h>
 #include <linux/random.h>
 #include <linux/user-return-notifier.h>
 #include <linux/dmi.h>
@@ -378,14 +378,11 @@ static void amd_e400_idle(void)
 
                 if (!cpumask_test_cpu(cpu, amd_e400_c1e_mask)) {
                         cpumask_set_cpu(cpu, amd_e400_c1e_mask);
-                        /*
-                         * Force broadcast so ACPI can not interfere.
-                         */
-                        clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_FORCE,
-                                           &cpu);
+                        /* Force broadcast so ACPI can not interfere. */
+                        tick_broadcast_force();
                         pr_info("Switch to broadcast mode on CPU%d\n", cpu);
                 }
-                clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &cpu);
+                tick_broadcast_enter();
 
                 default_idle();
 
@@ -394,7 +391,7 @@ static void amd_e400_idle(void)
                  * called with interrupts disabled.
                  */
                 local_irq_disable();
-                clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &cpu);
+                tick_broadcast_exit();
                 local_irq_enable();
         } else
                 default_idle();
diff --git a/arch/x86/kernel/vsyscall_gtod.c b/arch/x86/kernel/vsyscall_gtod.c
index c7d791f32b98..51e330416995 100644
--- a/arch/x86/kernel/vsyscall_gtod.c
+++ b/arch/x86/kernel/vsyscall_gtod.c
@@ -31,30 +31,30 @@ void update_vsyscall(struct timekeeper *tk)
         gtod_write_begin(vdata);
 
         /* copy vsyscall data */
-        vdata->vclock_mode      = tk->tkr.clock->archdata.vclock_mode;
-        vdata->cycle_last       = tk->tkr.cycle_last;
-        vdata->mask             = tk->tkr.mask;
-        vdata->mult             = tk->tkr.mult;
-        vdata->shift            = tk->tkr.shift;
+        vdata->vclock_mode      = tk->tkr_mono.clock->archdata.vclock_mode;
+        vdata->cycle_last       = tk->tkr_mono.cycle_last;
+        vdata->mask             = tk->tkr_mono.mask;
+        vdata->mult             = tk->tkr_mono.mult;
+        vdata->shift            = tk->tkr_mono.shift;
 
         vdata->wall_time_sec            = tk->xtime_sec;
-        vdata->wall_time_snsec          = tk->tkr.xtime_nsec;
+        vdata->wall_time_snsec          = tk->tkr_mono.xtime_nsec;
 
         vdata->monotonic_time_sec       = tk->xtime_sec
                                         + tk->wall_to_monotonic.tv_sec;
-        vdata->monotonic_time_snsec     = tk->tkr.xtime_nsec
+        vdata->monotonic_time_snsec     = tk->tkr_mono.xtime_nsec
                                         + ((u64)tk->wall_to_monotonic.tv_nsec
-                                                << tk->tkr.shift);
+                                                << tk->tkr_mono.shift);
         while (vdata->monotonic_time_snsec >=
-                                        (((u64)NSEC_PER_SEC) << tk->tkr.shift)) {
+                                        (((u64)NSEC_PER_SEC) << tk->tkr_mono.shift)) {
                 vdata->monotonic_time_snsec -=
-                                        ((u64)NSEC_PER_SEC) << tk->tkr.shift;
+                                        ((u64)NSEC_PER_SEC) << tk->tkr_mono.shift;
                 vdata->monotonic_time_sec++;
         }
 
         vdata->wall_time_coarse_sec     = tk->xtime_sec;
-        vdata->wall_time_coarse_nsec    = (long)(tk->tkr.xtime_nsec >>
-                                                 tk->tkr.shift);
+        vdata->wall_time_coarse_nsec    = (long)(tk->tkr_mono.xtime_nsec >>
+                                                 tk->tkr_mono.shift);
 
         vdata->monotonic_time_coarse_sec =
                 vdata->wall_time_coarse_sec + tk->wall_to_monotonic.tv_sec;
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 2b2dd030ea3b..e1a81267f3f6 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -1081,19 +1081,19 @@ static void update_pvclock_gtod(struct timekeeper *tk)
         struct pvclock_gtod_data *vdata = &pvclock_gtod_data;
         u64 boot_ns;
 
-        boot_ns = ktime_to_ns(ktime_add(tk->tkr.base_mono, tk->offs_boot));
+        boot_ns = ktime_to_ns(ktime_add(tk->tkr_mono.base, tk->offs_boot));
 
         write_seqcount_begin(&vdata->seq);
 
         /* copy pvclock gtod data */
-        vdata->clock.vclock_mode        = tk->tkr.clock->archdata.vclock_mode;
-        vdata->clock.cycle_last         = tk->tkr.cycle_last;
-        vdata->clock.mask               = tk->tkr.mask;
-        vdata->clock.mult               = tk->tkr.mult;
-        vdata->clock.shift              = tk->tkr.shift;
+        vdata->clock.vclock_mode        = tk->tkr_mono.clock->archdata.vclock_mode;
+        vdata->clock.cycle_last         = tk->tkr_mono.cycle_last;
+        vdata->clock.mask               = tk->tkr_mono.mask;
+        vdata->clock.mult               = tk->tkr_mono.mult;
+        vdata->clock.shift              = tk->tkr_mono.shift;
 
         vdata->boot_ns                  = boot_ns;
-        vdata->nsec_base                = tk->tkr.xtime_nsec;
+        vdata->nsec_base                = tk->tkr_mono.xtime_nsec;
 
         write_seqcount_end(&vdata->seq);
 }
diff --git a/arch/x86/xen/suspend.c b/arch/x86/xen/suspend.c
index c4df9dbd63b7..d9497698645a 100644
--- a/arch/x86/xen/suspend.c
+++ b/arch/x86/xen/suspend.c
@@ -1,5 +1,5 @@
 #include <linux/types.h>
-#include <linux/clockchips.h>
+#include <linux/tick.h>
 
 #include <xen/interface/xen.h>
 #include <xen/grant_table.h>
@@ -81,17 +81,14 @@ void xen_arch_post_suspend(int cancelled)
 
 static void xen_vcpu_notify_restore(void *data)
 {
-        unsigned long reason = (unsigned long)data;
-
         /* Boot processor notified via generic timekeeping_resume() */
-        if ( smp_processor_id() == 0)
+        if (smp_processor_id() == 0)
                 return;
 
-        clockevents_notify(reason, NULL);
+        tick_resume_local();
 }
 
 void xen_arch_resume(void)
 {
-        on_each_cpu(xen_vcpu_notify_restore,
-                    (void *)CLOCK_EVT_NOTIFY_RESUME, 1);
+        on_each_cpu(xen_vcpu_notify_restore, NULL, 1);
 }