efi_loader.h 29 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0+ */
2
3
4
5
6
7
/*
 *  EFI application loader
 *
 *  Copyright (c) 2016 Alexander Graf
 */

8
9
10
#ifndef _EFI_LOADER_H
#define _EFI_LOADER_H 1

11
#include <common.h>
12
#include <blk.h>
13
#include <log.h>
14
15
#include <part_efi.h>
#include <efi_api.h>
16
#include <image.h>
17
#include <pe.h>
18

19
20
struct blk_desc;

21
22
23
24
25
static inline int guidcmp(const void *g1, const void *g2)
{
	return memcmp(g1, g2, sizeof(efi_guid_t));
}

26
27
28
29
30
static inline void *guidcpy(void *dst, const void *src)
{
	return memcpy(dst, src, sizeof(efi_guid_t));
}

31
/* No need for efi loader support in SPL */
Stephen Warren's avatar
Stephen Warren committed
32
#if CONFIG_IS_ENABLED(EFI_LOADER)
33

34
#include <linux/list.h>
35
#include <linux/oid_registry.h>
36

37
38
39
/* Maximum number of configuration tables */
#define EFI_MAX_CONFIGURATION_TABLES 16

40
41
42
43
/* GUID used by the root node */
#define U_BOOT_GUID \
	EFI_GUID(0xe61d73b9, 0xa384, 0x4acc, \
		 0xae, 0xab, 0x82, 0xe8, 0x28, 0xf3, 0x62, 0x8b)
44
45
46
47
/* GUID used as host device on sandbox */
#define U_BOOT_HOST_DEV_GUID \
	EFI_GUID(0xbbe4e671, 0x5773, 0x4ea1, \
		 0x9a, 0xab, 0x3a, 0x7d, 0xbf, 0x40, 0xc4, 0x82)
48
49
50
51
/* GUID used as root for virtio devices */
#define U_BOOT_VIRTIO_DEV_GUID \
	EFI_GUID(0x63293792, 0xadf5, 0x9325, \
		 0xb9, 0x9f, 0x4e, 0x0e, 0x45, 0x5c, 0x1b, 0x1e)
52

53
/* Use internal device tree when starting UEFI application */
54
#define EFI_FDT_USE_INTERNAL NULL
55

56
57
58
/* Root node */
extern efi_handle_t efi_root;

59
60
61
/* Set to EFI_SUCCESS when initialized */
extern efi_status_t efi_obj_list_initialized;

62
63
64
/* Flag used by the selftest to avoid detaching devices in ExitBootServices() */
extern bool efi_st_keep_devices;

65
66
67
68
69
70
71
/* EFI system partition */
extern struct efi_system_partition {
	enum if_type if_type;
	int devnum;
	u8 part;
} efi_system_partition;

72
73
int __efi_entry_check(void);
int __efi_exit_check(void);
74
const char *__efi_nesting(void);
75
76
const char *__efi_nesting_inc(void);
const char *__efi_nesting_dec(void);
77

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

87
88
89
/*
 * Exit the u-boot world back to UEFI:
 */
90
#define EFI_EXIT(ret) ({ \
91
	typeof(ret) _r = ret; \
92
	debug("%sEFI: Exit: %s: %u\n", __efi_nesting_dec(), \
93
		__func__, (u32)((uintptr_t) _r & ~EFI_ERROR_MASK)); \
94
95
	assert(__efi_exit_check()); \
	_r; \
96
	})
97

98
/*
99
 * Call non-void UEFI function from u-boot and retrieve return value:
100
 */
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#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 { \
115
	debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \
116
	assert(__efi_exit_check()); \
117
	exp; \
118
	assert(__efi_entry_check()); \
119
	debug("%sEFI: Return From: %s\n", __efi_nesting_dec(), #exp); \
120
121
	} while(0)

122
/*
123
 * Write an indented message with EFI prefix
124
 */
125
126
127
#define EFI_PRINT(format, ...) ({ \
	debug("%sEFI: " format, __efi_nesting(), \
		##__VA_ARGS__); \
128
129
	})

130
131
132
133
134
135
136
#ifdef CONFIG_SYS_CACHELINE_SIZE
#define EFI_CACHELINE_SIZE CONFIG_SYS_CACHELINE_SIZE
#else
/* Just use the greatest cache flush alignment requirement I'm aware of */
#define EFI_CACHELINE_SIZE 128
#endif

