[mirror_ubuntu-artful-kernel.git] / arch / x86 / xen / time.c

/*
 * Xen time implementation.
 *
 * This is implemented in terms of a clocksource driver which uses
 * the hypervisor clock as a nanosecond timebase, and a clockevent
 * driver which uses the hypervisor's timer mechanism.
 *
 * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
 */
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/clocksource.h>
#include <linux/clockchips.h>
#include <linux/gfp.h>
#include <linux/slab.h>
#include <linux/pvclock_gtod.h>
#include <linux/timekeeper_internal.h>

#include <asm/pvclock.h>
#include <asm/xen/hypervisor.h>
#include <asm/xen/hypercall.h>

#include <xen/events.h>
#include <xen/features.h>
#include <xen/interface/xen.h>
#include <xen/interface/vcpu.h>

#include "xen-ops.h"

/* Xen may fire a timer up to this many ns early */
#define TIMER_SLOP	100000

/* Get the TSC speed from Xen */
static unsigned long xen_tsc_khz(void)
{
	struct pvclock_vcpu_time_info *info =
		&HYPERVISOR_shared_info->vcpu_info[0].time;

	return pvclock_tsc_khz(info);
}

cycle_t xen_clocksource_read(void)
{
        struct pvclock_vcpu_time_info *src;
	cycle_t ret;

	preempt_disable_notrace();
	src = &__this_cpu_read(xen_vcpu)->time;
	ret = pvclock_clocksource_read(src);
	preempt_enable_notrace();
	return ret;
}

static cycle_t xen_clocksource_get_cycles(struct clocksource *cs)
{
	return xen_clocksource_read();
}

static void xen_read_wallclock(struct timespec *ts)
{
	struct shared_info *s = HYPERVISOR_shared_info;
	struct pvclock_wall_clock *wall_clock = &(s->wc);
        struct pvclock_vcpu_time_info *vcpu_time;

	vcpu_time = &get_cpu_var(xen_vcpu)->time;
	pvclock_read_wallclock(wall_clock, vcpu_time, ts);
	put_cpu_var(xen_vcpu);
}

static void xen_get_wallclock(struct timespec *now)
{
	xen_read_wallclock(now);
}

static int xen_set_wallclock(const struct timespec *now)
{
	return -1;
}

static int xen_pvclock_gtod_notify(struct notifier_block *nb,
				   unsigned long was_set, void *priv)
{
	/* Protected by the calling core code serialization */
	static struct timespec64 next_sync;

	struct xen_platform_op op;
	struct timespec64 now;
	struct timekeeper *tk = priv;
	static bool settime64_supported = true;
	int ret;

	now.tv_sec = tk->xtime_sec;
	now.tv_nsec = (long)(tk->tkr_mono.xtime_nsec >> tk->tkr_mono.shift);

	/*
	 * We only take the expensive HV call when the clock was set
	 * or when the 11 minutes RTC synchronization time elapsed.
	 */
	if (!was_set && timespec64_compare(&now, &next_sync) < 0)
		return NOTIFY_OK;

again:
	if (settime64_supported) {
		op.cmd = XENPF_settime64;
		op.u.settime64.mbz = 0;
		op.u.settime64.secs = now.tv_sec;
		op.u.settime64.nsecs = now.tv_nsec;
		op.u.settime64.system_time = xen_clocksource_read();
	} else {
		op.cmd = XENPF_settime32;
		op.u.settime32.secs = now.tv_sec;
		op.u.settime32.nsecs = now.tv_nsec;
		op.u.settime32.system_time = xen_clocksource_read();
	}

	ret = HYPERVISOR_platform_op(&op);

	if (ret == -ENOSYS && settime64_supported) {
		settime64_supported = false;
		goto again;
	}
	if (ret < 0)
		return NOTIFY_BAD;

	/*
	 * Move the next drift compensation time 11 minutes
	 * ahead. That's emulating the sync_cmos_clock() update for
	 * the hardware RTC.
	 */
	next_sync = now;
	next_sync.tv_sec += 11 * 60;

	return NOTIFY_OK;
}

static struct notifier_block xen_pvclock_gtod_notifier = {
	.notifier_call = xen_pvclock_gtod_notify,
};

static struct clocksource xen_clocksource __read_mostly = {
	.name = "xen",
	.rating = 400,
	.read = xen_clocksource_get_cycles,
	.mask = ~0,
	.flags = CLOCK_SOURCE_IS_CONTINUOUS,
};

