[linux-2.6-block.git] / arch / ia64 / xen / xen_pv_ops.c

/******************************************************************************
 * arch/ia64/xen/xen_pv_ops.c
 *
 * Copyright (c) 2008 Isaku Yamahata <yamahata at valinux co jp>
 *                    VA Linux Systems Japan K.K.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <linux/console.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/pm.h>
#include <linux/unistd.h>

#include <asm/xen/hypervisor.h>
#include <asm/xen/xencomm.h>
#include <asm/xen/privop.h>

#include "irq_xen.h"
#include "time.h"

/***************************************************************************
 * general info
 */
static struct pv_info xen_info __initdata = {
	.kernel_rpl = 2,	/* or 1: determin at runtime */
	.paravirt_enabled = 1,
	.name = "Xen/ia64",
};

#define IA64_RSC_PL_SHIFT	2
#define IA64_RSC_PL_BIT_SIZE	2
#define IA64_RSC_PL_MASK	\
	(((1UL << IA64_RSC_PL_BIT_SIZE) - 1) << IA64_RSC_PL_SHIFT)

static void __init
xen_info_init(void)
{
	/* Xenified Linux/ia64 may run on pl = 1 or 2.
	 * determin at run time. */
	unsigned long rsc = ia64_getreg(_IA64_REG_AR_RSC);
	unsigned int rpl = (rsc & IA64_RSC_PL_MASK) >> IA64_RSC_PL_SHIFT;
	xen_info.kernel_rpl = rpl;
}

/***************************************************************************
 * pv_init_ops
 * initialization hooks.
 */

static void
xen_panic_hypercall(struct unw_frame_info *info, void *arg)
{
	current->thread.ksp = (__u64)info->sw - 16;
	HYPERVISOR_shutdown(SHUTDOWN_crash);
	/* we're never actually going to get here... */
}

static int
xen_panic_event(struct notifier_block *this, unsigned long event, void *ptr)
{
	unw_init_running(xen_panic_hypercall, NULL);
	/* we're never actually going to get here... */
	return NOTIFY_DONE;
}

static struct notifier_block xen_panic_block = {
	xen_panic_event, NULL, 0 /* try to go last */
};

static void xen_pm_power_off(void)
{
	local_irq_disable();
	HYPERVISOR_shutdown(SHUTDOWN_poweroff);
}

static void __init
xen_banner(void)
{
	printk(KERN_INFO
	       "Running on Xen! pl = %d start_info_pfn=0x%lx nr_pages=%ld "
	       "flags=0x%x\n",
	       xen_info.kernel_rpl,
	       HYPERVISOR_shared_info->arch.start_info_pfn,
	       xen_start_info->nr_pages, xen_start_info->flags);
}

static int __init
xen_reserve_memory(struct rsvd_region *region)
{
	region->start = (unsigned long)__va(
		(HYPERVISOR_shared_info->arch.start_info_pfn << PAGE_SHIFT));
	region->end   = region->start + PAGE_SIZE;
	return 1;
}

static void __init
xen_arch_setup_early(void)
{
	struct shared_info *s;
	BUG_ON(!xen_pv_domain());

	s = HYPERVISOR_shared_info;
	xen_start_info = __va(s->arch.start_info_pfn << PAGE_SHIFT);

	/* Must be done before any hypercall.  */
	xencomm_initialize();

	xen_setup_features();
	/* Register a call for panic conditions. */
	atomic_notifier_chain_register(&panic_notifier_list,
				       &xen_panic_block);
	pm_power_off = xen_pm_power_off;

	xen_ia64_enable_opt_feature();
}

static void __init
xen_arch_setup_console(char **cmdline_p)
{
	add_preferred_console("xenboot", 0, NULL);
	add_preferred_console("tty", 0, NULL);
	/* use hvc_xen */
	add_preferred_console("hvc", 0, NULL);

#if !defined(CONFIG_VT) || !defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = NULL;
#endif
}

static int __init
xen_arch_setup_nomca(void)
{
	return 1;
}

static void __init
xen_post_smp_prepare_boot_cpu(void)
{
	xen_setup_vcpu_info_placement();
}

