[net-next-2.6.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/kernel_stat.h>
#include <linux/math64.h>
#include <linux/gfp.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"

#define XEN_SHIFT 22

/* Xen may fire a timer up to this many ns early */
#define TIMER_SLOP	100000
#define NS_PER_TICK	(1000000000LL / HZ)

/* runstate info updated by Xen */
static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate);

/* snapshots of runstate info */
static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate_snapshot);

/* unused ns of stolen and blocked time */
static DEFINE_PER_CPU(u64, xen_residual_stolen);
static DEFINE_PER_CPU(u64, xen_residual_blocked);

/* return an consistent snapshot of 64-bit time/counter value */
static u64 get64(const u64 *p)
{
	u64 ret;

	if (BITS_PER_LONG < 64) {
		u32 *p32 = (u32 *)p;
		u32 h, l;

		/*
		 * Read high then low, and then make sure high is
		 * still the same; this will only loop if low wraps
		 * and carries into high.
		 * XXX some clean way to make this endian-proof?
		 */
		do {
			h = p32[1];
			barrier();
			l = p32[0];
			barrier();
		} while (p32[1] != h);

		ret = (((u64)h) << 32) | l;
	} else
		ret = *p;

	return ret;
}

/*
 * Runstate accounting
 */
static void get_runstate_snapshot(struct vcpu_runstate_info *res)
{
	u64 state_time;
	struct vcpu_runstate_info *state;

	BUG_ON(preemptible());

	state = &__get_cpu_var(xen_runstate);

	/*
	 * The runstate info is always updated by the hypervisor on
	 * the current CPU, so there's no need to use anything
	 * stronger than a compiler barrier when fetching it.
	 */
	do {
		state_time = get64(&state->state_entry_time);
		barrier();
		*res = *state;
		barrier();
	} while (get64(&state->state_entry_time) != state_time);
}

/* return true when a vcpu could run but has no real cpu to run on */
bool xen_vcpu_stolen(int vcpu)
{
	return per_cpu(xen_runstate, vcpu).state == RUNSTATE_runnable;
}

void xen_setup_runstate_info(int cpu)
{
	struct vcpu_register_runstate_memory_area area;

	area.addr.v = &per_cpu(xen_runstate, cpu);

	if (HYPERVISOR_vcpu_op(VCPUOP_register_runstate_memory_area,
			       cpu, &area))
		BUG();
}

static void do_stolen_accounting(void)
{
	struct vcpu_runstate_info state;
	struct vcpu_runstate_info *snap;
	s64 blocked, runnable, offline, stolen;
	cputime_t ticks;

	get_runstate_snapshot(&state);

	WARN_ON(state.state != RUNSTATE_running);

	snap = &__get_cpu_var(xen_runstate_snapshot);

	/* work out how much time the VCPU has not been runn*ing*  */
	blocked = state.time[RUNSTATE_blocked] - snap->time[RUNSTATE_blocked];
	runnable = state.time[RUNSTATE_runnable] - snap->time[RUNSTATE_runnable];
	offline = state.time[RUNSTATE_offline] - snap->time[RUNSTATE_offline];

	*snap = state;

	/* Add the appropriate number of ticks of stolen time,
	   including any left-overs from last time. */
	stolen = runnable + offline + __get_cpu_var(xen_residual_stolen);

	if (stolen < 0)
		stolen = 0;

	ticks = iter_div_u64_rem(stolen, NS_PER_TICK, &stolen);
	__get_cpu_var(xen_residual_stolen) = stolen;
	account_steal_ticks(ticks);

	/* Add the appropriate number of ticks of blocked time,
	   including any left-overs from last time. */
	blocked += __get_cpu_var(xen_residual_blocked);

	if (blocked < 0)
		blocked = 0;

	ticks = iter_div_u64_rem(blocked, NS_PER_TICK, &blocked);
	__get_cpu_var(xen_residual_blocked) = blocked;
	account_idle_ticks(ticks);
}