/*
   Xen clockevent implementation

   Xen has two clockevent implementations:

   The old timer_op one works with all released versions of Xen prior
   to version 3.0.4.  This version of the hypervisor provides a
   single-shot timer with nanosecond resolution.  However, sharing the
   same event channel is a 100Hz tick which is delivered while the
   vcpu is running.  We don't care about or use this tick, but it will
   cause the core time code to think the timer fired too soon, and
   will end up resetting it each time.  It could be filtered, but
   doing so has complications when the ktime clocksource is not yet
   the xen clocksource (ie, at boot time).

   The new vcpu_op-based timer interface allows the tick timer period
   to be changed or turned off.  The tick timer is not useful as a
   periodic timer because events are only delivered to running vcpus.
   The one-shot timer can report when a timeout is in the past, so
   set_next_event is capable of returning -ETIME when appropriate.
   This interface is used when available.
*/


/*
  Get a hypervisor absolute time.  In theory we could maintain an
  offset between the kernel's time and the hypervisor's time, and
  apply that to a kernel's absolute timeout.  Unfortunately the
  hypervisor and kernel times can drift even if the kernel is using
  the Xen clocksource, because ntp can warp the kernel's clocksource.
*/
static s64 get_abs_timeout(unsigned long delta)
{
	return xen_clocksource_read() + delta;
}

static int xen_timerop_shutdown(struct clock_event_device *evt)
{
	/* cancel timeout */
	HYPERVISOR_set_timer_op(0);

	return 0;
}

static int xen_timerop_set_next_event(unsigned long delta,
				      struct clock_event_device *evt)
{
	WARN_ON(!clockevent_state_oneshot(evt));

	if (HYPERVISOR_set_timer_op(get_abs_timeout(delta)) < 0)
		BUG();

	/* We may have missed the deadline, but there's no real way of
	   knowing for sure.  If the event was in the past, then we'll
	   get an immediate interrupt. */

	return 0;
}

static const struct clock_event_device xen_timerop_clockevent = {
	.name			= "xen",
	.features		= CLOCK_EVT_FEAT_ONESHOT,

	.max_delta_ns		= 0xffffffff,
	.min_delta_ns		= TIMER_SLOP,

	.mult			= 1,
	.shift			= 0,
	.rating			= 500,

	.set_state_shutdown	= xen_timerop_shutdown,
	.set_next_event		= xen_timerop_set_next_event,
};

static int xen_vcpuop_shutdown(struct clock_event_device *evt)
{
	int cpu = smp_processor_id();

	if (HYPERVISOR_vcpu_op(VCPUOP_stop_singleshot_timer, xen_vcpu_nr(cpu),
			       NULL) ||
	    HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, xen_vcpu_nr(cpu),
			       NULL))
		BUG();

	return 0;
}

static int xen_vcpuop_set_oneshot(struct clock_event_device *evt)
{
	int cpu = smp_processor_id();

	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, xen_vcpu_nr(cpu),
			       NULL))
		BUG();

	return 0;
}

static int xen_vcpuop_set_next_event(unsigned long delta,
				     struct clock_event_device *evt)
{
	int cpu = smp_processor_id();
	struct vcpu_set_singleshot_timer single;
	int ret;

	WARN_ON(!clockevent_state_oneshot(evt));

	single.timeout_abs_ns = get_abs_timeout(delta);
	/* Get an event anyway, even if the timeout is already expired */
	single.flags = 0;

	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, xen_vcpu_nr(cpu),
				 &single);
	BUG_ON(ret != 0);

	return ret;
}

static const struct clock_event_device xen_vcpuop_clockevent = {
	.name = "xen",
	.features = CLOCK_EVT_FEAT_ONESHOT,

	.max_delta_ns = 0xffffffff,
	.min_delta_ns = TIMER_SLOP,

	.mult = 1,
	.shift = 0,
	.rating = 500,

	.set_state_shutdown = xen_vcpuop_shutdown,
	.set_state_oneshot = xen_vcpuop_set_oneshot,
	.set_next_event = xen_vcpuop_set_next_event,
};

static const struct clock_event_device *xen_clockevent =
	&xen_timerop_clockevent;