static const struct pv_init_ops xen_init_ops __initconst = {
	.banner = xen_banner,

	.reserve_memory = xen_reserve_memory,

	.arch_setup_early = xen_arch_setup_early,
	.arch_setup_console = xen_arch_setup_console,
	.arch_setup_nomca = xen_arch_setup_nomca,

	.post_smp_prepare_boot_cpu = xen_post_smp_prepare_boot_cpu,
};

/***************************************************************************
 * pv_fsys_data
 * addresses for fsys
 */

extern unsigned long xen_fsyscall_table[NR_syscalls];
extern char xen_fsys_bubble_down[];
struct pv_fsys_data xen_fsys_data __initdata = {
	.fsyscall_table = (unsigned long *)xen_fsyscall_table,
	.fsys_bubble_down = (void *)xen_fsys_bubble_down,
};

/***************************************************************************
 * pv_patchdata
 * patchdata addresses
 */

#define DECLARE(name)							\
	extern unsigned long __xen_start_gate_##name##_patchlist[];	\
	extern unsigned long __xen_end_gate_##name##_patchlist[]

DECLARE(fsyscall);
DECLARE(brl_fsys_bubble_down);
DECLARE(vtop);
DECLARE(mckinley_e9);

extern unsigned long __xen_start_gate_section[];

#define ASSIGN(name)							\
	.start_##name##_patchlist =					\
		(unsigned long)__xen_start_gate_##name##_patchlist,	\
	.end_##name##_patchlist =					\
		(unsigned long)__xen_end_gate_##name##_patchlist

static struct pv_patchdata xen_patchdata __initdata = {
	ASSIGN(fsyscall),
	ASSIGN(brl_fsys_bubble_down),
	ASSIGN(vtop),
	ASSIGN(mckinley_e9),

	.gate_section = (void*)__xen_start_gate_section,
};

/***************************************************************************
 * pv_cpu_ops
 * intrinsics hooks.
 */

static void
xen_set_itm_with_offset(unsigned long val)
{
	/* ia64_cpu_local_tick() calls this with interrupt enabled. */
	/* WARN_ON(!irqs_disabled()); */
	xen_set_itm(val - XEN_MAPPEDREGS->itc_offset);
}

static unsigned long
xen_get_itm_with_offset(void)
{
	/* unused at this moment */
	printk(KERN_DEBUG "%s is called.\n", __func__);

	WARN_ON(!irqs_disabled());
	return ia64_native_getreg(_IA64_REG_CR_ITM) +
		XEN_MAPPEDREGS->itc_offset;
}

/* ia64_set_itc() is only called by
 * cpu_init() with ia64_set_itc(0) and ia64_sync_itc().
 * So XEN_MAPPEDRESG->itc_offset cal be considered as almost constant.
 */
static void
xen_set_itc(unsigned long val)
{
	unsigned long mitc;

	WARN_ON(!irqs_disabled());
	mitc = ia64_native_getreg(_IA64_REG_AR_ITC);
	XEN_MAPPEDREGS->itc_offset = val - mitc;
	XEN_MAPPEDREGS->itc_last = val;
}

static unsigned long
xen_get_itc(void)
{
	unsigned long res;
	unsigned long itc_offset;
	unsigned long itc_last;
	unsigned long ret_itc_last;

	itc_offset = XEN_MAPPEDREGS->itc_offset;
	do {
		itc_last = XEN_MAPPEDREGS->itc_last;
		res = ia64_native_getreg(_IA64_REG_AR_ITC);
		res += itc_offset;
		if (itc_last >= res)
			res = itc_last + 1;
		ret_itc_last = cmpxchg(&XEN_MAPPEDREGS->itc_last,
				       itc_last, res);
	} while (unlikely(ret_itc_last != itc_last));
	return res;

#if 0
	/* ia64_itc_udelay() calls ia64_get_itc() with interrupt enabled.
	   Should it be paravirtualized instead? */
	WARN_ON(!irqs_disabled());
	itc_offset = XEN_MAPPEDREGS->itc_offset;
	itc_last = XEN_MAPPEDREGS->itc_last;
	res = ia64_native_getreg(_IA64_REG_AR_ITC);
	res += itc_offset;
	if (itc_last >= res)
		res = itc_last + 1;
	XEN_MAPPEDREGS->itc_last = res;
	return res;
#endif
}

