[J-u-boot.git] / include / efi_loader.h

/*
 *  EFI application loader
 *
 *  Copyright (c) 2016 Alexander Graf
 *
 *  SPDX-License-Identifier:     GPL-2.0+
 */

#include <common.h>
#include <part_efi.h>
#include <efi_api.h>

/* No need for efi loader support in SPL */
#if defined(CONFIG_EFI_LOADER) && !defined(CONFIG_SPL_BUILD)

#include <linux/list.h>

int __efi_entry_check(void);
int __efi_exit_check(void);
const char *__efi_nesting(void);
const char *__efi_nesting_inc(void);
const char *__efi_nesting_dec(void);

/*
 * Enter the u-boot world from UEFI:
 */
#define EFI_ENTRY(format, ...) do { \
	assert(__efi_entry_check()); \
	debug("%sEFI: Entry %s(" format ")\n", __efi_nesting_inc(), \
		__func__, ##__VA_ARGS__); \
	} while(0)

/*
 * Exit the u-boot world back to UEFI:
 */
#define EFI_EXIT(ret) ({ \
	typeof(ret) _r = ret; \
	debug("%sEFI: Exit: %s: %u\n", __efi_nesting_dec(), \
		__func__, (u32)((uintptr_t) _r & ~EFI_ERROR_MASK)); \
	assert(__efi_exit_check()); \
	_r; \
	})

/*
 * Call non-void UEFI function from u-boot and retrieve return value:
 */
#define EFI_CALL(exp) ({ \
	debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \
	assert(__efi_exit_check()); \
	typeof(exp) _r = exp; \
	assert(__efi_entry_check()); \
	debug("%sEFI: %lu returned by %s\n", __efi_nesting_dec(), \
	      (unsigned long)((uintptr_t)_r & ~EFI_ERROR_MASK), #exp); \
	_r; \
})

/*
 * Call void UEFI function from u-boot:
 */
#define EFI_CALL_VOID(exp) do { \
	debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \
	assert(__efi_exit_check()); \
	exp; \
	assert(__efi_entry_check()); \
	debug("%sEFI: Return From: %s\n", __efi_nesting_dec(), #exp); \
	} while(0)

/*
 * Write GUID
 */
#define EFI_PRINT_GUID(txt, guid) ({ \
	debug("%sEFI: %s %pUl\n", __efi_nesting(), txt, guid); \
	})

extern struct efi_runtime_services efi_runtime_services;
extern struct efi_system_table systab;

extern const struct efi_simple_text_output_protocol efi_con_out;
extern struct efi_simple_input_interface efi_con_in;
extern const struct efi_console_control_protocol efi_console_control;
extern const struct efi_device_path_to_text_protocol efi_device_path_to_text;

uint16_t *efi_dp_str(struct efi_device_path *dp);

extern const efi_guid_t efi_guid_console_control;
extern const efi_guid_t efi_guid_device_path;
extern const efi_guid_t efi_guid_loaded_image;
extern const efi_guid_t efi_guid_device_path_to_text_protocol;

extern unsigned int __efi_runtime_start, __efi_runtime_stop;
extern unsigned int __efi_runtime_rel_start, __efi_runtime_rel_stop;

/*
 * When the UEFI payload wants to open a protocol on an object to get its
 * interface (usually a struct with callback functions), this struct maps the
 * protocol GUID to the respective protocol interface */
struct efi_handler {
	const efi_guid_t *guid;
	void *protocol_interface;
};

/*
 * UEFI has a poor man's OO model where one "object" can be polymorphic and have
 * multiple different protocols (classes) attached to it.
 *
 * This struct is the parent struct for all of our actual implementation objects
 * that can include it to make themselves an EFI object
 */
struct efi_object {
	/* Every UEFI object is part of a global object list */
	struct list_head link;
	/* We support up to 8 "protocols" an object can be accessed through */
	struct efi_handler protocols[8];
	/* The object spawner can either use this for data or as identifier */
	void *handle;
};

#define EFI_PROTOCOL_OBJECT(_guid, _protocol) (struct efi_object){	\
	.protocols = {{							\
		.guid = &(_guid),	 				\
		.protocol_interface = (void *)(_protocol), 		\
	}},								\
	.handle = (void *)(_protocol),					\
}

/**
 * struct efi_event
 *
 * @type:		Type of event, see efi_create_event
 * @notify_tpl:		Task priority level of notifications
 * @trigger_time:	Period of the timer
 * @trigger_next:	Next time to trigger the timer
 * @nofify_function:	Function to call when the event is triggered
 * @notify_context:	Data to be passed to the notify function
 * @trigger_type:	Type of timer, see efi_set_timer
 * @queued:		The notification functionis queued
 * @signaled:		The event occured
 */