struct xen_clock_event_device {
	struct clock_event_device evt;
	char name[16];
};
static DEFINE_PER_CPU(struct xen_clock_event_device, xen_clock_events) = { .evt.irq = -1 };

static irqreturn_t xen_timer_interrupt(int irq, void *dev_id)
{
	struct clock_event_device *evt = this_cpu_ptr(&xen_clock_events.evt);
	irqreturn_t ret;

	ret = IRQ_NONE;
	if (evt->event_handler) {
		evt->event_handler(evt);
		ret = IRQ_HANDLED;
	}

	return ret;
}

void xen_teardown_timer(int cpu)
{
	struct clock_event_device *evt;
	BUG_ON(cpu == 0);
	evt = &per_cpu(xen_clock_events, cpu).evt;

	if (evt->irq >= 0) {
		unbind_from_irqhandler(evt->irq, NULL);
		evt->irq = -1;
	}
}

void xen_setup_timer(int cpu)
{
	struct xen_clock_event_device *xevt = &per_cpu(xen_clock_events, cpu);
	struct clock_event_device *evt = &xevt->evt;
	int irq;

	WARN(evt->irq >= 0, "IRQ%d for CPU%d is already allocated\n", evt->irq, cpu);
	if (evt->irq >= 0)
		xen_teardown_timer(cpu);

	printk(KERN_INFO "installing Xen timer for CPU %d\n", cpu);

	snprintf(xevt->name, sizeof(xevt->name), "timer%d", cpu);

	irq = bind_virq_to_irqhandler(VIRQ_TIMER, cpu, xen_timer_interrupt,
				      IRQF_PERCPU|IRQF_NOBALANCING|IRQF_TIMER|
				      IRQF_FORCE_RESUME|IRQF_EARLY_RESUME,
				      xevt->name, NULL);
	(void)xen_set_irq_priority(irq, XEN_IRQ_PRIORITY_MAX);

	memcpy(evt, xen_clockevent, sizeof(*evt));

	evt->cpumask = cpumask_of(cpu);
	evt->irq = irq;
}


void xen_setup_cpu_clockevents(void)
{
	clockevents_register_device(this_cpu_ptr(&xen_clock_events.evt));
}

void xen_timer_resume(void)
{
	int cpu;

	pvclock_resume();

	if (xen_clockevent != &xen_vcpuop_clockevent)
		return;

	for_each_online_cpu(cpu) {
		if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer,
				       xen_vcpu_nr(cpu), NULL))
			BUG();
	}
}

static const struct pv_time_ops xen_time_ops __initconst = {
	.sched_clock = xen_clocksource_read,
};

static void __init xen_time_init(void)
{
	int cpu = smp_processor_id();
	struct timespec tp;

	/* As Dom0 is never moved, no penalty on using TSC there */
	if (xen_initial_domain())
		xen_clocksource.rating = 275;

	clocksource_register_hz(&xen_clocksource, NSEC_PER_SEC);

	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, xen_vcpu_nr(cpu),
			       NULL) == 0) {
		/* Successfully turned off 100Hz tick, so we have the
		   vcpuop-based timer interface */
		printk(KERN_DEBUG "Xen: using vcpuop timer interface\n");
		xen_clockevent = &xen_vcpuop_clockevent;
	}

	/* Set initial system time with full resolution */
	xen_read_wallclock(&tp);
	do_settimeofday(&tp);

	setup_force_cpu_cap(X86_FEATURE_TSC);

	xen_setup_runstate_info(cpu);
	xen_setup_timer(cpu);
	xen_setup_cpu_clockevents();

	xen_time_setup_guest();

	if (xen_initial_domain())
		pvclock_gtod_register_notifier(&xen_pvclock_gtod_notifier);
}

void __init xen_init_time_ops(void)
{
	pv_time_ops = xen_time_ops;

	x86_init.timers.timer_init = xen_time_init;
	x86_init.timers.setup_percpu_clockev = x86_init_noop;
	x86_cpuinit.setup_percpu_clockev = x86_init_noop;

	x86_platform.calibrate_tsc = xen_tsc_khz;
	x86_platform.get_wallclock = xen_get_wallclock;
	/* Dom0 uses the native method to set the hardware RTC. */
	if (!xen_initial_domain())
		x86_platform.set_wallclock = xen_set_wallclock;
}

