[linux.git] / drivers / xen / efi.c

/*
 * EFI support for Xen.
 *
 * Copyright (C) 1999 VA Linux Systems
 * Copyright (C) 1999 Walt Drummond <[email protected]>
 * Copyright (C) 1999-2002 Hewlett-Packard Co.
 *	David Mosberger-Tang <[email protected]>
 *	Stephane Eranian <[email protected]>
 * Copyright (C) 2005-2008 Intel Co.
 *	Fenghua Yu <[email protected]>
 *	Bibo Mao <[email protected]>
 *	Chandramouli Narayanan <[email protected]>
 *	Huang Ying <[email protected]>
 * Copyright (C) 2011 Novell Co.
 *	Jan Beulich <[email protected]>
 * Copyright (C) 2011-2012 Oracle Co.
 *	Liang Tang <[email protected]>
 * Copyright (c) 2014 Oracle Co., Daniel Kiper
 */

#include <linux/bug.h>
#include <linux/efi.h>
#include <linux/init.h>
#include <linux/string.h>

#include <xen/interface/xen.h>
#include <xen/interface/platform.h>
#include <xen/xen.h>
#include <xen/xen-ops.h>

#include <asm/page.h>

#include <asm/xen/hypercall.h>

#define INIT_EFI_OP(name) \
	{.cmd = XENPF_efi_runtime_call, \
	 .u.efi_runtime_call.function = XEN_EFI_##name, \
	 .u.efi_runtime_call.misc = 0}

#define efi_data(op)	(op.u.efi_runtime_call)

efi_status_t xen_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
{
	struct xen_platform_op op = INIT_EFI_OP(get_time);

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	if (tm) {
		BUILD_BUG_ON(sizeof(*tm) != sizeof(efi_data(op).u.get_time.time));
		memcpy(tm, &efi_data(op).u.get_time.time, sizeof(*tm));
	}

	if (tc) {
		tc->resolution = efi_data(op).u.get_time.resolution;
		tc->accuracy = efi_data(op).u.get_time.accuracy;
		tc->sets_to_zero = !!(efi_data(op).misc &
				      XEN_EFI_GET_TIME_SET_CLEARS_NS);
	}

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_get_time);

efi_status_t xen_efi_set_time(efi_time_t *tm)
{
	struct xen_platform_op op = INIT_EFI_OP(set_time);

	BUILD_BUG_ON(sizeof(*tm) != sizeof(efi_data(op).u.set_time));
	memcpy(&efi_data(op).u.set_time, tm, sizeof(*tm));

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_set_time);

efi_status_t xen_efi_get_wakeup_time(efi_bool_t *enabled, efi_bool_t *pending,
				     efi_time_t *tm)
{
	struct xen_platform_op op = INIT_EFI_OP(get_wakeup_time);

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	if (tm) {
		BUILD_BUG_ON(sizeof(*tm) != sizeof(efi_data(op).u.get_wakeup_time));
		memcpy(tm, &efi_data(op).u.get_wakeup_time, sizeof(*tm));
	}

	if (enabled)
		*enabled = !!(efi_data(op).misc & XEN_EFI_GET_WAKEUP_TIME_ENABLED);

	if (pending)
		*pending = !!(efi_data(op).misc & XEN_EFI_GET_WAKEUP_TIME_PENDING);

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_get_wakeup_time);

efi_status_t xen_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
{
	struct xen_platform_op op = INIT_EFI_OP(set_wakeup_time);

	BUILD_BUG_ON(sizeof(*tm) != sizeof(efi_data(op).u.set_wakeup_time));
	if (enabled)
		efi_data(op).misc = XEN_EFI_SET_WAKEUP_TIME_ENABLE;
	if (tm)
		memcpy(&efi_data(op).u.set_wakeup_time, tm, sizeof(*tm));
	else
		efi_data(op).misc |= XEN_EFI_SET_WAKEUP_TIME_ENABLE_ONLY;

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_set_wakeup_time);

efi_status_t xen_efi_get_variable(efi_char16_t *name, efi_guid_t *vendor,
				  u32 *attr, unsigned long *data_size,
				  void *data)
{
	struct xen_platform_op op = INIT_EFI_OP(get_variable);

	set_xen_guest_handle(efi_data(op).u.get_variable.name, name);
	BUILD_BUG_ON(sizeof(*vendor) !=
		     sizeof(efi_data(op).u.get_variable.vendor_guid));
	memcpy(&efi_data(op).u.get_variable.vendor_guid, vendor, sizeof(*vendor));
	efi_data(op).u.get_variable.size = *data_size;
	set_xen_guest_handle(efi_data(op).u.get_variable.data, data);

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	*data_size = efi_data(op).u.get_variable.size;
	if (attr)
		*attr = efi_data(op).misc;

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_get_variable);