struct efi_event {
	uint32_t type;
	UINTN notify_tpl;
	void (EFIAPI *notify_function)(struct efi_event *event, void *context);
	void *notify_context;
	u64 trigger_next;
	u64 trigger_time;
	enum efi_timer_delay trigger_type;
	int queued;
	int signaled;
};


/* This list contains all UEFI objects we know of */
extern struct list_head efi_obj_list;

/* Called by bootefi to make console interface available */
int efi_console_register(void);
/* Called by bootefi to make all disk storage accessible as EFI objects */
int efi_disk_register(void);
/* Called by bootefi to make GOP (graphical) interface available */
int efi_gop_register(void);
/* Called by bootefi to make the network interface available */
int efi_net_register(void);
/* Called by bootefi to make SMBIOS tables available */
void efi_smbios_register(void);

/* Called by networking code to memorize the dhcp ack package */
void efi_net_set_dhcp_ack(void *pkt, int len);

/* Called from places to check whether a timer expired */
void efi_timer_check(void);
/* PE loader implementation */
void *efi_load_pe(void *efi, struct efi_loaded_image *loaded_image_info);
/* Called once to store the pristine gd pointer */
void efi_save_gd(void);
/* Special case handler for error/abort that just tries to dtrt to get
 * back to u-boot world */
void efi_restore_gd(void);
/* Call this to relocate the runtime section to an address space */
void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map);
/* Call this to set the current device name */
void efi_set_bootdev(const char *dev, const char *devnr, const char *path);
/* Call this to create an event */
efi_status_t efi_create_event(uint32_t type, UINTN notify_tpl,
			      void (EFIAPI *notify_function) (
					struct efi_event *event,
					void *context),
			      void *notify_context, struct efi_event **event);
/* Call this to set a timer */
efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type,
			   uint64_t trigger_time);
/* Call this to signal an event */
void efi_signal_event(struct efi_event *event);

/* Generic EFI memory allocator, call this to get memory */
void *efi_alloc(uint64_t len, int memory_type);
/* More specific EFI memory allocator, called by EFI payloads */
efi_status_t efi_allocate_pages(int type, int memory_type, unsigned long pages,
				uint64_t *memory);
/* EFI memory free function. */
efi_status_t efi_free_pages(uint64_t memory, unsigned long pages);
/* EFI memory allocator for small allocations */
efi_status_t efi_allocate_pool(int pool_type, unsigned long size,
			       void **buffer);
/* EFI pool memory free function. */
efi_status_t efi_free_pool(void *buffer);
/* Returns the EFI memory map */
efi_status_t efi_get_memory_map(unsigned long *memory_map_size,
				struct efi_mem_desc *memory_map,
				unsigned long *map_key,
				unsigned long *descriptor_size,
				uint32_t *descriptor_version);
/* Adds a range into the EFI memory map */
uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type,
			    bool overlap_only_ram);
/* Called by board init to initialize the EFI memory map */
int efi_memory_init(void);
/* Adds new or overrides configuration table entry to the system table */
efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table);
void efi_setup_loaded_image(struct efi_loaded_image *info, struct efi_object *obj,
			    struct efi_device_path *device_path,
			    struct efi_device_path *file_path);

#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
extern void *efi_bounce_buffer;
#define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024)
#endif


struct efi_device_path *efi_dp_next(const struct efi_device_path *dp);
int efi_dp_match(struct efi_device_path *a, struct efi_device_path *b);
struct efi_object *efi_dp_find_obj(struct efi_device_path *dp,
				   struct efi_device_path **rem);
unsigned efi_dp_size(const struct efi_device_path *dp);
struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp);
struct efi_device_path *efi_dp_append(const struct efi_device_path *dp1,
				      const struct efi_device_path *dp2);
struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp,
					   const struct efi_device_path *node);


struct efi_device_path *efi_dp_from_dev(struct udevice *dev);
struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part);
struct efi_device_path *efi_dp_from_file(struct blk_desc *desc, int part,
					 const char *path);
struct efi_device_path *efi_dp_from_eth(void);
void efi_dp_split_file_path(struct efi_device_path *full_path,
			    struct efi_device_path **device_path,
			    struct efi_device_path **file_path);