#ifdef CONFIG_XEN_PVHVM
static void xen_hvm_setup_cpu_clockevents(void)
{
	int cpu = smp_processor_id();
	xen_setup_runstate_info(cpu);
	/*
	 * xen_setup_timer(cpu) - snprintf is bad in atomic context. Hence
	 * doing it xen_hvm_cpu_notify (which gets called by smp_init during
	 * early bootup and also during CPU hotplug events).
	 */
	xen_setup_cpu_clockevents();
}

void __init xen_hvm_init_time_ops(void)
{
	/* vector callback is needed otherwise we cannot receive interrupts
	 * on cpu > 0 and at this point we don't know how many cpus are
	 * available */
	if (!xen_have_vector_callback)
		return;
	if (!xen_feature(XENFEAT_hvm_safe_pvclock)) {
		printk(KERN_INFO "Xen doesn't support pvclock on HVM,"
				"disable pv timer\n");
		return;
	}

	pv_time_ops = xen_time_ops;
	x86_init.timers.setup_percpu_clockev = xen_time_init;
	x86_cpuinit.setup_percpu_clockev = xen_hvm_setup_cpu_clockevents;

	x86_platform.calibrate_tsc = xen_tsc_khz;
	x86_platform.get_wallclock = xen_get_wallclock;
	x86_platform.set_wallclock = xen_set_wallclock;
}
#endif
Commit	Line	Data
15c84731 JF	1	/*
	2	* Xen time implementation.
	3	*
	4	* This is implemented in terms of a clocksource driver which uses
	5	* the hypervisor clock as a nanosecond timebase, and a clockevent
	6	* driver which uses the hypervisor's timer mechanism.
	7	*
	8	* Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
	9	*/
	10	#include <linux/kernel.h>
	11	#include <linux/interrupt.h>
	12	#include <linux/clocksource.h>
	13	#include <linux/clockchips.h>
5a0e3ad6	14	#include <linux/gfp.h>
c9d76a24	15	#include <linux/slab.h>
5584880e	16	#include <linux/pvclock_gtod.h>
76096863	17	#include <linux/timekeeper_internal.h>
15c84731	18
1c7b67f7	19	#include <asm/pvclock.h>
15c84731 JF	20	#include <asm/xen/hypervisor.h>
	21	#include <asm/xen/hypercall.h>
	22
	23	#include <xen/events.h>
409771d2	24	#include <xen/features.h>
15c84731 JF	25	#include <xen/interface/xen.h>
	26	#include <xen/interface/vcpu.h>
	27
	28	#include "xen-ops.h"
	29
15c84731 JF	30	/* Xen may fire a timer up to this many ns early */
15c84731 JF	31	#define TIMER_SLOP 100000
f91a8b44	32
e93ef949	33	/* Get the TSC speed from Xen */
409771d2	34	static unsigned long xen_tsc_khz(void)
15c84731	35	{
3807f345	36	struct pvclock_vcpu_time_info *info =
15c84731 JF	37	&HYPERVISOR_shared_info->vcpu_info[0].time;
15c84731 JF	38
3807f345	39	return pvclock_tsc_khz(info);
15c84731 JF	40	}
15c84731 JF	41
ee7686bc	42	cycle_t xen_clocksource_read(void)
15c84731	43	{
1c7b67f7	44	struct pvclock_vcpu_time_info *src;
15c84731	45	cycle_t ret;
15c84731	46
f1c39625	47	preempt_disable_notrace();
3251f20b	48	src = &__this_cpu_read(xen_vcpu)->time;
1c7b67f7	49	ret = pvclock_clocksource_read(src);
f1c39625	50	preempt_enable_notrace();
15c84731 JF	51	return ret;
	52	}
	53
8e19608e MD	54	static cycle_t xen_clocksource_get_cycles(struct clocksource *cs)
	55	{
	56	return xen_clocksource_read();
	57	}
	58