efi_status_t xen_efi_get_next_variable(unsigned long *name_size,
				       efi_char16_t *name,
				       efi_guid_t *vendor)
{
	struct xen_platform_op op = INIT_EFI_OP(get_next_variable_name);

	efi_data(op).u.get_next_variable_name.size = *name_size;
	set_xen_guest_handle(efi_data(op).u.get_next_variable_name.name, name);
	BUILD_BUG_ON(sizeof(*vendor) !=
		     sizeof(efi_data(op).u.get_next_variable_name.vendor_guid));
	memcpy(&efi_data(op).u.get_next_variable_name.vendor_guid, vendor,
	       sizeof(*vendor));

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	*name_size = efi_data(op).u.get_next_variable_name.size;
	memcpy(vendor, &efi_data(op).u.get_next_variable_name.vendor_guid,
	       sizeof(*vendor));

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_get_next_variable);

efi_status_t xen_efi_set_variable(efi_char16_t *name, efi_guid_t *vendor,
				 u32 attr, unsigned long data_size,
				 void *data)
{
	struct xen_platform_op op = INIT_EFI_OP(set_variable);

	set_xen_guest_handle(efi_data(op).u.set_variable.name, name);
	efi_data(op).misc = attr;
	BUILD_BUG_ON(sizeof(*vendor) !=
		     sizeof(efi_data(op).u.set_variable.vendor_guid));
	memcpy(&efi_data(op).u.set_variable.vendor_guid, vendor, sizeof(*vendor));
	efi_data(op).u.set_variable.size = data_size;
	set_xen_guest_handle(efi_data(op).u.set_variable.data, data);

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_set_variable);

efi_status_t xen_efi_query_variable_info(u32 attr, u64 *storage_space,
					 u64 *remaining_space,
					 u64 *max_variable_size)
{
	struct xen_platform_op op = INIT_EFI_OP(query_variable_info);

	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
		return EFI_UNSUPPORTED;

	efi_data(op).u.query_variable_info.attr = attr;

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	*storage_space = efi_data(op).u.query_variable_info.max_store_size;
	*remaining_space = efi_data(op).u.query_variable_info.remain_store_size;
	*max_variable_size = efi_data(op).u.query_variable_info.max_size;

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_query_variable_info);

efi_status_t xen_efi_get_next_high_mono_count(u32 *count)
{
	struct xen_platform_op op = INIT_EFI_OP(get_next_high_monotonic_count);

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	*count = efi_data(op).misc;

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_get_next_high_mono_count);

efi_status_t xen_efi_update_capsule(efi_capsule_header_t **capsules,
				    unsigned long count, unsigned long sg_list)
{
	struct xen_platform_op op = INIT_EFI_OP(update_capsule);

	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
		return EFI_UNSUPPORTED;

	set_xen_guest_handle(efi_data(op).u.update_capsule.capsule_header_array,
			     capsules);
	efi_data(op).u.update_capsule.capsule_count = count;
	efi_data(op).u.update_capsule.sg_list = sg_list;

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_update_capsule);

efi_status_t xen_efi_query_capsule_caps(efi_capsule_header_t **capsules,
					unsigned long count, u64 *max_size,
					int *reset_type)
{
	struct xen_platform_op op = INIT_EFI_OP(query_capsule_capabilities);

	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
		return EFI_UNSUPPORTED;

	set_xen_guest_handle(efi_data(op).u.query_capsule_capabilities.capsule_header_array,
					capsules);
	efi_data(op).u.query_capsule_capabilities.capsule_count = count;

	if (HYPERVISOR_platform_op(&op) < 0)
		return EFI_UNSUPPORTED;

	*max_size = efi_data(op).u.query_capsule_capabilities.max_capsule_size;
	*reset_type = efi_data(op).u.query_capsule_capabilities.reset_type;

	return efi_data(op).status;
}
EXPORT_SYMBOL_GPL(xen_efi_query_capsule_caps);