static void xen_setreg(int regnum, unsigned long val)
{
	switch (regnum) {
	case _IA64_REG_AR_KR0 ... _IA64_REG_AR_KR7:
		xen_set_kr(regnum - _IA64_REG_AR_KR0, val);
		break;
#ifdef CONFIG_IA32_SUPPORT
	case _IA64_REG_AR_EFLAG:
		xen_set_eflag(val);
		break;
#endif
	case _IA64_REG_AR_ITC:
		xen_set_itc(val);
		break;
	case _IA64_REG_CR_TPR:
		xen_set_tpr(val);
		break;
	case _IA64_REG_CR_ITM:
		xen_set_itm_with_offset(val);
		break;
	case _IA64_REG_CR_EOI:
		xen_eoi(val);
		break;
	default:
		ia64_native_setreg_func(regnum, val);
		break;
	}
}

static unsigned long xen_getreg(int regnum)
{
	unsigned long res;

	switch (regnum) {
	case _IA64_REG_PSR:
		res = xen_get_psr();
		break;
#ifdef CONFIG_IA32_SUPPORT
	case _IA64_REG_AR_EFLAG:
		res = xen_get_eflag();
		break;
#endif
	case _IA64_REG_AR_ITC:
		res = xen_get_itc();
		break;
	case _IA64_REG_CR_ITM:
		res = xen_get_itm_with_offset();
		break;
	case _IA64_REG_CR_IVR:
		res = xen_get_ivr();
		break;
	case _IA64_REG_CR_TPR:
		res = xen_get_tpr();
		break;
	default:
		res = ia64_native_getreg_func(regnum);
		break;
	}
	return res;
}

/* turning on interrupts is a bit more complicated.. write to the
 * memory-mapped virtual psr.i bit first (to avoid race condition),
 * then if any interrupts were pending, we have to execute a hyperprivop
 * to ensure the pending interrupt gets delivered; else we're done! */
static void
xen_ssm_i(void)
{
	int old = xen_get_virtual_psr_i();
	xen_set_virtual_psr_i(1);
	barrier();
	if (!old && xen_get_virtual_pend())
		xen_hyper_ssm_i();
}

/* turning off interrupts can be paravirtualized simply by writing
 * to a memory-mapped virtual psr.i bit (implemented as a 16-bit bool) */
static void
xen_rsm_i(void)
{
	xen_set_virtual_psr_i(0);
	barrier();
}

static unsigned long
xen_get_psr_i(void)
{
	return xen_get_virtual_psr_i() ? IA64_PSR_I : 0;
}

static void
xen_intrin_local_irq_restore(unsigned long mask)
{
	if (mask & IA64_PSR_I)
		xen_ssm_i();
	else
		xen_rsm_i();
}

static const struct pv_cpu_ops xen_cpu_ops __initconst = {
	.fc		= xen_fc,
	.thash		= xen_thash,
	.get_cpuid	= xen_get_cpuid,
	.get_pmd	= xen_get_pmd,
	.getreg		= xen_getreg,
	.setreg		= xen_setreg,
	.ptcga		= xen_ptcga,
	.get_rr		= xen_get_rr,
	.set_rr		= xen_set_rr,
	.set_rr0_to_rr4	= xen_set_rr0_to_rr4,
	.ssm_i		= xen_ssm_i,
	.rsm_i		= xen_rsm_i,
	.get_psr_i	= xen_get_psr_i,
	.intrin_local_irq_restore
			= xen_intrin_local_irq_restore,
};

/******************************************************************************
 * replacement of hand written assembly codes.
 */

extern char xen_switch_to;
extern char xen_leave_syscall;
extern char xen_work_processed_syscall;
extern char xen_leave_kernel;