15c84731 JF	59	static void xen_read_wallclock(struct timespec *ts)
15c84731 JF	60	{
1c7b67f7 GH	61	struct shared_info *s = HYPERVISOR_shared_info;
	62	struct pvclock_wall_clock *wall_clock = &(s->wc);
	63	struct pvclock_vcpu_time_info *vcpu_time;
15c84731	64
1c7b67f7 GH	65	vcpu_time = &get_cpu_var(xen_vcpu)->time;
	66	pvclock_read_wallclock(wall_clock, vcpu_time, ts);
	67	put_cpu_var(xen_vcpu);
15c84731 JF	68	}
15c84731 JF	69
3565184e	70	static void xen_get_wallclock(struct timespec *now)
15c84731	71	{
3565184e	72	xen_read_wallclock(now);
15c84731	73	}
15c84731	74
3565184e	75	static int xen_set_wallclock(const struct timespec *now)
15c84731	76	{
47433b8c	77	return -1;
15c84731 JF	78	}
15c84731 JF	79
47433b8c DV	80	static int xen_pvclock_gtod_notify(struct notifier_block *nb,
47433b8c DV	81	unsigned long was_set, void *priv)
15c84731	82	{
47433b8c	83	/* Protected by the calling core code serialization */
187b26a9	84	static struct timespec64 next_sync;
5584880e	85
fdb9eb9f	86	struct xen_platform_op op;
76096863 SS	87	struct timespec64 now;
	88	struct timekeeper *tk = priv;
	89	static bool settime64_supported = true;
	90	int ret;
fdb9eb9f	91
76096863 SS	92	now.tv_sec = tk->xtime_sec;
76096863 SS	93	now.tv_nsec = (long)(tk->tkr_mono.xtime_nsec >> tk->tkr_mono.shift);
5584880e	94
47433b8c DV	95	/*
	96	* We only take the expensive HV call when the clock was set
	97	* or when the 11 minutes RTC synchronization time elapsed.
	98	*/
187b26a9	99	if (!was_set && timespec64_compare(&now, &next_sync) < 0)
47433b8c	100	return NOTIFY_OK;
fdb9eb9f	101
76096863 SS	102	again:
	103	if (settime64_supported) {
	104	op.cmd = XENPF_settime64;
	105	op.u.settime64.mbz = 0;
	106	op.u.settime64.secs = now.tv_sec;
	107	op.u.settime64.nsecs = now.tv_nsec;
	108	op.u.settime64.system_time = xen_clocksource_read();
	109	} else {
	110	op.cmd = XENPF_settime32;
	111	op.u.settime32.secs = now.tv_sec;
	112	op.u.settime32.nsecs = now.tv_nsec;
	113	op.u.settime32.system_time = xen_clocksource_read();
	114	}
	115
	116	ret = HYPERVISOR_platform_op(&op);
	117
	118	if (ret == -ENOSYS && settime64_supported) {
	119	settime64_supported = false;
	120	goto again;
	121	}
	122	if (ret < 0)
	123	return NOTIFY_BAD;
fdb9eb9f	124
47433b8c DV	125	/*
	126	* Move the next drift compensation time 11 minutes
	127	* ahead. That's emulating the sync_cmos_clock() update for
	128	* the hardware RTC.
	129	*/
	130	next_sync = now;
	131	next_sync.tv_sec += 11 * 60;
	132
5584880e	133	return NOTIFY_OK;
15c84731 JF	134	}
15c84731 JF	135
5584880e DV	136	static struct notifier_block xen_pvclock_gtod_notifier = {
	137	.notifier_call = xen_pvclock_gtod_notify,
	138	};
	139
15c84731 JF	140	static struct clocksource xen_clocksource __read_mostly = {
	141	.name = "xen",
	142	.rating = 400,
8e19608e	143	.read = xen_clocksource_get_cycles,
15c84731	144	.mask = ~0,
15c84731 JF	145	.flags = CLOCK_SOURCE_IS_CONTINUOUS,
	146	};
	147
	148	/*
	149	Xen clockevent implementation
	150
	151	Xen has two clockevent implementations:
	152
	153	The old timer_op one works with all released versions of Xen prior
	154	to version 3.0.4. This version of the hypervisor provides a
	155	single-shot timer with nanosecond resolution. However, sharing the
	156	same event channel is a 100Hz tick which is delivered while the
	157	vcpu is running. We don't care about or use this tick, but it will
	158	cause the core time code to think the timer fired too soon, and
	159	will end up resetting it each time. It could be filtered, but
	160	doing so has complications when the ktime clocksource is not yet
	161	the xen clocksource (ie, at boot time).
	162
	163	The new vcpu_op-based timer interface allows the tick timer period
	164	to be changed or turned off. The tick timer is not useful as a
	165	periodic timer because events are only delivered to running vcpus.
	166	The one-shot timer can report when a timeout is in the past, so
	167	set_next_event is capable of returning -ETIME when appropriate.
	168	This interface is used when available.
	169	*/
	170
	171
	172	/*
	173	Get a hypervisor absolute time. In theory we could maintain an
	174	offset between the kernel's time and the hypervisor's time, and
	175	apply that to a kernel's absolute timeout. Unfortunately the
	176	hypervisor and kernel times can drift even if the kernel is using
	177	the Xen clocksource, because ntp can warp the kernel's clocksource.
	178	*/
	179	static s64 get_abs_timeout(unsigned long delta)
	180	{
	181	return xen_clocksource_read() + delta;
	182	}
	183