137
138
139
/* Key identifying current memory map */
extern efi_uintn_t efi_memory_map_key;

140
extern struct efi_runtime_services efi_runtime_services;
141
142
extern struct efi_system_table systab;

143
extern struct efi_simple_text_output_protocol efi_con_out;
144
extern struct efi_simple_text_input_protocol efi_con_in;
145
extern struct efi_console_control_protocol efi_console_control;
146
extern const struct efi_device_path_to_text_protocol efi_device_path_to_text;
147
148
149
/* implementation of the EFI_DEVICE_PATH_UTILITIES_PROTOCOL */
extern const struct efi_device_path_utilities_protocol
					efi_device_path_utilities;
150
151
152
153
/* deprecated version of the EFI_UNICODE_COLLATION_PROTOCOL */
extern const struct efi_unicode_collation_protocol
					efi_unicode_collation_protocol;
/* current version of the EFI_UNICODE_COLLATION_PROTOCOL */
154
extern const struct efi_unicode_collation_protocol
155
					efi_unicode_collation_protocol2;
156
157
extern const struct efi_hii_config_routing_protocol efi_hii_config_routing;
extern const struct efi_hii_config_access_protocol efi_hii_config_access;
158
159
extern const struct efi_hii_database_protocol efi_hii_database;
extern const struct efi_hii_string_protocol efi_hii_string;
160

161
162
uint16_t *efi_dp_str(struct efi_device_path *dp);

163
164
/* GUID of the U-Boot root node */
extern const efi_guid_t efi_u_boot_guid;
165
166
167
168
#ifdef CONFIG_SANDBOX
/* GUID of U-Boot host device on sandbox */
extern const efi_guid_t efi_guid_host_dev;
#endif
169
170
/* GUID of the EFI_BLOCK_IO_PROTOCOL */
extern const efi_guid_t efi_block_io_guid;
Rob Clark's avatar
Rob Clark committed
171
extern const efi_guid_t efi_global_variable_guid;
172
extern const efi_guid_t efi_guid_console_control;
173
extern const efi_guid_t efi_guid_device_path;
174
175
/* GUID of the EFI_DRIVER_BINDING_PROTOCOL */
extern const efi_guid_t efi_guid_driver_binding_protocol;
176
177
178
179
180
181
182
183
184
185
/* event group ExitBootServices() invoked */
extern const efi_guid_t efi_guid_event_group_exit_boot_services;
/* event group SetVirtualAddressMap() invoked */
extern const efi_guid_t efi_guid_event_group_virtual_address_change;
/* event group memory map changed */
extern const efi_guid_t efi_guid_event_group_memory_map_change;
/* event group boot manager about to boot */
extern const efi_guid_t efi_guid_event_group_ready_to_boot;
/* event group ResetSystem() invoked (before ExitBootServices) */
extern const efi_guid_t efi_guid_event_group_reset_system;
186
187
/* GUID of the device tree table */
extern const efi_guid_t efi_guid_fdt;
188
extern const efi_guid_t efi_guid_loaded_image;
189
extern const efi_guid_t efi_guid_loaded_image_device_path;
190
extern const efi_guid_t efi_guid_device_path_to_text_protocol;
191
192
extern const efi_guid_t efi_simple_file_system_protocol_guid;
extern const efi_guid_t efi_file_info_guid;
193
194
/* GUID for file system information */
extern const efi_guid_t efi_file_system_info_guid;
195
extern const efi_guid_t efi_guid_device_path_utilities_protocol;
196
197
/* GUID of the deprecated Unicode collation protocol */
extern const efi_guid_t efi_guid_unicode_collation_protocol;
198
/* GUID of the Unicode collation protocol */
199
extern const efi_guid_t efi_guid_unicode_collation_protocol2;
200
201
extern const efi_guid_t efi_guid_hii_config_routing_protocol;
extern const efi_guid_t efi_guid_hii_config_access_protocol;
202
203
extern const efi_guid_t efi_guid_hii_database_protocol;
extern const efi_guid_t efi_guid_hii_string_protocol;
204
205
206
207
208
/* GUIDs for authentication */
extern const efi_guid_t efi_guid_image_security_database;
extern const efi_guid_t efi_guid_sha256;
extern const efi_guid_t efi_guid_cert_x509;
extern const efi_guid_t efi_guid_cert_x509_sha256;
209
extern const efi_guid_t efi_guid_cert_type_pkcs7;
210