const struct pv_cpu_asm_switch xen_cpu_asm_switch = {
	.switch_to		= (unsigned long)&xen_switch_to,
	.leave_syscall		= (unsigned long)&xen_leave_syscall,
	.work_processed_syscall	= (unsigned long)&xen_work_processed_syscall,
	.leave_kernel		= (unsigned long)&xen_leave_kernel,
};

/***************************************************************************
 * pv_iosapic_ops
 * iosapic read/write hooks.
 */
static void
xen_pcat_compat_init(void)
{
	/* nothing */
}

static struct irq_chip*
xen_iosapic_get_irq_chip(unsigned long trigger)
{
	return NULL;
}

static unsigned int
xen_iosapic_read(char __iomem *iosapic, unsigned int reg)
{
	struct physdev_apic apic_op;
	int ret;

	apic_op.apic_physbase = (unsigned long)iosapic -
					__IA64_UNCACHED_OFFSET;
	apic_op.reg = reg;
	ret = HYPERVISOR_physdev_op(PHYSDEVOP_apic_read, &apic_op);
	if (ret)
		return ret;
	return apic_op.value;
}

static void
xen_iosapic_write(char __iomem *iosapic, unsigned int reg, u32 val)
{
	struct physdev_apic apic_op;

	apic_op.apic_physbase = (unsigned long)iosapic -
					__IA64_UNCACHED_OFFSET;
	apic_op.reg = reg;
	apic_op.value = val;
	HYPERVISOR_physdev_op(PHYSDEVOP_apic_write, &apic_op);
}

static const struct pv_iosapic_ops xen_iosapic_ops __initconst = {
	.pcat_compat_init = xen_pcat_compat_init,
	.__get_irq_chip = xen_iosapic_get_irq_chip,

	.__read = xen_iosapic_read,
	.__write = xen_iosapic_write,
};

/***************************************************************************
 * pv_ops initialization
 */

void __init
xen_setup_pv_ops(void)
{
	xen_info_init();
	pv_info = xen_info;
	pv_init_ops = xen_init_ops;
	pv_fsys_data = xen_fsys_data;
	pv_patchdata = xen_patchdata;
	pv_cpu_ops = xen_cpu_ops;
	pv_iosapic_ops = xen_iosapic_ops;
	pv_irq_ops = xen_irq_ops;
	pv_time_ops = xen_time_ops;

	paravirt_cpu_asm_init(&xen_cpu_asm_switch);
}
Commit	Line	Data
080104cd IY	1	/******************************************************************************
	2	* arch/ia64/xen/xen_pv_ops.c
	3	*
	4	* Copyright (c) 2008 Isaku Yamahata <yamahata at valinux co jp>
	5	* VA Linux Systems Japan K.K.
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*
	21	*/
	22
	23	#include <linux/console.h>
	24	#include <linux/irq.h>
	25	#include <linux/kernel.h>
	26	#include <linux/pm.h>
533bd156	27	#include <linux/unistd.h>
080104cd IY	28
	29	#include <asm/xen/hypervisor.h>
	30	#include <asm/xen/xencomm.h>
	31	#include <asm/xen/privop.h>
	32
7477de98	33	#include "irq_xen.h"
dcbbecda	34	#include "time.h"
7477de98	35
080104cd IY	36	/***************************************************************************
	37	* general info
	38	*/
	39	static struct pv_info xen_info __initdata = {
	40	.kernel_rpl = 2, /* or 1: determin at runtime */
	41	.paravirt_enabled = 1,
	42	.name = "Xen/ia64",
	43	};
	44
	45	#define IA64_RSC_PL_SHIFT 2
	46	#define IA64_RSC_PL_BIT_SIZE 2
	47	#define IA64_RSC_PL_MASK \
	48	(((1UL << IA64_RSC_PL_BIT_SIZE) - 1) << IA64_RSC_PL_SHIFT)
	49
	50	static void __init
	51	xen_info_init(void)
	52	{
	53	/* Xenified Linux/ia64 may run on pl = 1 or 2.
	54	* determin at run time. */
	55	unsigned long rsc = ia64_getreg(_IA64_REG_AR_RSC);
	56	unsigned int rpl = (rsc & IA64_RSC_PL_MASK) >> IA64_RSC_PL_SHIFT;
	57	xen_info.kernel_rpl = rpl;
	58	}
	59