/* 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;

	src = &get_cpu_var(xen_vcpu)->time;
	ret = pvclock_clocksource_read(src);
	put_cpu_var(xen_vcpu);
	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 unsigned long xen_get_wallclock(void)
{
	struct timespec ts;

	xen_read_wallclock(&ts);
	return ts.tv_sec;
}

static int xen_set_wallclock(unsigned long now)
{
	/* do nothing for domU */
	return -1;
}

static struct clocksource xen_clocksource __read_mostly = {
	.name = "xen",
	.rating = 400,
	.read = xen_clocksource_get_cycles,
	.mask = ~0,
	.mult = 1<<XEN_SHIFT,		/* time directly in nanoseconds */
	.shift = XEN_SHIFT,
	.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 void xen_timerop_set_mode(enum clock_event_mode mode,
				 struct clock_event_device *evt)
{
	switch (mode) {
	case CLOCK_EVT_MODE_PERIODIC:
		/* unsupported */
		WARN_ON(1);
		break;

	case CLOCK_EVT_MODE_ONESHOT:
	case CLOCK_EVT_MODE_RESUME:
		break;

	case CLOCK_EVT_MODE_UNUSED:
	case CLOCK_EVT_MODE_SHUTDOWN:
		HYPERVISOR_set_timer_op(0);  /* cancel timeout */
		break;
	}
}

static int xen_timerop_set_next_event(unsigned long delta,
				      struct clock_event_device *evt)
{
	WARN_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT);

	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_mode = xen_timerop_set_mode,
	.set_next_event = xen_timerop_set_next_event,
};


static void xen_vcpuop_set_mode(enum clock_event_mode mode,
				struct clock_event_device *evt)
{
	int cpu = smp_processor_id();

	switch (mode) {
	case CLOCK_EVT_MODE_PERIODIC:
		WARN_ON(1);	/* unsupported */
		break;

	case CLOCK_EVT_MODE_ONESHOT:
		if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
			BUG();
		break;

	case CLOCK_EVT_MODE_UNUSED:
	case CLOCK_EVT_MODE_SHUTDOWN:
		if (HYPERVISOR_vcpu_op(VCPUOP_stop_singleshot_timer, cpu, NULL) ||
		    HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
			BUG();
		break;
	case CLOCK_EVT_MODE_RESUME:
		break;
	}
}

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(evt->mode != CLOCK_EVT_MODE_ONESHOT);

	single.timeout_abs_ns = get_abs_timeout(delta);
	single.flags = VCPU_SSHOTTMR_future;

	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single);

	BUG_ON(ret != 0 && ret != -ETIME);

	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_mode = xen_vcpuop_set_mode,
	.set_next_event = xen_vcpuop_set_next_event,
};

static const struct clock_event_device *xen_clockevent =
	&xen_timerop_clockevent;
static DEFINE_PER_CPU(struct clock_event_device, xen_clock_events);

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

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

	do_stolen_accounting();

	return ret;
}

void xen_setup_timer(int cpu)
{
	const char *name;
	struct clock_event_device *evt;
	int irq;

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

	name = kasprintf(GFP_KERNEL, "timer%d", cpu);
	if (!name)
		name = "<timer kasprintf failed>";

	irq = bind_virq_to_irqhandler(VIRQ_TIMER, cpu, xen_timer_interrupt,
				      IRQF_DISABLED|IRQF_PERCPU|IRQF_NOBALANCING|IRQF_TIMER,
				      name, NULL);

	evt = &per_cpu(xen_clock_events, cpu);
	memcpy(evt, xen_clockevent, sizeof(*evt));

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

void xen_teardown_timer(int cpu)
{
	struct clock_event_device *evt;
	BUG_ON(cpu == 0);
	evt = &per_cpu(xen_clock_events, cpu);
	unbind_from_irqhandler(evt->irq, NULL);
}

void xen_setup_cpu_clockevents(void)
{
	BUG_ON(preemptible());

	clockevents_register_device(&__get_cpu_var(xen_clock_events));
}

void xen_timer_resume(void)
{
	int cpu;

	if (xen_clockevent != &xen_vcpuop_clockevent)
		return;

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

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

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

	clocksource_register(&xen_clocksource);

	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, 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();
}

__init void 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;
	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);
	xen_setup_cpu_clockevents();
}