211
212
213
/* GUID of RNG protocol */
extern const efi_guid_t efi_guid_rng_protocol;

214
215
216
extern unsigned int __efi_runtime_start, __efi_runtime_stop;
extern unsigned int __efi_runtime_rel_start, __efi_runtime_rel_stop;

217
218
219
/**
 * struct efi_open_protocol_info_item - open protocol info item
 *
220
221
 * When a protocol is opened a open protocol info entry is created.
 * These are maintained in a list.
222
223
224
 *
 * @link:	link to the list of open protocol info entries of a protocol
 * @info:	information about the opening of a protocol
225
226
227
228
229
230
 */
struct efi_open_protocol_info_item {
	struct list_head link;
	struct efi_open_protocol_info_entry info;
};

231
232
233
/**
 * struct efi_handler - single protocol interface of a handle
 *
234
235
 * 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
236
 * protocol GUID to the respective protocol interface
237
238
239
240
241
 *
 * @link:		link to the list of protocols of a handle
 * @guid:		GUID of the protocol
 * @protocol_interface:	protocol interface
 * @open_infos		link to the list of open protocol info items
242
 */
243
struct efi_handler {
244
	struct list_head link;
245
	const efi_guid_t *guid;
246
	void *protocol_interface;
247
	struct list_head open_infos;
248
249
};

250
251
252
253
254
255
256
257
/**
 * enum efi_object_type - type of EFI object
 *
 * In UnloadImage we must be able to identify if the handle relates to a
 * started image.
 */
enum efi_object_type {
	EFI_OBJECT_TYPE_UNDEFINED = 0,
258
	EFI_OBJECT_TYPE_U_BOOT_FIRMWARE,
259
260
261
262
	EFI_OBJECT_TYPE_LOADED_IMAGE,
	EFI_OBJECT_TYPE_STARTED_IMAGE,
};

263
264
265
266
267
268
269
270
271
272
273
274
275
/**
 * struct efi_object - dereferenced EFI handle
 *
 * @link:	pointers to put the handle into a linked list
 * @protocols:	linked list with the protocol interfaces installed on this
 *		handle
 *
 * UEFI offers a flexible and expandable object model. The objects in the UEFI
 * API are devices, drivers, and loaded images. struct efi_object is our storage
 * structure for these objects.
 *
 * When including this structure into a larger structure always put it first so
 * that when deleting a handle the whole encompassing structure can be freed.
276
 *
277
278
 * A pointer to this structure is referred to as a handle. Typedef efi_handle_t
 * has been created for such pointers.
279
280
281
282
 */
struct efi_object {
	/* Every UEFI object is part of a global object list */
	struct list_head link;
283
284
	/* The list of protocols */
	struct list_head protocols;
285
	enum efi_object_type type;
286
287
};

288
289
290
291
292
enum efi_image_auth_status {
	EFI_IMAGE_AUTH_FAILED = 0,
	EFI_IMAGE_AUTH_PASSED,
};

293
294
/**
 * struct efi_loaded_image_obj - handle of a loaded image
295
296
 *
 * @header:		EFI object header
297
298
299
 * @exit_status:	exit status passed to Exit()
 * @exit_data_size:	exit data size passed to Exit()
 * @exit_data:		exit data passed to Exit()
300
 * @exit_jmp:		long jump buffer for returning from started image
301
 * @entry:		entry address of the relocated image
302
303
 * @image_type:		indicates if the image is an applicition or a driver
 * @auth_status:	indicates if the image is authenticated
304
305
 */
struct efi_loaded_image_obj {
306
	struct efi_object header;
307
	efi_status_t *exit_status;
308
309
	efi_uintn_t *exit_data_size;
	u16 **exit_data;
310
	struct jmp_buf_data *exit_jmp;
311
312
	EFIAPI efi_status_t (*entry)(efi_handle_t image_handle,
				     struct efi_system_table *st);
313
	u16 image_type;
314
	enum efi_image_auth_status auth_status;
315
316
};