955381dd	184	static int xen_timerop_shutdown(struct clock_event_device *evt)
15c84731	185	{
955381dd VK	186	/* cancel timeout */
	187	HYPERVISOR_set_timer_op(0);
	188
	189	return 0;
15c84731 JF	190	}
	191
	192	static int xen_timerop_set_next_event(unsigned long delta,
	193	struct clock_event_device *evt)
	194	{
955381dd	195	WARN_ON(!clockevent_state_oneshot(evt));
15c84731 JF	196
	197	if (HYPERVISOR_set_timer_op(get_abs_timeout(delta)) < 0)
	198	BUG();
	199
	200	/* We may have missed the deadline, but there's no real way of
	201	knowing for sure. If the event was in the past, then we'll
	202	get an immediate interrupt. */
	203
	204	return 0;
	205	}
	206
	207	static const struct clock_event_device xen_timerop_clockevent = {
955381dd VK	208	.name = "xen",
955381dd VK	209	.features = CLOCK_EVT_FEAT_ONESHOT,
15c84731	210
955381dd VK	211	.max_delta_ns = 0xffffffff,
955381dd VK	212	.min_delta_ns = TIMER_SLOP,
15c84731	213
955381dd VK	214	.mult = 1,
	215	.shift = 0,
	216	.rating = 500,
15c84731	217
955381dd VK	218	.set_state_shutdown = xen_timerop_shutdown,
955381dd VK	219	.set_next_event = xen_timerop_set_next_event,
15c84731 JF	220	};
15c84731 JF	221
955381dd VK	222	static int xen_vcpuop_shutdown(struct clock_event_device *evt)
	223	{
	224	int cpu = smp_processor_id();
15c84731	225
ad5475f9 VK	226	if (HYPERVISOR_vcpu_op(VCPUOP_stop_singleshot_timer, xen_vcpu_nr(cpu),
	227	NULL) \|\|
	228	HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, xen_vcpu_nr(cpu),
	229	NULL))
955381dd	230	BUG();
15c84731	231
955381dd VK	232	return 0;
	233	}
	234
	235	static int xen_vcpuop_set_oneshot(struct clock_event_device *evt)
15c84731 JF	236	{
	237	int cpu = smp_processor_id();
	238
ad5475f9 VK	239	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, xen_vcpu_nr(cpu),
ad5475f9 VK	240	NULL))
955381dd VK	241	BUG();
	242
	243	return 0;
15c84731 JF	244	}
	245
	246	static int xen_vcpuop_set_next_event(unsigned long delta,
	247	struct clock_event_device *evt)
	248	{
	249	int cpu = smp_processor_id();
	250	struct vcpu_set_singleshot_timer single;
	251	int ret;
	252
955381dd	253	WARN_ON(!clockevent_state_oneshot(evt));
15c84731 JF	254
15c84731 JF	255	single.timeout_abs_ns = get_abs_timeout(delta);
c06b6d70 SS	256	/* Get an event anyway, even if the timeout is already expired */
c06b6d70 SS	257	single.flags = 0;
15c84731	258
ad5475f9 VK	259	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, xen_vcpu_nr(cpu),
ad5475f9 VK	260	&single);
c06b6d70	261	BUG_ON(ret != 0);
15c84731 JF	262
	263	return ret;
	264	}
	265
	266	static const struct clock_event_device xen_vcpuop_clockevent = {
	267	.name = "xen",
	268	.features = CLOCK_EVT_FEAT_ONESHOT,
	269
	270	.max_delta_ns = 0xffffffff,
	271	.min_delta_ns = TIMER_SLOP,
	272
	273	.mult = 1,
	274	.shift = 0,
	275	.rating = 500,
	276
955381dd VK	277	.set_state_shutdown = xen_vcpuop_shutdown,
955381dd VK	278	.set_state_oneshot = xen_vcpuop_set_oneshot,
15c84731 JF	279	.set_next_event = xen_vcpuop_set_next_event,
	280	};
	281
	282	static const struct clock_event_device *xen_clockevent =
	283	&xen_timerop_clockevent;