#define EFI_DP_TYPE(_dp, _type, _subtype) \
	(((_dp)->type == DEVICE_PATH_TYPE_##_type) && \
	 ((_dp)->sub_type == DEVICE_PATH_SUB_TYPE_##_subtype))

/* Convert strings from normal C strings to uEFI strings */
static inline void ascii2unicode(u16 *unicode, const char *ascii)
{
	while (*ascii)
		*(unicode++) = *(ascii++);
}

static inline int guidcmp(const efi_guid_t *g1, const efi_guid_t *g2)
{
	return memcmp(g1, g2, sizeof(efi_guid_t));
}

/*
 * Use these to indicate that your code / data should go into the EFI runtime
 * section and thus still be available when the OS is running
 */
#define __efi_runtime_data __attribute__ ((section ("efi_runtime_data")))
#define __efi_runtime __attribute__ ((section ("efi_runtime_text")))

/* Call this with mmio_ptr as the _pointer_ to a pointer to an MMIO region
 * to make it available at runtime */
void efi_add_runtime_mmio(void *mmio_ptr, u64 len);

/* Boards may provide the functions below to implement RTS functionality */

void __efi_runtime EFIAPI efi_reset_system(
			enum efi_reset_type reset_type,
			efi_status_t reset_status,
			unsigned long data_size, void *reset_data);
void efi_reset_system_init(void);

efi_status_t __efi_runtime EFIAPI efi_get_time(
			struct efi_time *time,
			struct efi_time_cap *capabilities);
void efi_get_time_init(void);

#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
/*
 * Entry point for the tests of the EFI API.
 * It is called by 'bootefi selftest'
 */
efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle,
				 struct efi_system_table *systab);
#endif

#else /* defined(EFI_LOADER) && !defined(CONFIG_SPL_BUILD) */

/* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */
#define __efi_runtime_data
#define __efi_runtime
static inline void efi_add_runtime_mmio(void *mmio_ptr, u64 len) { }

/* No loader configured, stub out EFI_ENTRY */
static inline void efi_restore_gd(void) { }
static inline void efi_set_bootdev(const char *dev, const char *devnr,
				   const char *path) { }
static inline void efi_net_set_dhcp_ack(void *pkt, int len) { }

#endif
Commit	Line	Data
cb149c66 AG	1	/*
	2	* EFI application loader
	3	*
	4	* Copyright (c) 2016 Alexander Graf
	5	*
	6	* SPDX-License-Identifier: GPL-2.0+
	7	*/
	8
bee91169	9	#include <common.h>
cb149c66 AG	10	#include <part_efi.h>
cb149c66 AG	11	#include <efi_api.h>
bee91169 AG	12
	13	/* No need for efi loader support in SPL */
	14	#if defined(CONFIG_EFI_LOADER) && !defined(CONFIG_SPL_BUILD)
	15
cb149c66 AG	16	#include <linux/list.h>
cb149c66 AG	17
c160d2f5 RC	18	int __efi_entry_check(void);
c160d2f5 RC	19	int __efi_exit_check(void);
ae0bd3a9	20	const char *__efi_nesting(void);
af65db85 RC	21	const char *__efi_nesting_inc(void);
af65db85 RC	22	const char *__efi_nesting_dec(void);
c160d2f5	23
a095aadf RC	24	/*
	25	* Enter the u-boot world from UEFI:
	26	*/
bee91169	27	#define EFI_ENTRY(format, ...) do { \
c160d2f5	28	assert(__efi_entry_check()); \
af65db85 RC	29	debug("%sEFI: Entry %s(" format ")\n", __efi_nesting_inc(), \
af65db85 RC	30	__func__, ##__VA_ARGS__); \
bee91169	31	} while(0)
bee91169	32
a095aadf RC	33	/*
	34	* Exit the u-boot world back to UEFI:
	35	*/
804b1d73	36	#define EFI_EXIT(ret) ({ \
c81883df	37	typeof(ret) _r = ret; \
af65db85	38	debug("%sEFI: Exit: %s: %u\n", __efi_nesting_dec(), \
c81883df	39	__func__, (u32)((uintptr_t) _r & ~EFI_ERROR_MASK)); \
c160d2f5 RC	40	assert(__efi_exit_check()); \
c160d2f5 RC	41	_r; \
804b1d73	42	})
bee91169	43
a095aadf	44	/*
ea630ce9	45	* Call non-void UEFI function from u-boot and retrieve return value:
a095aadf	46	*/
ea630ce9 HS	47	#define EFI_CALL(exp) ({ \
	48	debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \
	49	assert(__efi_exit_check()); \
	50	typeof(exp) _r = exp; \
	51	assert(__efi_entry_check()); \
	52	debug("%sEFI: %lu returned by %s\n", __efi_nesting_dec(), \
	53	(unsigned long)((uintptr_t)_r & ~EFI_ERROR_MASK), #exp); \
	54	_r; \
	55	})
	56
	57	/*
	58	* Call void UEFI function from u-boot:
	59	*/
	60	#define EFI_CALL_VOID(exp) do { \