317
318
319
/**
 * struct efi_event
 *
320
 * @link:		Link to list of all events
321
 * @queue_link:		Link to the list of queued events
322
323
324
325
 * @type:		Type of event, see efi_create_event
 * @notify_tpl:		Task priority level of notifications
 * @nofify_function:	Function to call when the event is triggered
 * @notify_context:	Data to be passed to the notify function
326
 * @group:		Event group
327
328
 * @trigger_time:	Period of the timer
 * @trigger_next:	Next time to trigger the timer
329
 * @trigger_type:	Type of timer, see efi_set_timer
330
 * @is_signaled:	The event occurred. The event is in the signaled state.
331
332
 */
struct efi_event {
333
	struct list_head link;
334
	struct list_head queue_link;
335
	uint32_t type;
336
	efi_uintn_t notify_tpl;
337
338
	void (EFIAPI *notify_function)(struct efi_event *event, void *context);
	void *notify_context;
339
	const efi_guid_t *group;
340
341
	u64 trigger_next;
	u64 trigger_time;
342
	enum efi_timer_delay trigger_type;
343
	bool is_signaled;
344
345
};

346
347
/* This list contains all UEFI objects we know of */
extern struct list_head efi_obj_list;
348
349
/* List of all events */
extern struct list_head efi_events;
350

351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
/**
 * struct efi_protocol_notification - handle for notified protocol
 *
 * When a protocol interface is installed for which an event was registered with
 * the RegisterProtocolNotify() service this structure is used to hold the
 * handle on which the protocol interface was installed.
 *
 * @link:	link to list of all handles notified for this event
 * @handle:	handle on which the notified protocol interface was installed
 */
struct efi_protocol_notification {
	struct list_head link;
	efi_handle_t handle;
};

366
367
368
369
370
/**
 * efi_register_notify_event - event registered by RegisterProtocolNotify()
 *
 * The address of this structure serves as registration value.
 *
371
372
373
374
375
376
 * @link:	link to list of all registered events
 * @event:	registered event. The same event may registered for multiple
 *		GUIDs.
 * @protocol:	protocol for which the event is registered
 * @handles:	linked list of all handles on which the notified protocol was
 *		installed
377
378
379
380
381
 */
struct efi_register_notify_event {
	struct list_head link;
	struct efi_event *event;
	efi_guid_t protocol;
382
	struct list_head handles;
383
384
385
386
387
};

/* List of all events registered by RegisterProtocolNotify() */
extern struct list_head efi_register_notify_events;

388
389
/* Initialize efi execution environment */
efi_status_t efi_init_obj_list(void);
390
391
/* Install device tree */
efi_status_t efi_install_fdt(void *fdt);
392
393
/* Run loaded UEFI image */
efi_status_t efi_run_image(void *source_buffer, efi_uintn_t source_size);
394
395
/* Initialize variable services */
efi_status_t efi_init_variables(void);
396
397
/* Notify ExitBootServices() is called */
void efi_variables_boot_exit_notify(void);
398
399
/* Called by bootefi to initialize root node */
efi_status_t efi_root_node_register(void);
400
401
/* Called by bootefi to initialize runtime */
efi_status_t efi_initialize_system_table(void);
402
403
/* efi_runtime_detach() - detach unimplemented runtime functions */
void efi_runtime_detach(void);
404
405
406
/* efi_convert_pointer() - convert pointer to virtual address */
efi_status_t EFIAPI efi_convert_pointer(efi_uintn_t debug_disposition,
					void **address);
407
/* Called by bootefi to make console interface available */
408
efi_status_t efi_console_register(void);
409
/* Called by bootefi to make all disk storage accessible as EFI objects */
410
efi_status_t efi_disk_register(void);
411
412
/* Called by efi_init_obj_list() to install EFI_RNG_PROTOCOL */
efi_status_t efi_rng_register(void);
413
414
/* Called by efi_init_obj_list() to install EFI_TCG2_PROTOCOL */
efi_status_t efi_tcg2_register(void);
415
416
417
418
/* Create handles and protocols for the partitions of a block device */
int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc,
			       const char *if_typename, int diskid,
			       const char *pdevname);