void xen_efi_reset_system(int reset_type, efi_status_t status,
			  unsigned long data_size, efi_char16_t *data)
{
	switch (reset_type) {
	case EFI_RESET_COLD:
	case EFI_RESET_WARM:
		xen_reboot(SHUTDOWN_reboot);
		break;
	case EFI_RESET_SHUTDOWN:
		xen_reboot(SHUTDOWN_poweroff);
		break;
	default:
		BUG();
	}
}
EXPORT_SYMBOL_GPL(xen_efi_reset_system);
Commit	Line	Data
be81c8a1 DK	1	/*
	2	* EFI support for Xen.
	3	*
	4	* Copyright (C) 1999 VA Linux Systems
	5	* Copyright (C) 1999 Walt Drummond <[email protected]>
	6	* Copyright (C) 1999-2002 Hewlett-Packard Co.
	7	* David Mosberger-Tang <[email protected]>
	8	* Stephane Eranian <[email protected]>
	9	* Copyright (C) 2005-2008 Intel Co.
	10	* Fenghua Yu <[email protected]>
	11	* Bibo Mao <[email protected]>
	12	* Chandramouli Narayanan <[email protected]>
	13	* Huang Ying <[email protected]>
	14	* Copyright (C) 2011 Novell Co.
	15	* Jan Beulich <[email protected]>
	16	* Copyright (C) 2011-2012 Oracle Co.
	17	* Liang Tang <[email protected]>
	18	* Copyright (c) 2014 Oracle Co., Daniel Kiper
	19	*/
	20
	21	#include <linux/bug.h>
	22	#include <linux/efi.h>
	23	#include <linux/init.h>
	24	#include <linux/string.h>
	25
	26	#include <xen/interface/xen.h>
	27	#include <xen/interface/platform.h>
	28	#include <xen/xen.h>
e371fd76	29	#include <xen/xen-ops.h>
be81c8a1	30
342cd340 DK	31	#include <asm/page.h>
342cd340 DK	32
be81c8a1 DK	33	#include <asm/xen/hypercall.h>
	34
	35	#define INIT_EFI_OP(name) \
	36	{.cmd = XENPF_efi_runtime_call, \
	37	.u.efi_runtime_call.function = XEN_EFI_##name, \
	38	.u.efi_runtime_call.misc = 0}
	39
	40	#define efi_data(op) (op.u.efi_runtime_call)
	41
a62ed500	42	efi_status_t xen_efi_get_time(efi_time_t tm, efi_time_cap_t tc)
be81c8a1 DK	43	{
	44	struct xen_platform_op op = INIT_EFI_OP(get_time);
	45
cfafae94	46	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	47	return EFI_UNSUPPORTED;
	48
	49	if (tm) {
	50	BUILD_BUG_ON(sizeof(*tm) != sizeof(efi_data(op).u.get_time.time));
	51	memcpy(tm, &efi_data(op).u.get_time.time, sizeof(*tm));
	52	}
	53
	54	if (tc) {
	55	tc->resolution = efi_data(op).u.get_time.resolution;
	56	tc->accuracy = efi_data(op).u.get_time.accuracy;
	57	tc->sets_to_zero = !!(efi_data(op).misc &
	58	XEN_EFI_GET_TIME_SET_CLEARS_NS);
	59	}
	60
	61	return efi_data(op).status;
	62	}
a62ed500	63	EXPORT_SYMBOL_GPL(xen_efi_get_time);
be81c8a1	64
a62ed500	65	efi_status_t xen_efi_set_time(efi_time_t *tm)
be81c8a1 DK	66	{
	67	struct xen_platform_op op = INIT_EFI_OP(set_time);
	68
	69	BUILD_BUG_ON(sizeof(*tm) != sizeof(efi_data(op).u.set_time));
	70	memcpy(&efi_data(op).u.set_time, tm, sizeof(*tm));
	71
cfafae94	72	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	73	return EFI_UNSUPPORTED;
	74
	75	return efi_data(op).status;
	76	}
a62ed500	77	EXPORT_SYMBOL_GPL(xen_efi_set_time);
be81c8a1	78
a62ed500 SZ	79	efi_status_t xen_efi_get_wakeup_time(efi_bool_t enabled, efi_bool_t pending,
a62ed500 SZ	80	efi_time_t *tm)
be81c8a1 DK	81	{
	82	struct xen_platform_op op = INIT_EFI_OP(get_wakeup_time);
	83
cfafae94	84	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	85	return EFI_UNSUPPORTED;
	86
	87	if (tm) {
	88	BUILD_BUG_ON(sizeof(*tm) != sizeof(efi_data(op).u.get_wakeup_time));
	89	memcpy(tm, &efi_data(op).u.get_wakeup_time, sizeof(*tm));
	90	}
	91
	92	if (enabled)
	93	*enabled = !!(efi_data(op).misc & XEN_EFI_GET_WAKEUP_TIME_ENABLED);
	94
	95	if (pending)
	96	*pending = !!(efi_data(op).misc & XEN_EFI_GET_WAKEUP_TIME_PENDING);
	97
	98	return efi_data(op).status;
	99	}