af65db85	61	debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \
c160d2f5	62	assert(__efi_exit_check()); \
a095aadf	63	exp; \
c160d2f5	64	assert(__efi_entry_check()); \
af65db85	65	debug("%sEFI: Return From: %s\n", __efi_nesting_dec(), #exp); \
a095aadf RC	66	} while(0)
a095aadf RC	67
ae0bd3a9 HS	68	/*
	69	* Write GUID
	70	*/
	71	#define EFI_PRINT_GUID(txt, guid) ({ \
	72	debug("%sEFI: %s %pUl\n", __efi_nesting(), txt, guid); \
	73	})
	74
50149ea3	75	extern struct efi_runtime_services efi_runtime_services;
bee91169 AG	76	extern struct efi_system_table systab;
bee91169 AG	77
c1311ad4	78	extern const struct efi_simple_text_output_protocol efi_con_out;
91be9a77	79	extern struct efi_simple_input_interface efi_con_in;
c1311ad4	80	extern const struct efi_console_control_protocol efi_console_control;
cc5b7081	81	extern const struct efi_device_path_to_text_protocol efi_device_path_to_text;
c1311ad4	82
adae4313 RC	83	uint16_t efi_dp_str(struct efi_device_path dp);
adae4313 RC	84
c1311ad4	85	extern const efi_guid_t efi_guid_console_control;
cb149c66 AG	86	extern const efi_guid_t efi_guid_device_path;
cb149c66 AG	87	extern const efi_guid_t efi_guid_loaded_image;
cc5b7081	88	extern const efi_guid_t efi_guid_device_path_to_text_protocol;
cb149c66	89
50149ea3 AG	90	extern unsigned int __efi_runtime_start, __efi_runtime_stop;
	91	extern unsigned int __efi_runtime_rel_start, __efi_runtime_rel_stop;
	92
bee91169 AG	93	/*
	94	* When the UEFI payload wants to open a protocol on an object to get its
	95	* interface (usually a struct with callback functions), this struct maps the
b5349f74	96	* protocol GUID to the respective protocol interface */
bee91169 AG	97	struct efi_handler {
bee91169 AG	98	const efi_guid_t *guid;
b5349f74	99	void *protocol_interface;
bee91169 AG	100	};
	101
	102	/*
	103	* UEFI has a poor man's OO model where one "object" can be polymorphic and have
	104	* multiple different protocols (classes) attached to it.
	105	*
	106	* This struct is the parent struct for all of our actual implementation objects
	107	* that can include it to make themselves an EFI object
	108	*/
	109	struct efi_object {
	110	/* Every UEFI object is part of a global object list */
	111	struct list_head link;
011f4327 HS	112	/* We support up to 8 "protocols" an object can be accessed through */
011f4327 HS	113	struct efi_handler protocols[8];
bee91169 AG	114	/* The object spawner can either use this for data or as identifier */
	115	void *handle;
	116	};
	117
641833db RC	118	#define EFI_PROTOCOL_OBJECT(_guid, _protocol) (struct efi_object){ \
	119	.protocols = {{ \
	120	.guid = &(_guid), \
	121	.protocol_interface = (void *)(_protocol), \
	122	}}, \
	123	.handle = (void *)(_protocol), \
	124	}
	125
c6841592 HS	126	/**
	127	* struct efi_event
	128	*
	129	* @type: Type of event, see efi_create_event
	130	* @notify_tpl: Task priority level of notifications
	131	* @trigger_time: Period of the timer
	132	* @trigger_next: Next time to trigger the timer
	133	* @nofify_function: Function to call when the event is triggered
	134	* @notify_context: Data to be passed to the notify function
	135	* @trigger_type: Type of timer, see efi_set_timer
ca62a4f5 HS	136	* @queued: The notification functionis queued
ca62a4f5 HS	137	* @signaled: The event occured
c6841592 HS	138	*/
c6841592 HS	139	struct efi_event {
b521d29e	140	uint32_t type;
503f2695	141	UINTN notify_tpl;
c6841592 HS	142	void (EFIAPI notify_function)(struct efi_event event, void *context);
	143	void *notify_context;
	144	u64 trigger_next;
	145	u64 trigger_time;
b521d29e	146	enum efi_timer_delay trigger_type;
ca62a4f5	147	int queued;
c6841592 HS	148	int signaled;
	149	};
	150
	151