419
420
/* Check if it is EFI system partition */
bool efi_disk_is_system_part(efi_handle_t handle);
Alexander Graf's avatar
Alexander Graf committed
421
/* Called by bootefi to make GOP (graphical) interface available */
422
efi_status_t efi_gop_register(void);
423
/* Called by bootefi to make the network interface available */
424
efi_status_t efi_net_register(void);
425
/* Called by bootefi to make the watchdog available */
426
efi_status_t efi_watchdog_register(void);
427
efi_status_t efi_initrd_register(void);
428
/* Called by bootefi to make SMBIOS tables available */
429
430
431
432
433
434
435
436
/**
 * efi_acpi_register() - write out ACPI tables
 *
 * Called by bootefi to make ACPI tables available
 *
 * @return 0 if OK, -ENOMEM if no memory is available for the tables
 */
efi_status_t efi_acpi_register(void);
437
438
439
440
441
442
443
/**
 * efi_smbios_register() - write out SMBIOS tables
 *
 * Called by bootefi to make SMBIOS tables available
 *
 * @return 0 if OK, -ENOMEM if no memory is available for the tables
 */
444
efi_status_t efi_smbios_register(void);
445

446
447
448
struct efi_simple_file_system_protocol *
efi_fs_from_path(struct efi_device_path *fp);

449
450
/* Called by networking code to memorize the dhcp ack package */
void efi_net_set_dhcp_ack(void *pkt, int len);
451
452
/* Called by efi_set_watchdog_timer to reset the timer */
efi_status_t efi_set_watchdog(unsigned long timeout);
453

454
455
456
/* Called from places to check whether a timer expired */
void efi_timer_check(void);
/* PE loader implementation */
457
458
efi_status_t efi_load_pe(struct efi_loaded_image_obj *handle,
			 void *efi, size_t efi_size,
459
			 struct efi_loaded_image *loaded_image_info);
460
461
/* Called once to store the pristine gd pointer */
void efi_save_gd(void);
462
463
/* Special case handler for error/abort that just tries to dtrt to get
 * back to u-boot world */
464
void efi_restore_gd(void);
465
466
/* Call this to relocate the runtime section to an address space */
void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map);
467
/* Call this to set the current device name */
468
void efi_set_bootdev(const char *dev, const char *devnr, const char *path);
469
/* Add a new object to the object list. */
470
void efi_add_handle(efi_handle_t obj);
471
/* Create handle */
472
efi_status_t efi_create_handle(efi_handle_t *handle);
473
/* Delete handle */
474
void efi_delete_handle(efi_handle_t obj);
475
/* Call this to validate a handle and find the EFI object for it */
476
struct efi_object *efi_search_obj(const efi_handle_t handle);
477
478
479
480
481
482
483
/* Load image */
efi_status_t EFIAPI efi_load_image(bool boot_policy,
				   efi_handle_t parent_image,
				   struct efi_device_path *file_path,
				   void *source_buffer,
				   efi_uintn_t source_size,
				   efi_handle_t *image_handle);
484
485
486
487
/* Start image */
efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle,
				    efi_uintn_t *exit_data_size,
				    u16 **exit_data);
488
489
/* Unload image */
efi_status_t EFIAPI efi_unload_image(efi_handle_t image_handle);
490
/* Find a protocol on a handle */
491
efi_status_t efi_search_protocol(const efi_handle_t handle,
492
493
494
				 const efi_guid_t *protocol_guid,
				 struct efi_handler **handler);
/* Install new protocol on a handle */
495
496
efi_status_t efi_add_protocol(const efi_handle_t handle,
			      const efi_guid_t *protocol,
497
498
			      void *protocol_interface);
/* Delete protocol from a handle */
499
500
efi_status_t efi_remove_protocol(const efi_handle_t handle,
				 const efi_guid_t *protocol,
501
502
				 void *protocol_interface);
/* Delete all protocols from a handle */
503
efi_status_t efi_remove_all_protocols(const efi_handle_t handle);
504
505
506
/* Install multiple protocol interfaces */
efi_status_t EFIAPI efi_install_multiple_protocol_interfaces
				(efi_handle_t *handle, ...);