__init void 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>
f91a8b44	14	#include <linux/kernel_stat.h>
f595ec96	15	#include <linux/math64.h>
5a0e3ad6	16	#include <linux/gfp.h>
15c84731	17
1c7b67f7	18	#include <asm/pvclock.h>
15c84731 JF	19	#include <asm/xen/hypervisor.h>
	20	#include <asm/xen/hypercall.h>
	21
	22	#include <xen/events.h>
409771d2	23	#include <xen/features.h>
15c84731 JF	24	#include <xen/interface/xen.h>
	25	#include <xen/interface/vcpu.h>
	26
	27	#include "xen-ops.h"
	28
	29	#define XEN_SHIFT 22
	30
	31	/* Xen may fire a timer up to this many ns early */
	32	#define TIMER_SLOP 100000
f91a8b44	33	#define NS_PER_TICK (1000000000LL / HZ)
15c84731	34
f91a8b44	35	/* runstate info updated by Xen */
c6e22f9e	36	static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate);
f91a8b44 JF	37
f91a8b44 JF	38	/* snapshots of runstate info */
c6e22f9e	39	static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate_snapshot);
f91a8b44 JF	40
f91a8b44 JF	41	/* unused ns of stolen and blocked time */
c6e22f9e TH	42	static DEFINE_PER_CPU(u64, xen_residual_stolen);
c6e22f9e TH	43	static DEFINE_PER_CPU(u64, xen_residual_blocked);
f91a8b44 JF	44
	45	/* return an consistent snapshot of 64-bit time/counter value */
	46	static u64 get64(const u64 *p)
	47	{
	48	u64 ret;
	49
	50	if (BITS_PER_LONG < 64) {
	51	u32 p32 = (u32 )p;
	52	u32 h, l;
	53
	54	/*
	55	* Read high then low, and then make sure high is
	56	* still the same; this will only loop if low wraps
	57	* and carries into high.
	58	* XXX some clean way to make this endian-proof?
	59	*/
	60	do {
	61	h = p32[1];
	62	barrier();
	63	l = p32[0];
	64	barrier();
	65	} while (p32[1] != h);
	66
	67	ret = (((u64)h) << 32) \| l;
	68	} else
	69	ret = *p;
	70
	71	return ret;
	72	}
	73
	74	/*
	75	* Runstate accounting
	76	*/
	77	static void get_runstate_snapshot(struct vcpu_runstate_info *res)
	78	{
	79	u64 state_time;
	80	struct vcpu_runstate_info *state;
	81
f120f13e	82	BUG_ON(preemptible());
f91a8b44	83
c6e22f9e	84	state = &__get_cpu_var(xen_runstate);
f91a8b44 JF	85
	86	/*
	87	* The runstate info is always updated by the hypervisor on
	88	* the current CPU, so there's no need to use anything
	89	* stronger than a compiler barrier when fetching it.
	90	*/
	91	do {
	92	state_time = get64(&state->state_entry_time);
	93	barrier();
	94	res = state;
	95	barrier();
	96	} while (get64(&state->state_entry_time) != state_time);
f91a8b44 JF	97	}
f91a8b44 JF	98
f0d73394 JF	99	/* return true when a vcpu could run but has no real cpu to run on */
	100	bool xen_vcpu_stolen(int vcpu)
	101	{
c6e22f9e	102	return per_cpu(xen_runstate, vcpu).state == RUNSTATE_runnable;
f0d73394 JF	103	}
f0d73394 JF	104
be012920	105	void xen_setup_runstate_info(int cpu)
f91a8b44 JF	106	{
	107	struct vcpu_register_runstate_memory_area area;
	108
c6e22f9e	109	area.addr.v = &per_cpu(xen_runstate, cpu);
f91a8b44 JF	110
	111	if (HYPERVISOR_vcpu_op(VCPUOP_register_runstate_memory_area,
	112	cpu, &area))
	113	BUG();
	114	}
	115
	116	static void do_stolen_accounting(void)
	117	{
	118	struct vcpu_runstate_info state;
	119	struct vcpu_runstate_info *snap;
	120	s64 blocked, runnable, offline, stolen;
	121	cputime_t ticks;
	122
	123	get_runstate_snapshot(&state);
	124
	125	WARN_ON(state.state != RUNSTATE_running);
	126
c6e22f9e	127	snap = &__get_cpu_var(xen_runstate_snapshot);
f91a8b44 JF	128
	129	/* work out how much time the VCPU has not been running */
	130	blocked = state.time[RUNSTATE_blocked] - snap->time[RUNSTATE_blocked];
	131	runnable = state.time[RUNSTATE_runnable] - snap->time[RUNSTATE_runnable];
	132	offline = state.time[RUNSTATE_offline] - snap->time[RUNSTATE_offline];
	133
	134	*snap = state;
	135
	136	/* Add the appropriate number of ticks of stolen time,
79741dd3	137	including any left-overs from last time. */
c6e22f9e	138	stolen = runnable + offline + __get_cpu_var(xen_residual_stolen);
f91a8b44 JF	139
	140	if (stolen < 0)
	141	stolen = 0;
	142
f595ec96	143	ticks = iter_div_u64_rem(stolen, NS_PER_TICK, &stolen);
c6e22f9e	144	__get_cpu_var(xen_residual_stolen) = stolen;
79741dd3	145	account_steal_ticks(ticks);
f91a8b44 JF	146
f91a8b44 JF	147	/* Add the appropriate number of ticks of blocked time,
79741dd3	148	including any left-overs from last time. */
c6e22f9e	149	blocked += __get_cpu_var(xen_residual_blocked);
f91a8b44 JF	150
	151	if (blocked < 0)
	152	blocked = 0;
	153
f595ec96	154	ticks = iter_div_u64_rem(blocked, NS_PER_TICK, &blocked);
c6e22f9e	155	__get_cpu_var(xen_residual_blocked) = blocked;
79741dd3	156	account_idle_ticks(ticks);
f91a8b44 JF	157	}
f91a8b44 JF	158
e93ef949	159	/* Get the TSC speed from Xen */
409771d2	160	static unsigned long xen_tsc_khz(void)
15c84731	161	{
3807f345	162	struct pvclock_vcpu_time_info *info =
15c84731 JF	163	&HYPERVISOR_shared_info->vcpu_info[0].time;
15c84731 JF	164
3807f345	165	return pvclock_tsc_khz(info);
15c84731 JF	166	}
15c84731 JF	167
ee7686bc	168	cycle_t xen_clocksource_read(void)
15c84731	169	{
1c7b67f7	170	struct pvclock_vcpu_time_info *src;
15c84731	171	cycle_t ret;
15c84731	172
1c7b67f7 GH	173	src = &get_cpu_var(xen_vcpu)->time;
	174	ret = pvclock_clocksource_read(src);
	175	put_cpu_var(xen_vcpu);
15c84731 JF	176	return ret;
	177	}
	178
