[deliverable/linux.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/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 */
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);
}

unsigned long xen_get_wallclock(void)
{
	struct timespec ts;

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

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

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