31620a19 KRW	284
	285	struct xen_clock_event_device {
	286	struct clock_event_device evt;
7be0772d	287	char name[16];
31620a19 KRW	288	};
31620a19 KRW	289	static DEFINE_PER_CPU(struct xen_clock_event_device, xen_clock_events) = { .evt.irq = -1 };
15c84731 JF	290
	291	static irqreturn_t xen_timer_interrupt(int irq, void *dev_id)
	292	{
89cbc767	293	struct clock_event_device *evt = this_cpu_ptr(&xen_clock_events.evt);
15c84731 JF	294	irqreturn_t ret;
	295
	296	ret = IRQ_NONE;
	297	if (evt->event_handler) {
	298	evt->event_handler(evt);
	299	ret = IRQ_HANDLED;
	300	}
	301
	302	return ret;
	303	}
	304
09e99da7 KRW	305	void xen_teardown_timer(int cpu)
	306	{
	307	struct clock_event_device *evt;
	308	BUG_ON(cpu == 0);
	309	evt = &per_cpu(xen_clock_events, cpu).evt;
	310
	311	if (evt->irq >= 0) {
	312	unbind_from_irqhandler(evt->irq, NULL);
	313	evt->irq = -1;
09e99da7 KRW	314	}
	315	}
	316
f87e4cac	317	void xen_setup_timer(int cpu)
15c84731	318	{
7be0772d VK	319	struct xen_clock_event_device *xevt = &per_cpu(xen_clock_events, cpu);
7be0772d VK	320	struct clock_event_device *evt = &xevt->evt;
15c84731 JF	321	int irq;
15c84731 JF	322
ef35a4e6	323	WARN(evt->irq >= 0, "IRQ%d for CPU%d is already allocated\n", evt->irq, cpu);
09e99da7 KRW	324	if (evt->irq >= 0)
09e99da7 KRW	325	xen_teardown_timer(cpu);
ef35a4e6	326
15c84731 JF	327	printk(KERN_INFO "installing Xen timer for CPU %d\n", cpu);
15c84731 JF	328
7be0772d	329	snprintf(xevt->name, sizeof(xevt->name), "timer%d", cpu);
15c84731 JF	330
15c84731 JF	331	irq = bind_virq_to_irqhandler(VIRQ_TIMER, cpu, xen_timer_interrupt,
9d71cee6	332	IRQF_PERCPU\|IRQF_NOBALANCING\|IRQF_TIMER\|
8d5999df	333	IRQF_FORCE_RESUME\|IRQF_EARLY_RESUME,
7be0772d	334	xevt->name, NULL);
8785c676	335	(void)xen_set_irq_priority(irq, XEN_IRQ_PRIORITY_MAX);
15c84731	336
15c84731 JF	337	memcpy(evt, xen_clockevent, sizeof(*evt));
15c84731 JF	338
320ab2b0	339	evt->cpumask = cpumask_of(cpu);
15c84731	340	evt->irq = irq;
f87e4cac JF	341	}
f87e4cac JF	342
d68d82af	343
f87e4cac JF	344	void xen_setup_cpu_clockevents(void)
f87e4cac JF	345	{
89cbc767	346	clockevents_register_device(this_cpu_ptr(&xen_clock_events.evt));
15c84731 JF	347	}
15c84731 JF	348
d07af1f0 JF	349	void xen_timer_resume(void)
	350	{
	351	int cpu;
	352
e7a3481c JF	353	pvclock_resume();
e7a3481c JF	354
d07af1f0 JF	355	if (xen_clockevent != &xen_vcpuop_clockevent)
	356	return;
	357
	358	for_each_online_cpu(cpu) {
ad5475f9 VK	359	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer,
ad5475f9 VK	360	xen_vcpu_nr(cpu), NULL))
d07af1f0 JF	361	BUG();
	362	}
	363	}
	364