8e19608e MD	179	static cycle_t xen_clocksource_get_cycles(struct clocksource *cs)
	180	{
	181	return xen_clocksource_read();
	182	}
	183
15c84731 JF	184	static void xen_read_wallclock(struct timespec *ts)
15c84731 JF	185	{
1c7b67f7 GH	186	struct shared_info *s = HYPERVISOR_shared_info;
	187	struct pvclock_wall_clock *wall_clock = &(s->wc);
	188	struct pvclock_vcpu_time_info *vcpu_time;
15c84731	189
1c7b67f7 GH	190	vcpu_time = &get_cpu_var(xen_vcpu)->time;
	191	pvclock_read_wallclock(wall_clock, vcpu_time, ts);
	192	put_cpu_var(xen_vcpu);
15c84731 JF	193	}
15c84731 JF	194
409771d2	195	static unsigned long xen_get_wallclock(void)
15c84731 JF	196	{
	197	struct timespec ts;
	198
	199	xen_read_wallclock(&ts);
15c84731 JF	200	return ts.tv_sec;
	201	}
	202
409771d2	203	static int xen_set_wallclock(unsigned long now)
15c84731 JF	204	{
	205	/* do nothing for domU */
	206	return -1;
	207	}
	208
	209	static struct clocksource xen_clocksource __read_mostly = {
	210	.name = "xen",
	211	.rating = 400,
8e19608e	212	.read = xen_clocksource_get_cycles,
15c84731 JF	213	.mask = ~0,
	214	.mult = 1<<XEN_SHIFT, /* time directly in nanoseconds */
	215	.shift = XEN_SHIFT,
	216	.flags = CLOCK_SOURCE_IS_CONTINUOUS,
	217	};
	218
	219	/*
	220	Xen clockevent implementation
	221
	222	Xen has two clockevent implementations:
	223
	224	The old timer_op one works with all released versions of Xen prior
	225	to version 3.0.4. This version of the hypervisor provides a
	226	single-shot timer with nanosecond resolution. However, sharing the
	227	same event channel is a 100Hz tick which is delivered while the
	228	vcpu is running. We don't care about or use this tick, but it will
	229	cause the core time code to think the timer fired too soon, and
	230	will end up resetting it each time. It could be filtered, but
	231	doing so has complications when the ktime clocksource is not yet
	232	the xen clocksource (ie, at boot time).
	233
	234	The new vcpu_op-based timer interface allows the tick timer period
	235	to be changed or turned off. The tick timer is not useful as a
	236	periodic timer because events are only delivered to running vcpus.
	237	The one-shot timer can report when a timeout is in the past, so
	238	set_next_event is capable of returning -ETIME when appropriate.
	239	This interface is used when available.
	240	*/
	241
	242
	243	/*
	244	Get a hypervisor absolute time. In theory we could maintain an
	245	offset between the kernel's time and the hypervisor's time, and
	246	apply that to a kernel's absolute timeout. Unfortunately the
	247	hypervisor and kernel times can drift even if the kernel is using
	248	the Xen clocksource, because ntp can warp the kernel's clocksource.
	249	*/
	250	static s64 get_abs_timeout(unsigned long delta)
	251	{
	252	return xen_clocksource_read() + delta;
	253	}
	254
	255	static void xen_timerop_set_mode(enum clock_event_mode mode,
	256	struct clock_event_device *evt)
	257	{
	258	switch (mode) {
	259	case CLOCK_EVT_MODE_PERIODIC:
	260	/* unsupported */
	261	WARN_ON(1);
	262	break;
	263
	264	case CLOCK_EVT_MODE_ONESHOT:
18de5bc4	265	case CLOCK_EVT_MODE_RESUME:
15c84731 JF	266	break;
	267
	268	case CLOCK_EVT_MODE_UNUSED:
	269	case CLOCK_EVT_MODE_SHUTDOWN:
	270	HYPERVISOR_set_timer_op(0); /* cancel timeout */
	271	break;
	272	}
	273	}
	274
	275	static int xen_timerop_set_next_event(unsigned long delta,
	276	struct clock_event_device *evt)
	277	{
	278	WARN_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT);
	279
	280	if (HYPERVISOR_set_timer_op(get_abs_timeout(delta)) < 0)
	281	BUG();
	282
	283	/* We may have missed the deadline, but there's no real way of
	284	knowing for sure. If the event was in the past, then we'll
	285	get an immediate interrupt. */
	286
	287	return 0;
	288	}
	289
	290	static const struct clock_event_device xen_timerop_clockevent = {
	291	.name = "xen",
	292	.features = CLOCK_EVT_FEAT_ONESHOT,
	293
	294	.max_delta_ns = 0xffffffff,
	295	.min_delta_ns = TIMER_SLOP,
	296
	297	.mult = 1,
	298	.shift = 0,
	299	.rating = 500,
	300
	301	.set_mode = xen_timerop_set_mode,
	302	.set_next_event = xen_timerop_set_next_event,
	303	};
	304
	305
	306
	307	static void xen_vcpuop_set_mode(enum clock_event_mode mode,
	308	struct clock_event_device *evt)
	309	{
	310	int cpu = smp_processor_id();
	311
	312	switch (mode) {
	313	case CLOCK_EVT_MODE_PERIODIC:
	314	WARN_ON(1); /* unsupported */
	315	break;
	316
	317	case CLOCK_EVT_MODE_ONESHOT:
	318	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
	319	BUG();
	320	break;
	321
	322	case CLOCK_EVT_MODE_UNUSED:
	323	case CLOCK_EVT_MODE_SHUTDOWN:
	324	if (HYPERVISOR_vcpu_op(VCPUOP_stop_singleshot_timer, cpu, NULL) \|\|
	325	HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
	326	BUG();
	327	break;
18de5bc4 TG	328	case CLOCK_EVT_MODE_RESUME:
18de5bc4 TG	329	break;
15c84731 JF	330	}
	331	}
	332
	333	static int xen_vcpuop_set_next_event(unsigned long delta,
	334	struct clock_event_device *evt)
	335	{
	336	int cpu = smp_processor_id();
	337	struct vcpu_set_singleshot_timer single;
	338	int ret;
	339
	340	WARN_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT);
	341
	342	single.timeout_abs_ns = get_abs_timeout(delta);
	343	single.flags = VCPU_SSHOTTMR_future;
	344
	345	ret = HYPERVISOR_vcpu_op(VCPUOP_set_singleshot_timer, cpu, &single);
	346
	347	BUG_ON(ret != 0 && ret != -ETIME);
	348
	349	return ret;
	350	}
	351
	352	static const struct clock_event_device xen_vcpuop_clockevent = {
	353	.name = "xen",
	354	.features = CLOCK_EVT_FEAT_ONESHOT,
	355
	356	.max_delta_ns = 0xffffffff,
	357	.min_delta_ns = TIMER_SLOP,
	358
	359	.mult = 1,
	360	.shift = 0,
	361	.rating = 500,
	362
	363	.set_mode = xen_vcpuop_set_mode,
	364	.set_next_event = xen_vcpuop_set_next_event,
	365	};
	366
	367	static const struct clock_event_device *xen_clockevent =
	368	&xen_timerop_clockevent;
	369	static DEFINE_PER_CPU(struct clock_event_device, xen_clock_events);
	370
	371	static irqreturn_t xen_timer_interrupt(int irq, void *dev_id)
	372	{
	373	struct clock_event_device *evt = &__get_cpu_var(xen_clock_events);
	374	irqreturn_t ret;
	375
	376	ret = IRQ_NONE;
	377	if (evt->event_handler) {
	378	evt->event_handler(evt);
	379	ret = IRQ_HANDLED;
	380	}
	381
f91a8b44 JF	382	do_stolen_accounting();
f91a8b44 JF	383
15c84731 JF	384	return ret;
	385	}
	386