507
508
509
510
511
512
513
514
515
516
517
518
519
520
/* Get handles that support a given protocol */
efi_status_t EFIAPI efi_locate_handle_buffer(
			enum efi_locate_search_type search_type,
			const efi_guid_t *protocol, void *search_key,
			efi_uintn_t *no_handles, efi_handle_t **buffer);
/* Close an previously opened protocol interface */
efi_status_t EFIAPI efi_close_protocol(efi_handle_t handle,
				       const efi_guid_t *protocol,
				       efi_handle_t agent_handle,
				       efi_handle_t controller_handle);
/* Open a protocol interface */
efi_status_t EFIAPI efi_handle_protocol(efi_handle_t handle,
					const efi_guid_t *protocol,
					void **protocol_interface);
521
/* Call this to create an event */
522
efi_status_t efi_create_event(uint32_t type, efi_uintn_t notify_tpl,
523
524
525
			      void (EFIAPI *notify_function) (
					struct efi_event *event,
					void *context),
526
527
			      void *notify_context, efi_guid_t *group,
			      struct efi_event **event);
528
/* Call this to set a timer */
529
efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type,
530
			   uint64_t trigger_time);
531
/* Call this to signal an event */
532
void efi_signal_event(struct efi_event *event);
533

534
535
536
537
538
539
540
/* open file system: */
struct efi_simple_file_system_protocol *efi_simple_file_system(
		struct blk_desc *desc, int part, struct efi_device_path *dp);

/* open file from device-path: */
struct efi_file_handle *efi_file_from_path(struct efi_device_path *fp);

541
542
543
544
545
546
547
548
549
550
/**
 * efi_size_in_pages() - convert size in bytes to size in pages
 *
 * This macro returns the number of EFI memory pages required to hold 'size'
 * bytes.
 *
 * @size:	size in bytes
 * Return:	size in pages
 */
#define efi_size_in_pages(size) ((size + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT)
551
552
553
/* 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 */
554
efi_status_t efi_allocate_pages(int type, int memory_type, efi_uintn_t pages,
555
				uint64_t *memory);
556
/* EFI memory free function. */
557
efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages);
558
/* EFI memory allocator for small allocations */
559
efi_status_t efi_allocate_pool(int pool_type, efi_uintn_t size,
560
			       void **buffer);
561
562
/* EFI pool memory free function. */
efi_status_t efi_free_pool(void *buffer);
563
/* Returns the EFI memory map */
564
efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size,
565
				struct efi_mem_desc *memory_map,
566
567
				efi_uintn_t *map_key,
				efi_uintn_t *descriptor_size,
568
569
				uint32_t *descriptor_version);
/* Adds a range into the EFI memory map */
570
efi_status_t efi_add_memory_map(u64 start, u64 size, int memory_type);
571
572
573
574
/* Adds a conventional range into the EFI memory map */
efi_status_t efi_add_conventional_memory_map(u64 ram_start, u64 ram_end,
					     u64 ram_top);

575
/* Called by board init to initialize the EFI drivers */
576
efi_status_t efi_driver_init(void);
577
578
/* Called by board init to initialize the EFI memory map */
int efi_memory_init(void);
579
580
/* 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);
581
/* Sets up a loaded image */
582
583
584
585
efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path,
				    struct efi_device_path *file_path,
				    struct efi_loaded_image_obj **handle_ptr,
				    struct efi_loaded_image **info_ptr);
586
587
/* Print information about all loaded images */
void efi_print_image_infos(void *pc);
588

589
590
591
592
593
#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
extern void *efi_bounce_buffer;
#define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024)
#endif

Rob Clark's avatar
Rob Clark committed
594
595

struct efi_device_path *efi_dp_next(const struct efi_device_path *dp);
596
597
int efi_dp_match(const struct efi_device_path *a,
		 const struct efi_device_path *b);
Rob Clark's avatar
Rob Clark committed
598
599
struct efi_object *efi_dp_find_obj(struct efi_device_path *dp,
				   struct efi_device_path **rem);
600
601
602
603
/* get size of the first device path instance excluding end node */
efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp);
/* size of multi-instance device path excluding end node */
efi_uintn_t efi_dp_size(const struct efi_device_path *dp);
Rob Clark's avatar
Rob Clark committed
604
605
606
607
608
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);
609
610
611
612
/* Create a device path node of given type, sub-type, length */
struct efi_device_path *efi_dp_create_device_node(const u8 type,
						  const u8 sub_type,
						  const u16 length);