a62ed500	100	EXPORT_SYMBOL_GPL(xen_efi_get_wakeup_time);
be81c8a1	101
a62ed500	102	efi_status_t xen_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
be81c8a1 DK	103	{
	104	struct xen_platform_op op = INIT_EFI_OP(set_wakeup_time);
	105
	106	BUILD_BUG_ON(sizeof(*tm) != sizeof(efi_data(op).u.set_wakeup_time));
	107	if (enabled)
	108	efi_data(op).misc = XEN_EFI_SET_WAKEUP_TIME_ENABLE;
	109	if (tm)
	110	memcpy(&efi_data(op).u.set_wakeup_time, tm, sizeof(*tm));
	111	else
	112	efi_data(op).misc \|= XEN_EFI_SET_WAKEUP_TIME_ENABLE_ONLY;
	113
cfafae94	114	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	115	return EFI_UNSUPPORTED;
	116
	117	return efi_data(op).status;
	118	}
a62ed500	119	EXPORT_SYMBOL_GPL(xen_efi_set_wakeup_time);
be81c8a1	120
a62ed500 SZ	121	efi_status_t xen_efi_get_variable(efi_char16_t name, efi_guid_t vendor,
	122	u32 attr, unsigned long data_size,
	123	void *data)
be81c8a1 DK	124	{
	125	struct xen_platform_op op = INIT_EFI_OP(get_variable);
	126
	127	set_xen_guest_handle(efi_data(op).u.get_variable.name, name);
	128	BUILD_BUG_ON(sizeof(*vendor) !=
	129	sizeof(efi_data(op).u.get_variable.vendor_guid));
	130	memcpy(&efi_data(op).u.get_variable.vendor_guid, vendor, sizeof(*vendor));
	131	efi_data(op).u.get_variable.size = *data_size;
	132	set_xen_guest_handle(efi_data(op).u.get_variable.data, data);
	133
cfafae94	134	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	135	return EFI_UNSUPPORTED;
	136
	137	*data_size = efi_data(op).u.get_variable.size;
	138	if (attr)
	139	*attr = efi_data(op).misc;
	140
	141	return efi_data(op).status;
	142	}
a62ed500	143	EXPORT_SYMBOL_GPL(xen_efi_get_variable);
be81c8a1	144
a62ed500 SZ	145	efi_status_t xen_efi_get_next_variable(unsigned long *name_size,
	146	efi_char16_t *name,
	147	efi_guid_t *vendor)
be81c8a1 DK	148	{
	149	struct xen_platform_op op = INIT_EFI_OP(get_next_variable_name);
	150
	151	efi_data(op).u.get_next_variable_name.size = *name_size;
	152	set_xen_guest_handle(efi_data(op).u.get_next_variable_name.name, name);
	153	BUILD_BUG_ON(sizeof(*vendor) !=
	154	sizeof(efi_data(op).u.get_next_variable_name.vendor_guid));
	155	memcpy(&efi_data(op).u.get_next_variable_name.vendor_guid, vendor,
	156	sizeof(*vendor));
	157
cfafae94	158	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	159	return EFI_UNSUPPORTED;
	160
	161	*name_size = efi_data(op).u.get_next_variable_name.size;
	162	memcpy(vendor, &efi_data(op).u.get_next_variable_name.vendor_guid,
	163	sizeof(*vendor));
	164
	165	return efi_data(op).status;
	166	}
a62ed500	167	EXPORT_SYMBOL_GPL(xen_efi_get_next_variable);
be81c8a1	168
a62ed500 SZ	169	efi_status_t xen_efi_set_variable(efi_char16_t name, efi_guid_t vendor,
	170	u32 attr, unsigned long data_size,
	171	void *data)
be81c8a1 DK	172	{
	173	struct xen_platform_op op = INIT_EFI_OP(set_variable);
	174
	175	set_xen_guest_handle(efi_data(op).u.set_variable.name, name);
	176	efi_data(op).misc = attr;
	177	BUILD_BUG_ON(sizeof(*vendor) !=
	178	sizeof(efi_data(op).u.set_variable.vendor_guid));
	179	memcpy(&efi_data(op).u.set_variable.vendor_guid, vendor, sizeof(*vendor));
	180	efi_data(op).u.set_variable.size = data_size;
	181	set_xen_guest_handle(efi_data(op).u.set_variable.data, data);
	182
cfafae94	183	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	184	return EFI_UNSUPPORTED;
	185
	186	return efi_data(op).status;
	187	}