b5a26e4d IY	60	/***************************************************************************
	61	* pv_init_ops
	62	* initialization hooks.
	63	*/
	64
	65	static void
	66	xen_panic_hypercall(struct unw_frame_info info, void arg)
	67	{
	68	current->thread.ksp = (__u64)info->sw - 16;
	69	HYPERVISOR_shutdown(SHUTDOWN_crash);
	70	/* we're never actually going to get here... */
	71	}
	72
	73	static int
	74	xen_panic_event(struct notifier_block this, unsigned long event, void ptr)
	75	{
	76	unw_init_running(xen_panic_hypercall, NULL);
	77	/* we're never actually going to get here... */
	78	return NOTIFY_DONE;
	79	}
	80
	81	static struct notifier_block xen_panic_block = {
	82	xen_panic_event, NULL, 0 /* try to go last */
	83	};
	84
	85	static void xen_pm_power_off(void)
	86	{
	87	local_irq_disable();
	88	HYPERVISOR_shutdown(SHUTDOWN_poweroff);
	89	}
	90
	91	static void __init
	92	xen_banner(void)
	93	{
	94	printk(KERN_INFO
	95	"Running on Xen! pl = %d start_info_pfn=0x%lx nr_pages=%ld "
	96	"flags=0x%x\n",
	97	xen_info.kernel_rpl,
	98	HYPERVISOR_shared_info->arch.start_info_pfn,
	99	xen_start_info->nr_pages, xen_start_info->flags);
	100	}
	101
	102	static int __init
	103	xen_reserve_memory(struct rsvd_region *region)
	104	{
	105	region->start = (unsigned long)__va(
	106	(HYPERVISOR_shared_info->arch.start_info_pfn << PAGE_SHIFT));
	107	region->end = region->start + PAGE_SIZE;
	108	return 1;
	109	}
	110
	111	static void __init
	112	xen_arch_setup_early(void)
	113	{
	114	struct shared_info *s;
	115	BUG_ON(!xen_pv_domain());
	116
	117	s = HYPERVISOR_shared_info;
	118	xen_start_info = __va(s->arch.start_info_pfn << PAGE_SHIFT);
	119
	120	/* Must be done before any hypercall. */
	121	xencomm_initialize();
	122
	123	xen_setup_features();
124	/* Register a call for panic conditions. */
125	atomic_notifier_chain_register(&panic_notifier_list,
126	&xen_panic_block);
127	pm_power_off = xen_pm_power_off;
128
129	xen_ia64_enable_opt_feature();
130	}
131
132	static void __init
133	xen_arch_setup_console(char **cmdline_p)
134	{
135	add_preferred_console("xenboot", 0, NULL);
136	add_preferred_console("tty", 0, NULL);
137	/* use hvc_xen */
138	add_preferred_console("hvc", 0, NULL);
139
140	#if !defined(CONFIG_VT) \|\| !defined(CONFIG_DUMMY_CONSOLE)
141	conswitchp = NULL;
142	#endif
143	}
144
145	static int __init
146	xen_arch_setup_nomca(void)
147	{
148	return 1;
149	}
150
151	static void __init
152	xen_post_smp_prepare_boot_cpu(void)
153	{
154	xen_setup_vcpu_info_placement();
155	}
156
ec8148de	157	static const struct pv_init_ops xen_init_ops __initconst = {
b5a26e4d IY	158	.banner = xen_banner,
	159
	160	.reserve_memory = xen_reserve_memory,
	161
	162	.arch_setup_early = xen_arch_setup_early,
	163	.arch_setup_console = xen_arch_setup_console,
	164	.arch_setup_nomca = xen_arch_setup_nomca,
	165
	166	.post_smp_prepare_boot_cpu = xen_post_smp_prepare_boot_cpu,
	167	};
	168