613
614
615
616
617
618
619
620
621
/* Append device path instance */
struct efi_device_path *efi_dp_append_instance(
		const struct efi_device_path *dp,
		const struct efi_device_path *dpi);
/* Get next device path instance */
struct efi_device_path *efi_dp_get_next_instance(struct efi_device_path **dp,
						 efi_uintn_t *size);
/* Check if a device path contains muliple instances */
bool efi_dp_is_multi_instance(const struct efi_device_path *dp);
Rob Clark's avatar
Rob Clark committed
622
623

struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part);
624
625
/* Create a device node for a block device partition. */
struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part);
Rob Clark's avatar
Rob Clark committed
626
627
628
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);
629
630
631
struct efi_device_path *efi_dp_from_mem(uint32_t mem_type,
					uint64_t start_address,
					uint64_t end_address);
632
633
634
/* Determine the last device path node that is not the end node. */
const struct efi_device_path *efi_dp_last_node(
			const struct efi_device_path *dp);
635
636
637
efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path,
				    struct efi_device_path **device_path,
				    struct efi_device_path **file_path);
638
639
640
641
efi_status_t efi_dp_from_name(const char *dev, const char *devnr,
			      const char *path,
			      struct efi_device_path **device,
			      struct efi_device_path **file);
642
643
ssize_t efi_dp_check_length(const struct efi_device_path *dp,
			    const size_t maxlen);
Rob Clark's avatar
Rob Clark committed
644
645
646
647
648

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

649
650
651
652
/*
 * 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
 */
653
654
#define __efi_runtime_data __attribute__ ((section (".data.efi_runtime")))
#define __efi_runtime __attribute__ ((section (".text.efi_runtime")))
655

656
657
658
/* Indicate supported runtime services */
efi_status_t efi_init_runtime_supported(void);

659
660
661
/* Update CRC32 in table header */
void __efi_runtime efi_update_table_header_crc32(struct efi_table_hdr *table);

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

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

668
void __efi_runtime EFIAPI efi_reset_system(
669
670
671
			enum efi_reset_type reset_type,
			efi_status_t reset_status,
			unsigned long data_size, void *reset_data);
672
673
674

/* Architecture specific initialization of the EFI subsystem */
efi_status_t efi_reset_system_init(void);
675

676
efi_status_t __efi_runtime EFIAPI efi_get_time(
677
678
679
			struct efi_time *time,
			struct efi_time_cap *capabilities);

680
681
efi_status_t __efi_runtime EFIAPI efi_set_time(struct efi_time *time);

682
683
684
685
686
687
688
689
690
#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

691
692
693
efi_status_t EFIAPI efi_get_variable(u16 *variable_name,
				     const efi_guid_t *vendor, u32 *attributes,
				     efi_uintn_t *data_size, void *data);
694
695
efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size,
					       u16 *variable_name,
696
					       efi_guid_t *vendor);
697
698
efi_status_t EFIAPI efi_set_variable(u16 *variable_name,
				     const efi_guid_t *vendor, u32 attributes,
699
				     efi_uintn_t data_size, const void *data);
Rob Clark's avatar
Rob Clark committed
700

701
702
703
704
705
efi_status_t EFIAPI efi_query_variable_info(
			u32 attributes, u64 *maximum_variable_storage_size,
			u64 *remaining_variable_storage_size,
			u64 *maximum_variable_size);

706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
/*
 * See section 3.1.3 in the v2.7 UEFI spec for more details on
 * the layout of EFI_LOAD_OPTION.  In short it is:
 *
 *    typedef struct _EFI_LOAD_OPTION {
 *        UINT32 Attributes;
 *        UINT16 FilePathListLength;
 *        // CHAR16 Description[];   <-- variable length, NULL terminated
 *        // EFI_DEVICE_PATH_PROTOCOL FilePathList[];
 *						 <-- FilePathListLength bytes
 *        // UINT8 OptionalData[];
 *    } EFI_LOAD_OPTION;
 */