a62ed500	188	EXPORT_SYMBOL_GPL(xen_efi_set_variable);
be81c8a1	189
a62ed500 SZ	190	efi_status_t xen_efi_query_variable_info(u32 attr, u64 *storage_space,
	191	u64 *remaining_space,
	192	u64 *max_variable_size)
be81c8a1 DK	193	{
	194	struct xen_platform_op op = INIT_EFI_OP(query_variable_info);
	195
	196	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
	197	return EFI_UNSUPPORTED;
	198
	199	efi_data(op).u.query_variable_info.attr = attr;
	200
cfafae94	201	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	202	return EFI_UNSUPPORTED;
	203
	204	*storage_space = efi_data(op).u.query_variable_info.max_store_size;
	205	*remaining_space = efi_data(op).u.query_variable_info.remain_store_size;
	206	*max_variable_size = efi_data(op).u.query_variable_info.max_size;
	207
	208	return efi_data(op).status;
	209	}
a62ed500	210	EXPORT_SYMBOL_GPL(xen_efi_query_variable_info);
be81c8a1	211
a62ed500	212	efi_status_t xen_efi_get_next_high_mono_count(u32 *count)
be81c8a1 DK	213	{
	214	struct xen_platform_op op = INIT_EFI_OP(get_next_high_monotonic_count);
	215
cfafae94	216	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	217	return EFI_UNSUPPORTED;
	218
	219	*count = efi_data(op).misc;
	220
	221	return efi_data(op).status;
	222	}
a62ed500	223	EXPORT_SYMBOL_GPL(xen_efi_get_next_high_mono_count);
be81c8a1	224
a62ed500 SZ	225	efi_status_t xen_efi_update_capsule(efi_capsule_header_t **capsules,
a62ed500 SZ	226	unsigned long count, unsigned long sg_list)
be81c8a1 DK	227	{
	228	struct xen_platform_op op = INIT_EFI_OP(update_capsule);
	229
	230	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
	231	return EFI_UNSUPPORTED;
	232
	233	set_xen_guest_handle(efi_data(op).u.update_capsule.capsule_header_array,
	234	capsules);
	235	efi_data(op).u.update_capsule.capsule_count = count;
	236	efi_data(op).u.update_capsule.sg_list = sg_list;
	237
cfafae94	238	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	239	return EFI_UNSUPPORTED;
	240
	241	return efi_data(op).status;
	242	}
a62ed500	243	EXPORT_SYMBOL_GPL(xen_efi_update_capsule);
be81c8a1	244
a62ed500 SZ	245	efi_status_t xen_efi_query_capsule_caps(efi_capsule_header_t **capsules,
	246	unsigned long count, u64 *max_size,
	247	int *reset_type)
be81c8a1 DK	248	{
	249	struct xen_platform_op op = INIT_EFI_OP(query_capsule_capabilities);
	250
	251	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
	252	return EFI_UNSUPPORTED;
	253
	254	set_xen_guest_handle(efi_data(op).u.query_capsule_capabilities.capsule_header_array,
	255	capsules);
	256	efi_data(op).u.query_capsule_capabilities.capsule_count = count;
	257
cfafae94	258	if (HYPERVISOR_platform_op(&op) < 0)
be81c8a1 DK	259	return EFI_UNSUPPORTED;
	260
	261	*max_size = efi_data(op).u.query_capsule_capabilities.max_capsule_size;
	262	*reset_type = efi_data(op).u.query_capsule_capabilities.reset_type;
	263
	264	return efi_data(op).status;
	265	}
a62ed500	266	EXPORT_SYMBOL_GPL(xen_efi_query_capsule_caps);
e371fd76 JG	267
	268	void xen_efi_reset_system(int reset_type, efi_status_t status,
	269	unsigned long data_size, efi_char16_t *data)
	270	{
	271	switch (reset_type) {
	272	case EFI_RESET_COLD:
	273	case EFI_RESET_WARM:
	274	xen_reboot(SHUTDOWN_reboot);
	275	break;
	276	case EFI_RESET_SHUTDOWN:
	277	xen_reboot(SHUTDOWN_poweroff);
	278	break;
	279	default:
	280	BUG();
	281	}
	282	}
	283	EXPORT_SYMBOL_GPL(xen_efi_reset_system);