533bd156 IY	169	/***************************************************************************
	170	* pv_fsys_data
	171	* addresses for fsys
	172	*/
	173
	174	extern unsigned long xen_fsyscall_table[NR_syscalls];
	175	extern char xen_fsys_bubble_down[];
	176	struct pv_fsys_data xen_fsys_data __initdata = {
	177	.fsyscall_table = (unsigned long *)xen_fsyscall_table,
	178	.fsys_bubble_down = (void *)xen_fsys_bubble_down,
	179	};
	180
b937dd76 IY	181	/***************************************************************************
	182	* pv_patchdata
	183	* patchdata addresses
	184	*/
	185
	186	#define DECLARE(name) \
	187	extern unsigned long __xen_start_gate_##name##_patchlist[]; \
	188	extern unsigned long __xen_end_gate_##name##_patchlist[]
	189
	190	DECLARE(fsyscall);
	191	DECLARE(brl_fsys_bubble_down);
	192	DECLARE(vtop);
	193	DECLARE(mckinley_e9);
	194
	195	extern unsigned long __xen_start_gate_section[];
	196
	197	#define ASSIGN(name) \
	198	.start_##name##_patchlist = \
	199	(unsigned long)__xen_start_gate_##name##_patchlist, \
	200	.end_##name##_patchlist = \
	201	(unsigned long)__xen_end_gate_##name##_patchlist
	202
	203	static struct pv_patchdata xen_patchdata __initdata = {
	204	ASSIGN(fsyscall),
	205	ASSIGN(brl_fsys_bubble_down),
	206	ASSIGN(vtop),
	207	ASSIGN(mckinley_e9),
	208
	209	.gate_section = (void*)__xen_start_gate_section,
	210	};
	211
4b83ce43 IY	212	/***************************************************************************
	213	* pv_cpu_ops
	214	* intrinsics hooks.
	215	*/
	216
