[mirror_ubuntu-artful-kernel.git] / arch / arm / xen / enlighten.c

#include <xen/xen.h>
#include <xen/events.h>
#include <xen/grant_table.h>
#include <xen/hvm.h>
#include <xen/interface/xen.h>
#include <xen/interface/memory.h>
#include <xen/interface/hvm/params.h>
#include <xen/features.h>
#include <xen/platform_pci.h>
#include <xen/xenbus.h>
#include <xen/page.h>
#include <asm/xen/hypervisor.h>
#include <asm/xen/hypercall.h>
#include <linux/interrupt.h>
#include <linux/irqreturn.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_address.h>

struct start_info _xen_start_info;
struct start_info *xen_start_info = &_xen_start_info;
EXPORT_SYMBOL_GPL(xen_start_info);

enum xen_domain_type xen_domain_type = XEN_NATIVE;
EXPORT_SYMBOL_GPL(xen_domain_type);

struct shared_info xen_dummy_shared_info;
struct shared_info *HYPERVISOR_shared_info = (void *)&xen_dummy_shared_info;

DEFINE_PER_CPU(struct vcpu_info *, xen_vcpu);

/* These are unused until we support booting "pre-ballooned" */
unsigned long xen_released_pages;
struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata;

/* TODO: to be removed */
__read_mostly int xen_have_vector_callback;
EXPORT_SYMBOL_GPL(xen_have_vector_callback);

int xen_platform_pci_unplug = XEN_UNPLUG_ALL;
EXPORT_SYMBOL_GPL(xen_platform_pci_unplug);

static __read_mostly int xen_events_irq = -1;

int xen_remap_domain_mfn_range(struct vm_area_struct *vma,
			       unsigned long addr,
			       unsigned long mfn, int nr,
			       pgprot_t prot, unsigned domid)
{
	return -ENOSYS;
}
EXPORT_SYMBOL_GPL(xen_remap_domain_mfn_range);

/*
 * see Documentation/devicetree/bindings/arm/xen.txt for the
 * documentation of the Xen Device Tree format.
 */
#define GRANT_TABLE_PHYSADDR 0
static int __init xen_guest_init(void)
{
	struct xen_add_to_physmap xatp;
	static struct shared_info *shared_info_page = 0;
	struct device_node *node;
	int len;
	const char *s = NULL;
	const char *version = NULL;
	const char *xen_prefix = "xen,xen-";
	struct resource res;

	node = of_find_compatible_node(NULL, NULL, "xen,xen");
	if (!node) {
		pr_debug("No Xen support\n");
		return 0;
	}
	s = of_get_property(node, "compatible", &len);
	if (strlen(xen_prefix) + 3  < len &&
			!strncmp(xen_prefix, s, strlen(xen_prefix)))
		version = s + strlen(xen_prefix);
	if (version == NULL) {
		pr_debug("Xen version not found\n");
		return 0;
	}
	if (of_address_to_resource(node, GRANT_TABLE_PHYSADDR, &res))
		return 0;
	xen_hvm_resume_frames = res.start >> PAGE_SHIFT;
	xen_events_irq = irq_of_parse_and_map(node, 0);
	pr_info("Xen %s support found, events_irq=%d gnttab_frame_pfn=%lx\n",
			version, xen_events_irq, xen_hvm_resume_frames);
	xen_domain_type = XEN_HVM_DOMAIN;

	xen_setup_features();
	if (xen_feature(XENFEAT_dom0))
		xen_start_info->flags |= SIF_INITDOMAIN|SIF_PRIVILEGED;
	else
		xen_start_info->flags &= ~(SIF_INITDOMAIN|SIF_PRIVILEGED);

	if (!shared_info_page)
		shared_info_page = (struct shared_info *)
			get_zeroed_page(GFP_KERNEL);
	if (!shared_info_page) {
		pr_err("not enough memory\n");
		return -ENOMEM;
	}
	xatp.domid = DOMID_SELF;
	xatp.idx = 0;
	xatp.space = XENMAPSPACE_shared_info;
	xatp.gpfn = __pa(shared_info_page) >> PAGE_SHIFT;
	if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp))
		BUG();

	HYPERVISOR_shared_info = (struct shared_info *)shared_info_page;

	/* xen_vcpu is a pointer to the vcpu_info struct in the shared_info
	 * page, we use it in the event channel upcall and in some pvclock
	 * related functions. We don't need the vcpu_info placement
	 * optimizations because we don't use any pv_mmu or pv_irq op on
	 * HVM.
	 * The shared info contains exactly 1 CPU (the boot CPU). The guest
	 * is required to use VCPUOP_register_vcpu_info to place vcpu info
	 * for secondary CPUs as they are brought up. */
	per_cpu(xen_vcpu, 0) = &HYPERVISOR_shared_info->vcpu_info[0];

	gnttab_init();
	if (!xen_initial_domain())
		xenbus_probe(NULL);

	return 0;
}
core_initcall(xen_guest_init);