fb6ce5de	365	static const struct pv_time_ops xen_time_ops __initconst = {
ca50a5f3	366	.sched_clock = xen_clocksource_read,
409771d2 SS	367	};
409771d2 SS	368
fb6ce5de	369	static void __init xen_time_init(void)
15c84731 JF	370	{
15c84731 JF	371	int cpu = smp_processor_id();
c4507257	372	struct timespec tp;
15c84731	373
94dd85f6 PI	374	/* As Dom0 is never moved, no penalty on using TSC there */
	375	if (xen_initial_domain())
	376	xen_clocksource.rating = 275;
	377
b01cc1b0	378	clocksource_register_hz(&xen_clocksource, NSEC_PER_SEC);
15c84731	379
ad5475f9 VK	380	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, xen_vcpu_nr(cpu),
ad5475f9 VK	381	NULL) == 0) {
f91a8b44	382	/* Successfully turned off 100Hz tick, so we have the
15c84731 JF	383	vcpuop-based timer interface */
	384	printk(KERN_DEBUG "Xen: using vcpuop timer interface\n");
	385	xen_clockevent = &xen_vcpuop_clockevent;
	386	}
	387
	388	/* Set initial system time with full resolution */
c4507257 JS	389	xen_read_wallclock(&tp);
c4507257 JS	390	do_settimeofday(&tp);
15c84731	391
404ee5b1	392	setup_force_cpu_cap(X86_FEATURE_TSC);
15c84731	393
be012920	394	xen_setup_runstate_info(cpu);
15c84731	395	xen_setup_timer(cpu);
f87e4cac	396	xen_setup_cpu_clockevents();
5584880e	397
ecb23dc6 JG	398	xen_time_setup_guest();
ecb23dc6 JG	399
5584880e DV	400	if (xen_initial_domain())
5584880e DV	401	pvclock_gtod_register_notifier(&xen_pvclock_gtod_notifier);
15c84731	402	}
409771d2	403
fb6ce5de	404	void __init xen_init_time_ops(void)
409771d2 SS	405	{
	406	pv_time_ops = xen_time_ops;
	407
	408	x86_init.timers.timer_init = xen_time_init;
	409	x86_init.timers.setup_percpu_clockev = x86_init_noop;
	410	x86_cpuinit.setup_percpu_clockev = x86_init_noop;
	411
	412	x86_platform.calibrate_tsc = xen_tsc_khz;
	413	x86_platform.get_wallclock = xen_get_wallclock;
47433b8c DV	414	/* Dom0 uses the native method to set the hardware RTC. */
	415	if (!xen_initial_domain())
	416	x86_platform.set_wallclock = xen_set_wallclock;
409771d2 SS	417	}
409771d2 SS	418
ca65f9fc	419	#ifdef CONFIG_XEN_PVHVM
409771d2 SS	420	static void xen_hvm_setup_cpu_clockevents(void)
	421	{
	422	int cpu = smp_processor_id();
	423	xen_setup_runstate_info(cpu);
7918c92a KRW	424	/*
	425	* xen_setup_timer(cpu) - snprintf is bad in atomic context. Hence
	426	* doing it xen_hvm_cpu_notify (which gets called by smp_init during
	427	* early bootup and also during CPU hotplug events).
	428	*/
409771d2 SS	429	xen_setup_cpu_clockevents();
	430	}
	431
fb6ce5de	432	void __init xen_hvm_init_time_ops(void)
409771d2 SS	433	{
409771d2 SS	434	/* vector callback is needed otherwise we cannot receive interrupts
31e7e931 SS	435	* on cpu > 0 and at this point we don't know how many cpus are
	436	* available */
	437	if (!xen_have_vector_callback)
409771d2 SS	438	return;
	439	if (!xen_feature(XENFEAT_hvm_safe_pvclock)) {
	440	printk(KERN_INFO "Xen doesn't support pvclock on HVM,"
	441	"disable pv timer\n");
	442	return;
	443	}
	444
	445	pv_time_ops = xen_time_ops;
	446	x86_init.timers.setup_percpu_clockev = xen_time_init;
	447	x86_cpuinit.setup_percpu_clockev = xen_hvm_setup_cpu_clockevents;
	448
	449	x86_platform.calibrate_tsc = xen_tsc_khz;
	450	x86_platform.get_wallclock = xen_get_wallclock;
	451	x86_platform.set_wallclock = xen_set_wallclock;
	452	}
ca65f9fc	453	#endif