f87e4cac	387	void xen_setup_timer(int cpu)
15c84731 JF	388	{
	389	const char *name;
	390	struct clock_event_device *evt;
	391	int irq;
	392
	393	printk(KERN_INFO "installing Xen timer for CPU %d\n", cpu);
	394
	395	name = kasprintf(GFP_KERNEL, "timer%d", cpu);
	396	if (!name)
	397	name = "<timer kasprintf failed>";
	398
	399	irq = bind_virq_to_irqhandler(VIRQ_TIMER, cpu, xen_timer_interrupt,
f350c792	400	IRQF_DISABLED\|IRQF_PERCPU\|IRQF_NOBALANCING\|IRQF_TIMER,
15c84731 JF	401	name, NULL);
15c84731 JF	402
f87e4cac	403	evt = &per_cpu(xen_clock_events, cpu);
15c84731 JF	404	memcpy(evt, xen_clockevent, sizeof(*evt));
15c84731 JF	405
320ab2b0	406	evt->cpumask = cpumask_of(cpu);
15c84731	407	evt->irq = irq;
f87e4cac JF	408	}
f87e4cac JF	409
d68d82af AN	410	void xen_teardown_timer(int cpu)
	411	{
	412	struct clock_event_device *evt;
	413	BUG_ON(cpu == 0);
	414	evt = &per_cpu(xen_clock_events, cpu);
	415	unbind_from_irqhandler(evt->irq, NULL);
	416	}
	417