struct efi_load_option {
	u32 attributes;
	u16 file_path_length;
	u16 *label;
	struct efi_device_path *file_path;
724
	const u8 *optional_data;
725
726
};

727
728
efi_status_t efi_deserialize_load_option(struct efi_load_option *lo, u8 *data,
					 efi_uintn_t *size);
729
unsigned long efi_serialize_load_option(struct efi_load_option *lo, u8 **data);
730
731
732
efi_status_t efi_set_load_options(efi_handle_t handle,
				  efi_uintn_t load_options_size,
				  void *load_options);
733
efi_status_t efi_bootmgr_load(efi_handle_t *handle, void **load_options);
Rob Clark's avatar
Rob Clark committed
734

735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
/**
 * efi_image_regions - A list of memory regions
 *
 * @max:	Maximum number of regions
 * @num:	Number of regions
 * @reg:	array of regions
 */
struct efi_image_regions {
	int			max;
	int			num;
	struct image_region	reg[];
};

/**
 * efi_sig_data - A decoded data of struct efi_signature_data
 *
 * This structure represents an internal form of signature in
 * signature database. A listed list may represent a signature list.
 *
 * @next:	Pointer to next entry
 * @onwer:	Signature owner
 * @data:	Pointer to signature data
 * @size:	Size of signature data
 */
struct efi_sig_data {
	struct efi_sig_data *next;
	efi_guid_t owner;
	void *data;
	size_t size;
};

/**
 * efi_signature_store - A decoded data of signature database
 *
 * This structure represents an internal form of signature database.
 *
 * @next:		Pointer to next entry
 * @sig_type:		Signature type
 * @sig_data_list:	Pointer to signature list
 */
struct efi_signature_store {
	struct efi_signature_store *next;
	efi_guid_t sig_type;
	struct efi_sig_data *sig_data_list;
};

struct x509_certificate;
struct pkcs7_message;

784
785
bool efi_signature_lookup_digest(struct efi_image_regions *regs,
				 struct efi_signature_store *db);
786
787
788
789
bool efi_signature_verify(struct efi_image_regions *regs,
			  struct pkcs7_message *msg,
			  struct efi_signature_store *db,
			  struct efi_signature_store *dbx);
790
791
792
793
794
795
static inline bool efi_signature_verify_one(struct efi_image_regions *regs,
					    struct pkcs7_message *msg,
					    struct efi_signature_store *db)
{
	return efi_signature_verify(regs, msg, db, NULL);
}
796
797
bool efi_signature_check_signers(struct pkcs7_message *msg,
				 struct efi_signature_store *dbx);
798
799
800
801

efi_status_t efi_image_region_add(struct efi_image_regions *regs,
				  const void *start, const void *end,
				  int nocheck);
802
803
804

void efi_sigstore_free(struct efi_signature_store *sigstore);
struct efi_signature_store *efi_sigstore_parse_sigdb(u16 *name);
805
806

bool efi_secure_boot_enabled(void);
807
808
809

bool efi_image_parse(void *efi, size_t len, struct efi_image_regions **regp,
		     WIN_CERTIFICATE **auth, size_t *auth_len);
810

811
812
813
/* runtime implementation of memcpy() */
void efi_memcpy_runtime(void *dest, const void *src, size_t n);

814
815
816
/* commonly used helper function */
u16 *efi_create_indexed_name(u16 *buffer, const char *name, unsigned int index);

Stephen Warren's avatar
Stephen Warren committed
817
#else /* CONFIG_IS_ENABLED(EFI_LOADER) */
818

819
/* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */
820
821
#define __efi_runtime_data
#define __efi_runtime
822
823
824
825
static inline efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len)
{
	return EFI_SUCCESS;
}
826

827
828
/* No loader configured, stub out EFI_ENTRY */
static inline void efi_restore_gd(void) { }
829
830
static inline void efi_set_bootdev(const char *dev, const char *devnr,
				   const char *path) { }
831
static inline void efi_net_set_dhcp_ack(void *pkt, int len) { }
832
static inline void efi_print_image_infos(void *pc) { }
833

Stephen Warren's avatar
Stephen Warren committed
834
#endif /* CONFIG_IS_ENABLED(EFI_LOADER) */
835
836

#endif /* _EFI_LOADER_H */