bee91169 AG	152	/* This list contains all UEFI objects we know of */
	153	extern struct list_head efi_obj_list;
	154
91be9a77 HS	155	/* Called by bootefi to make console interface available */
91be9a77 HS	156	int efi_console_register(void);
2a22d05d AG	157	/* Called by bootefi to make all disk storage accessible as EFI objects */
2a22d05d AG	158	int efi_disk_register(void);
be8d3241 AG	159	/* Called by bootefi to make GOP (graphical) interface available */
be8d3241 AG	160	int efi_gop_register(void);
0efe1bcf	161	/* Called by bootefi to make the network interface available */
95c5553e	162	int efi_net_register(void);
e663b350 AG	163	/* Called by bootefi to make SMBIOS tables available */
e663b350 AG	164	void efi_smbios_register(void);
0efe1bcf AG	165
	166	/* Called by networking code to memorize the dhcp ack package */
	167	void efi_net_set_dhcp_ack(void *pkt, int len);
	168
bee91169 AG	169	/* Called from places to check whether a timer expired */
	170	void efi_timer_check(void);
	171	/* PE loader implementation */
cb149c66	172	void efi_load_pe(void efi, struct efi_loaded_image *loaded_image_info);
bee91169 AG	173	/* Called once to store the pristine gd pointer */
bee91169 AG	174	void efi_save_gd(void);
c160d2f5 RC	175	/* Special case handler for error/abort that just tries to dtrt to get
c160d2f5 RC	176	* back to u-boot world */
bee91169	177	void efi_restore_gd(void);
50149ea3 AG	178	/* Call this to relocate the runtime section to an address space */
50149ea3 AG	179	void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map);
0f4060eb	180	/* Call this to set the current device name */
c07ad7c0	181	void efi_set_bootdev(const char dev, const char devnr, const char *path);
49deb455	182	/* Call this to create an event */
b521d29e	183	efi_status_t efi_create_event(uint32_t type, UINTN notify_tpl,
49deb455 HS	184	void (EFIAPI *notify_function) (
	185	struct efi_event *event,
	186	void *context),
	187	void notify_context, struct efi_event *event);
bfc72462	188	/* Call this to set a timer */
b521d29e	189	efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type,
bfc72462	190	uint64_t trigger_time);
91be9a77 HS	191	/* Call this to signal an event */
91be9a77 HS	192	void efi_signal_event(struct efi_event *event);
50149ea3	193
5d00995c AG	194	/* Generic EFI memory allocator, call this to get memory */
	195	void *efi_alloc(uint64_t len, int memory_type);
	196	/* More specific EFI memory allocator, called by EFI payloads */
	197	efi_status_t efi_allocate_pages(int type, int memory_type, unsigned long pages,
	198	uint64_t *memory);
b61d857b	199	/* EFI memory free function. */
5d00995c	200	efi_status_t efi_free_pages(uint64_t memory, unsigned long pages);
ead1274b SB	201	/* EFI memory allocator for small allocations */
	202	efi_status_t efi_allocate_pool(int pool_type, unsigned long size,
	203	void **buffer);
42417bc8 SB	204	/* EFI pool memory free function. */
42417bc8 SB	205	efi_status_t efi_free_pool(void *buffer);
5d00995c AG	206	/* Returns the EFI memory map */
	207	efi_status_t efi_get_memory_map(unsigned long *memory_map_size,
	208	struct efi_mem_desc *memory_map,
	209	unsigned long *map_key,
	210	unsigned long *descriptor_size,
	211	uint32_t *descriptor_version);
	212	/* Adds a range into the EFI memory map */
	213	uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type,
	214	bool overlap_only_ram);
	215	/* Called by board init to initialize the EFI memory map */
	216	int efi_memory_init(void);
488bf12d AG	217	/* Adds new or overrides configuration table entry to the system table */
488bf12d AG	218	efi_status_t efi_install_configuration_table(const efi_guid_t guid, void table);
95c5553e RC	219	void efi_setup_loaded_image(struct efi_loaded_image info, struct efi_object obj,
	220	struct efi_device_path *device_path,
	221	struct efi_device_path *file_path);