f87e4cac JF	418	void xen_setup_cpu_clockevents(void)
	419	{
	420	BUG_ON(preemptible());
f91a8b44	421
f87e4cac	422	clockevents_register_device(&__get_cpu_var(xen_clock_events));
15c84731 JF	423	}
15c84731 JF	424
d07af1f0 JF	425	void xen_timer_resume(void)
	426	{
	427	int cpu;
	428
	429	if (xen_clockevent != &xen_vcpuop_clockevent)
	430	return;
	431
	432	for_each_online_cpu(cpu) {
	433	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
	434	BUG();
	435	}
	436	}
	437
409771d2	438	static const struct pv_time_ops xen_time_ops __initdata = {
ca50a5f3	439	.sched_clock = xen_clocksource_read,
409771d2 SS	440	};
	441
	442	static __init void xen_time_init(void)
15c84731 JF	443	{
15c84731 JF	444	int cpu = smp_processor_id();
c4507257	445	struct timespec tp;
15c84731	446
15c84731 JF	447	clocksource_register(&xen_clocksource);
	448
	449	if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL) == 0) {
f91a8b44	450	/* Successfully turned off 100Hz tick, so we have the
15c84731 JF	451	vcpuop-based timer interface */
	452	printk(KERN_DEBUG "Xen: using vcpuop timer interface\n");
	453	xen_clockevent = &xen_vcpuop_clockevent;
	454	}
	455
	456	/* Set initial system time with full resolution */