496203b1 IY	217	static void
	218	xen_set_itm_with_offset(unsigned long val)
	219	{
	220	/* ia64_cpu_local_tick() calls this with interrupt enabled. */
	221	/* WARN_ON(!irqs_disabled()); */
	222	xen_set_itm(val - XEN_MAPPEDREGS->itc_offset);
	223	}
	224
	225	static unsigned long
	226	xen_get_itm_with_offset(void)
	227	{
	228	/* unused at this moment */
	229	printk(KERN_DEBUG "%s is called.\n", __func__);
	230
	231	WARN_ON(!irqs_disabled());
	232	return ia64_native_getreg(_IA64_REG_CR_ITM) +
	233	XEN_MAPPEDREGS->itc_offset;
	234	}
	235
	236	/* ia64_set_itc() is only called by
	237	* cpu_init() with ia64_set_itc(0) and ia64_sync_itc().
	238	* So XEN_MAPPEDRESG->itc_offset cal be considered as almost constant.
	239	*/
	240	static void
	241	xen_set_itc(unsigned long val)
	242	{
	243	unsigned long mitc;
	244
	245	WARN_ON(!irqs_disabled());
	246	mitc = ia64_native_getreg(_IA64_REG_AR_ITC);
	247	XEN_MAPPEDREGS->itc_offset = val - mitc;
	248	XEN_MAPPEDREGS->itc_last = val;
	249	}
	250
	251	static unsigned long
	252	xen_get_itc(void)
	253	{
	254	unsigned long res;
	255	unsigned long itc_offset;
	256	unsigned long itc_last;
	257	unsigned long ret_itc_last;
	258
	259	itc_offset = XEN_MAPPEDREGS->itc_offset;
	260	do {
	261	itc_last = XEN_MAPPEDREGS->itc_last;
	262	res = ia64_native_getreg(_IA64_REG_AR_ITC);
	263	res += itc_offset;
	264	if (itc_last >= res)
	265	res = itc_last + 1;
	266	ret_itc_last = cmpxchg(&XEN_MAPPEDREGS->itc_last,
	267	itc_last, res);
	268	} while (unlikely(ret_itc_last != itc_last));
	269	return res;
	270
	271	#if 0
	272	/* ia64_itc_udelay() calls ia64_get_itc() with interrupt enabled.
	273	Should it be paravirtualized instead? */
	274	WARN_ON(!irqs_disabled());
	275	itc_offset = XEN_MAPPEDREGS->itc_offset;
	276	itc_last = XEN_MAPPEDREGS->itc_last;
	277	res = ia64_native_getreg(_IA64_REG_AR_ITC);
	278	res += itc_offset;
	279	if (itc_last >= res)
	280	res = itc_last + 1;
281	XEN_MAPPEDREGS->itc_last = res;
282	return res;
283	#endif
284	}
285
4b83ce43 IY	286	static void xen_setreg(int regnum, unsigned long val)
	287	{
	288	switch (regnum) {
	289	case _IA64_REG_AR_KR0 ... _IA64_REG_AR_KR7:
	290	xen_set_kr(regnum - _IA64_REG_AR_KR0, val);
	291	break;
	292	#ifdef CONFIG_IA32_SUPPORT
	293	case _IA64_REG_AR_EFLAG:
	294	xen_set_eflag(val);
	295	break;
	296	#endif
496203b1 IY	297	case _IA64_REG_AR_ITC:
	298	xen_set_itc(val);
	299	break;
4b83ce43 IY	300	case _IA64_REG_CR_TPR:
	301	xen_set_tpr(val);
	302	break;
	303	case _IA64_REG_CR_ITM:
496203b1	304	xen_set_itm_with_offset(val);
4b83ce43 IY	305	break;
	306	case _IA64_REG_CR_EOI:
	307	xen_eoi(val);
	308	break;
	309	default:
	310	ia64_native_setreg_func(regnum, val);
	311	break;
	312	}
	313	}
	314
	315	static unsigned long xen_getreg(int regnum)
	316	{
	317	unsigned long res;
	318
	319	switch (regnum) {
	320	case _IA64_REG_PSR:
	321	res = xen_get_psr();
	322	break;
	323	#ifdef CONFIG_IA32_SUPPORT
	324	case _IA64_REG_AR_EFLAG:
	325	res = xen_get_eflag();
	326	break;
	327	#endif
496203b1 IY	328	case _IA64_REG_AR_ITC:
	329	res = xen_get_itc();
	330	break;
	331	case _IA64_REG_CR_ITM:
	332	res = xen_get_itm_with_offset();
	333	break;
4b83ce43 IY	334	case _IA64_REG_CR_IVR:
	335	res = xen_get_ivr();
	336	break;
	337	case _IA64_REG_CR_TPR:
	338	res = xen_get_tpr();
	339	break;
	340	default:
	341	res = ia64_native_getreg_func(regnum);
	342	break;
	343	}
	344	return res;
	345	}
	346
	347	/* turning on interrupts is a bit more complicated.. write to the
	348	* memory-mapped virtual psr.i bit first (to avoid race condition),
	349	* then if any interrupts were pending, we have to execute a hyperprivop
	350	* to ensure the pending interrupt gets delivered; else we're done! */
	351	static void
	352	xen_ssm_i(void)
	353	{
	354	int old = xen_get_virtual_psr_i();
	355	xen_set_virtual_psr_i(1);
	356	barrier();
	357	if (!old && xen_get_virtual_pend())
	358	xen_hyper_ssm_i();
	359	}
	360
	361	/* turning off interrupts can be paravirtualized simply by writing
	362	* to a memory-mapped virtual psr.i bit (implemented as a 16-bit bool) */
	363	static void
	364	xen_rsm_i(void)
	365	{
	366	xen_set_virtual_psr_i(0);
	367	barrier();
	368	}
	369
	370	static unsigned long
	371	xen_get_psr_i(void)
	372	{
	373	return xen_get_virtual_psr_i() ? IA64_PSR_I : 0;
	374	}
	375
	376	static void
	377	xen_intrin_local_irq_restore(unsigned long mask)
	378	{
	379	if (mask & IA64_PSR_I)
	380	xen_ssm_i();
	381	else
	382	xen_rsm_i();
	383	}
	384