static irqreturn_t xen_arm_callback(int irq, void *arg)
{
	xen_hvm_evtchn_do_upcall();
	return IRQ_HANDLED;
}

static int __init xen_init_events(void)
{
	if (!xen_domain() || xen_events_irq < 0)
		return -ENODEV;

	xen_init_IRQ();

	if (request_percpu_irq(xen_events_irq, xen_arm_callback,
			"events", xen_vcpu)) {
		pr_err("Error requesting IRQ %d\n", xen_events_irq);
		return -EINVAL;
	}

	enable_percpu_irq(xen_events_irq, 0);

	return 0;
}
postcore_initcall(xen_init_events);
Commit	Line	Data
4c071ee5	1	#include <xen/xen.h>
0ec53ecf	2	#include <xen/events.h>
b3b52fd8 SS	3	#include <xen/grant_table.h>
b3b52fd8 SS	4	#include <xen/hvm.h>
4c071ee5 SS	5	#include <xen/interface/xen.h>
4c071ee5 SS	6	#include <xen/interface/memory.h>
b3b52fd8	7	#include <xen/interface/hvm/params.h>
ef61ee0d	8	#include <xen/features.h>
4c071ee5	9	#include <xen/platform_pci.h>
b3b52fd8	10	#include <xen/xenbus.h>
c61ba729	11	#include <xen/page.h>
4c071ee5 SS	12	#include <asm/xen/hypervisor.h>
4c071ee5 SS	13	#include <asm/xen/hypercall.h>
0ec53ecf SS	14	#include <linux/interrupt.h>
0ec53ecf SS	15	#include <linux/irqreturn.h>
4c071ee5	16	#include <linux/module.h>
2e01f166 SS	17	#include <linux/of.h>
	18	#include <linux/of_irq.h>
	19	#include <linux/of_address.h>
4c071ee5 SS	20
	21	struct start_info _xen_start_info;
	22	struct start_info *xen_start_info = &_xen_start_info;
	23	EXPORT_SYMBOL_GPL(xen_start_info);
	24
	25	enum xen_domain_type xen_domain_type = XEN_NATIVE;
	26	EXPORT_SYMBOL_GPL(xen_domain_type);
	27
	28	struct shared_info xen_dummy_shared_info;
	29	struct shared_info HYPERVISOR_shared_info = (void )&xen_dummy_shared_info;
	30
	31	DEFINE_PER_CPU(struct vcpu_info *, xen_vcpu);
	32
c61ba729 IC	33	/* These are unused until we support booting "pre-ballooned" */
	34	unsigned long xen_released_pages;
	35	struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata;
	36
4c071ee5 SS	37	/* TODO: to be removed */
	38	__read_mostly int xen_have_vector_callback;
	39	EXPORT_SYMBOL_GPL(xen_have_vector_callback);
	40
	41	int xen_platform_pci_unplug = XEN_UNPLUG_ALL;
	42	EXPORT_SYMBOL_GPL(xen_platform_pci_unplug);
	43
0ec53ecf SS	44	static __read_mostly int xen_events_irq = -1;
0ec53ecf SS	45
4c071ee5 SS	46	int xen_remap_domain_mfn_range(struct vm_area_struct *vma,
	47	unsigned long addr,
	48	unsigned long mfn, int nr,
	49	pgprot_t prot, unsigned domid)
	50	{
	51	return -ENOSYS;
	52	}
	53	EXPORT_SYMBOL_GPL(xen_remap_domain_mfn_range);
2e01f166 SS	54
	55	/*
	56	* see Documentation/devicetree/bindings/arm/xen.txt for the
	57	* documentation of the Xen Device Tree format.
	58	*/