c4507257 JS	457	xen_read_wallclock(&tp);
c4507257 JS	458	do_settimeofday(&tp);
15c84731	459
404ee5b1	460	setup_force_cpu_cap(X86_FEATURE_TSC);
15c84731	461
be012920	462	xen_setup_runstate_info(cpu);
15c84731	463	xen_setup_timer(cpu);
f87e4cac	464	xen_setup_cpu_clockevents();
15c84731	465	}
409771d2 SS	466
	467	__init void xen_init_time_ops(void)
	468	{
	469	pv_time_ops = xen_time_ops;
	470
	471	x86_init.timers.timer_init = xen_time_init;
	472	x86_init.timers.setup_percpu_clockev = x86_init_noop;
	473	x86_cpuinit.setup_percpu_clockev = x86_init_noop;
	474
	475	x86_platform.calibrate_tsc = xen_tsc_khz;
	476	x86_platform.get_wallclock = xen_get_wallclock;
	477	x86_platform.set_wallclock = xen_set_wallclock;
	478	}
	479
ca65f9fc	480	#ifdef CONFIG_XEN_PVHVM
409771d2 SS	481	static void xen_hvm_setup_cpu_clockevents(void)
	482	{
	483	int cpu = smp_processor_id();
	484	xen_setup_runstate_info(cpu);
	485	xen_setup_timer(cpu);
	486	xen_setup_cpu_clockevents();
	487	}
	488
	489	__init void xen_hvm_init_time_ops(void)
	490	{
	491	/* vector callback is needed otherwise we cannot receive interrupts
31e7e931 SS	492	* on cpu > 0 and at this point we don't know how many cpus are
	493	* available */
	494	if (!xen_have_vector_callback)
409771d2 SS	495	return;
	496	if (!xen_feature(XENFEAT_hvm_safe_pvclock)) {
	497	printk(KERN_INFO "Xen doesn't support pvclock on HVM,"
	498	"disable pv timer\n");
	499	return;
	500	}
	501
	502	pv_time_ops = xen_time_ops;
	503	x86_init.timers.setup_percpu_clockev = xen_time_init;
	504	x86_cpuinit.setup_percpu_clockev = xen_hvm_setup_cpu_clockevents;
	505
	506	x86_platform.calibrate_tsc = xen_tsc_khz;
	507	x86_platform.get_wallclock = xen_get_wallclock;
	508	x86_platform.set_wallclock = xen_set_wallclock;
	509	}
ca65f9fc	510	#endif