5d00995c	222
51735ae0 AG	223	#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
	224	extern void *efi_bounce_buffer;
	225	#define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024)
	226	#endif
	227
b66c60dd RC	228
	229	struct efi_device_path efi_dp_next(const struct efi_device_path dp);
	230	int efi_dp_match(struct efi_device_path a, struct efi_device_path b);
	231	struct efi_object efi_dp_find_obj(struct efi_device_path dp,
	232	struct efi_device_path **rem);
	233	unsigned efi_dp_size(const struct efi_device_path *dp);
	234	struct efi_device_path efi_dp_dup(const struct efi_device_path dp);
	235	struct efi_device_path efi_dp_append(const struct efi_device_path dp1,
	236	const struct efi_device_path *dp2);
	237	struct efi_device_path efi_dp_append_node(const struct efi_device_path dp,
	238	const struct efi_device_path *node);
	239
	240
	241	struct efi_device_path efi_dp_from_dev(struct udevice dev);
	242	struct efi_device_path efi_dp_from_part(struct blk_desc desc, int part);
	243	struct efi_device_path efi_dp_from_file(struct blk_desc desc, int part,
	244	const char *path);
	245	struct efi_device_path *efi_dp_from_eth(void);
	246	void efi_dp_split_file_path(struct efi_device_path *full_path,
	247	struct efi_device_path **device_path,
	248	struct efi_device_path **file_path);
	249
	250	#define EFI_DP_TYPE(_dp, _type, _subtype) \
	251	(((_dp)->type == DEVICE_PATH_TYPE_##_type) && \
	252	((_dp)->sub_type == DEVICE_PATH_SUB_TYPE_##_subtype))
	253
0f4060eb	254	/* Convert strings from normal C strings to uEFI strings */
487d756f	255	static inline void ascii2unicode(u16 unicode, const char ascii)
0f4060eb AG	256	{
	257	while (*ascii)
	258	(unicode++) = (ascii++);
	259	}
	260
3e094c59 RC	261	static inline int guidcmp(const efi_guid_t g1, const efi_guid_t g2)
	262	{
	263	return memcmp(g1, g2, sizeof(efi_guid_t));
	264	}
	265
50149ea3 AG	266	/*
	267	* Use these to indicate that your code / data should go into the EFI runtime
	268	* section and thus still be available when the OS is running
	269	*/
3c63db9c AG	270	#define __efi_runtime_data __attribute__ ((section ("efi_runtime_data")))
3c63db9c AG	271	#define __efi_runtime __attribute__ ((section ("efi_runtime_text")))
bee91169	272
80a4800e AG	273	/* Call this with mmio_ptr as the _pointer_ to a pointer to an MMIO region
	274	* to make it available at runtime */
	275	void efi_add_runtime_mmio(void *mmio_ptr, u64 len);
	276
	277	/* Boards may provide the functions below to implement RTS functionality */
	278
3c63db9c	279	void __efi_runtime EFIAPI efi_reset_system(
80a4800e AG	280	enum efi_reset_type reset_type,
	281	efi_status_t reset_status,
	282	unsigned long data_size, void *reset_data);
	283	void efi_reset_system_init(void);
	284
3c63db9c	285	efi_status_t __efi_runtime EFIAPI efi_get_time(
80a4800e AG	286	struct efi_time *time,
	287	struct efi_time_cap *capabilities);
	288	void efi_get_time_init(void);
	289
623b3a57 HS	290	#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
	291	/*
	292	* Entry point for the tests of the EFI API.
	293	* It is called by 'bootefi selftest'
	294	*/
	295	efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle,
	296	struct efi_system_table *systab);
	297	#endif
	298
bee91169 AG	299	#else /* defined(EFI_LOADER) && !defined(CONFIG_SPL_BUILD) */
bee91169 AG	300
50149ea3	301	/* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */
3c63db9c AG	302	#define __efi_runtime_data
3c63db9c AG	303	#define __efi_runtime
97d01444	304	static inline void efi_add_runtime_mmio(void *mmio_ptr, u64 len) { }
50149ea3	305
bee91169 AG	306	/* No loader configured, stub out EFI_ENTRY */
bee91169 AG	307	static inline void efi_restore_gd(void) { }
c07ad7c0 AG	308	static inline void efi_set_bootdev(const char dev, const char devnr,
c07ad7c0 AG	309	const char *path) { }
0efe1bcf	310	static inline void efi_net_set_dhcp_ack(void *pkt, int len) { }
bee91169 AG	311
bee91169 AG	312	#endif