b3b52fd8	59	#define GRANT_TABLE_PHYSADDR 0
2e01f166 SS	60	static int __init xen_guest_init(void)
	61	{
	62	struct xen_add_to_physmap xatp;
	63	static struct shared_info *shared_info_page = 0;
	64	struct device_node *node;
	65	int len;
	66	const char *s = NULL;
	67	const char *version = NULL;
	68	const char *xen_prefix = "xen,xen-";
b3b52fd8	69	struct resource res;
2e01f166 SS	70
	71	node = of_find_compatible_node(NULL, NULL, "xen,xen");
	72	if (!node) {
	73	pr_debug("No Xen support\n");
	74	return 0;
	75	}
	76	s = of_get_property(node, "compatible", &len);
	77	if (strlen(xen_prefix) + 3 < len &&
	78	!strncmp(xen_prefix, s, strlen(xen_prefix)))
	79	version = s + strlen(xen_prefix);
	80	if (version == NULL) {
	81	pr_debug("Xen version not found\n");
	82	return 0;
	83	}
b3b52fd8 SS	84	if (of_address_to_resource(node, GRANT_TABLE_PHYSADDR, &res))
	85	return 0;
	86	xen_hvm_resume_frames = res.start >> PAGE_SHIFT;
0ec53ecf SS	87	xen_events_irq = irq_of_parse_and_map(node, 0);
	88	pr_info("Xen %s support found, events_irq=%d gnttab_frame_pfn=%lx\n",
	89	version, xen_events_irq, xen_hvm_resume_frames);
2e01f166 SS	90	xen_domain_type = XEN_HVM_DOMAIN;
2e01f166 SS	91
ef61ee0d SS	92	xen_setup_features();
	93	if (xen_feature(XENFEAT_dom0))
	94	xen_start_info->flags \|= SIF_INITDOMAIN\|SIF_PRIVILEGED;
	95	else
	96	xen_start_info->flags &= ~(SIF_INITDOMAIN\|SIF_PRIVILEGED);
	97
2e01f166 SS	98	if (!shared_info_page)
	99	shared_info_page = (struct shared_info *)
	100	get_zeroed_page(GFP_KERNEL);
	101	if (!shared_info_page) {
	102	pr_err("not enough memory\n");
	103	return -ENOMEM;
	104	}
	105	xatp.domid = DOMID_SELF;
	106	xatp.idx = 0;
	107	xatp.space = XENMAPSPACE_shared_info;
	108	xatp.gpfn = __pa(shared_info_page) >> PAGE_SHIFT;
	109	if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp))
	110	BUG();
	111
	112	HYPERVISOR_shared_info = (struct shared_info *)shared_info_page;
	113
	114	/* xen_vcpu is a pointer to the vcpu_info struct in the shared_info
	115	* page, we use it in the event channel upcall and in some pvclock
	116	* related functions. We don't need the vcpu_info placement
	117	* optimizations because we don't use any pv_mmu or pv_irq op on
	118	* HVM.
	119	* The shared info contains exactly 1 CPU (the boot CPU). The guest
	120	* is required to use VCPUOP_register_vcpu_info to place vcpu info
	121	* for secondary CPUs as they are brought up. */
	122	per_cpu(xen_vcpu, 0) = &HYPERVISOR_shared_info->vcpu_info[0];
b3b52fd8 SS	123
	124	gnttab_init();
	125	if (!xen_initial_domain())
	126	xenbus_probe(NULL);
	127
2e01f166 SS	128	return 0;
	129	}
	130	core_initcall(xen_guest_init);
0ec53ecf SS	131
	132	static irqreturn_t xen_arm_callback(int irq, void *arg)
	133	{
	134	xen_hvm_evtchn_do_upcall();
	135	return IRQ_HANDLED;
	136	}
	137
	138	static int __init xen_init_events(void)
	139	{
	140	if (!xen_domain() \|\| xen_events_irq < 0)
	141	return -ENODEV;
	142
	143	xen_init_IRQ();
	144
	145	if (request_percpu_irq(xen_events_irq, xen_arm_callback,
	146	"events", xen_vcpu)) {
	147	pr_err("Error requesting IRQ %d\n", xen_events_irq);
	148	return -EINVAL;
	149	}
	150
	151	enable_percpu_irq(xen_events_irq, 0);
	152
	153	return 0;
	154	}
	155	postcore_initcall(xen_init_events);