e8c3b420	385	static const struct pv_cpu_ops xen_cpu_ops __initconst = {
4b83ce43 IY	386	.fc = xen_fc,
	387	.thash = xen_thash,
	388	.get_cpuid = xen_get_cpuid,
	389	.get_pmd = xen_get_pmd,
	390	.getreg = xen_getreg,
	391	.setreg = xen_setreg,
	392	.ptcga = xen_ptcga,
	393	.get_rr = xen_get_rr,
	394	.set_rr = xen_set_rr,
	395	.set_rr0_to_rr4 = xen_set_rr0_to_rr4,
	396	.ssm_i = xen_ssm_i,
	397	.rsm_i = xen_rsm_i,
	398	.get_psr_i = xen_get_psr_i,
	399	.intrin_local_irq_restore
	400	= xen_intrin_local_irq_restore,
	401	};
	402
16583bc0 IY	403	/******************************************************************************
	404	* replacement of hand written assembly codes.
	405	*/
	406
	407	extern char xen_switch_to;
	408	extern char xen_leave_syscall;
	409	extern char xen_work_processed_syscall;
	410	extern char xen_leave_kernel;
	411
	412	const struct pv_cpu_asm_switch xen_cpu_asm_switch = {
	413	.switch_to = (unsigned long)&xen_switch_to,
	414	.leave_syscall = (unsigned long)&xen_leave_syscall,
	415	.work_processed_syscall = (unsigned long)&xen_work_processed_syscall,
	416	.leave_kernel = (unsigned long)&xen_leave_kernel,
	417	};
	418
bcdd4873 IY	419	/***************************************************************************
	420	* pv_iosapic_ops
	421	* iosapic read/write hooks.
	422	*/
	423	static void
	424	xen_pcat_compat_init(void)
	425	{
	426	/* nothing */
	427	}
	428
	429	static struct irq_chip*
	430	xen_iosapic_get_irq_chip(unsigned long trigger)
	431	{
	432	return NULL;
	433	}
	434
	435	static unsigned int
	436	xen_iosapic_read(char __iomem *iosapic, unsigned int reg)
	437	{
	438	struct physdev_apic apic_op;
	439	int ret;
	440
	441	apic_op.apic_physbase = (unsigned long)iosapic -
	442	__IA64_UNCACHED_OFFSET;
	443	apic_op.reg = reg;
	444	ret = HYPERVISOR_physdev_op(PHYSDEVOP_apic_read, &apic_op);
	445	if (ret)
	446	return ret;
	447	return apic_op.value;
	448	}
	449
	450	static void
	451	xen_iosapic_write(char __iomem *iosapic, unsigned int reg, u32 val)
	452	{
	453	struct physdev_apic apic_op;
	454
	455	apic_op.apic_physbase = (unsigned long)iosapic -
	456	__IA64_UNCACHED_OFFSET;
	457	apic_op.reg = reg;
	458	apic_op.value = val;
	459	HYPERVISOR_physdev_op(PHYSDEVOP_apic_write, &apic_op);
	460	}
	461
ec8148de	462	static const struct pv_iosapic_ops xen_iosapic_ops __initconst = {
bcdd4873 IY	463	.pcat_compat_init = xen_pcat_compat_init,
	464	.__get_irq_chip = xen_iosapic_get_irq_chip,
	465
	466	.__read = xen_iosapic_read,
	467	.__write = xen_iosapic_write,
	468	};
	469
080104cd IY	470	/***************************************************************************
	471	* pv_ops initialization
	472	*/
	473
	474	void __init
	475	xen_setup_pv_ops(void)
	476	{
	477	xen_info_init();
	478	pv_info = xen_info;
b5a26e4d	479	pv_init_ops = xen_init_ops;
533bd156	480	pv_fsys_data = xen_fsys_data;
b937dd76	481	pv_patchdata = xen_patchdata;
4b83ce43	482	pv_cpu_ops = xen_cpu_ops;
bcdd4873	483	pv_iosapic_ops = xen_iosapic_ops;
7477de98	484	pv_irq_ops = xen_irq_ops;
dcbbecda	485	pv_time_ops = xen_time_ops;
16583bc0 IY	486
16583bc0 IY	487	paravirt_cpu_asm_init(&xen_cpu_asm_switch);
080104cd	488	}