1/* SPDX-License-Identifier: GPL-2.0+ */ 2/* 3 * EFI application loader 4 * 5 * Copyright (c) 2016 Alexander Graf 6 */ 7 8#ifndef _EFI_LOADER_H 9#define _EFI_LOADER_H 1 10 11#include <blk.h> 12#include <event.h> 13#include <log.h> 14#include <part_efi.h> 15#include <efi_api.h> 16#include <image.h> 17#include <pe.h> 18#include <linux/list.h> 19#include <linux/oid_registry.h> 20 21struct blk_desc; 22struct jmp_buf_data; 23 24static inline int guidcmp(const void *g1, const void *g2) 25{ 26 return memcmp(g1, g2, sizeof(efi_guid_t)); 27} 28 29static inline void *guidcpy(void *dst, const void *src) 30{ 31 return memcpy(dst, src, sizeof(efi_guid_t)); 32} 33 34#if CONFIG_IS_ENABLED(EFI_LOADER) 35 36/** 37 * __efi_runtime_data - declares a non-const variable for EFI runtime section 38 * 39 * This macro indicates that a variable is non-const and should go into the 40 * EFI runtime section, and thus still be available when the OS is running. 41 * 42 * Only use on variables not declared const. 43 * 44 * Example: 45 * 46 * :: 47 * 48 * static __efi_runtime_data my_computed_table[256]; 49 */ 50#define __efi_runtime_data __section(".data.efi_runtime") 51 52/** 53 * __efi_runtime_rodata - declares a read-only variable for EFI runtime section 54 * 55 * This macro indicates that a variable is read-only (const) and should go into 56 * the EFI runtime section, and thus still be available when the OS is running. 57 * 58 * Only use on variables also declared const. 59 * 60 * Example: 61 * 62 * :: 63 * 64 * static const __efi_runtime_rodata my_const_table[] = { 1, 2, 3 }; 65 */ 66#define __efi_runtime_rodata __section(".rodata.efi_runtime") 67 68/** 69 * __efi_runtime - declares a function for EFI runtime section 70 * 71 * This macro indicates that a function should go into the EFI runtime section, 72 * and thus still be available when the OS is running. 73 * 74 * Example: 75 * 76 * :: 77 * 78 * static __efi_runtime compute_my_table(void); 79 */ 80#define __efi_runtime __section(".text.efi_runtime") 81 82/* 83 * Call this with mmio_ptr as the _pointer_ to a pointer to an MMIO region 84 * to make it available at runtime 85 */ 86efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len); 87 88/* 89 * Special case handler for error/abort that just tries to dtrt to get 90 * back to u-boot world 91 */ 92void efi_restore_gd(void); 93 94/* Called by networking code to memorize the dhcp ack package */ 95void efi_net_set_dhcp_ack(void *pkt, int len); 96/* Print information about all loaded images */ 97void efi_print_image_infos(void *pc); 98 99/* Hook at initialization */ 100efi_status_t efi_launch_capsules(void); 101 102#else /* CONFIG_IS_ENABLED(EFI_LOADER) */ 103 104/* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */ 105#define __efi_runtime_data 106#define __efi_runtime_rodata 107#define __efi_runtime 108static inline efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len) 109{ 110 return EFI_SUCCESS; 111} 112 113/* No loader configured, stub out EFI_ENTRY */ 114static inline void efi_restore_gd(void) { } 115static inline void efi_net_set_dhcp_ack(void *pkt, int len) { } 116static inline void efi_print_image_infos(void *pc) { } 117static inline efi_status_t efi_launch_capsules(void) 118{ 119 return EFI_SUCCESS; 120} 121 122#endif /* CONFIG_IS_ENABLED(EFI_LOADER) */ 123 124#if CONFIG_IS_ENABLED(EFI_BINARY_EXEC) 125/* Call this to unset the current device name */ 126void efi_clear_bootdev(void); 127/* Call this to set the current device name */ 128void efi_set_bootdev(const char *dev, const char *devnr, const char *path, 129 void *buffer, size_t buffer_size); 130#else 131static inline void efi_clear_bootdev(void) { } 132 133static inline void efi_set_bootdev(const char *dev, const char *devnr, 134 const char *path, void *buffer, 135 size_t buffer_size) { } 136#endif 137 138/* Maximum number of configuration tables */ 139#define EFI_MAX_CONFIGURATION_TABLES 16 140 141/* GUID used by the root node */ 142#define U_BOOT_GUID \ 143 EFI_GUID(0xe61d73b9, 0xa384, 0x4acc, \ 144 0xae, 0xab, 0x82, 0xe8, 0x28, 0xf3, 0x62, 0x8b) 145/* GUID used as root for blkmap devices */ 146#define U_BOOT_BLKMAP_DEV_GUID \ 147 EFI_GUID(0x4cad859d, 0xd644, 0x42ff, \ 148 0x87, 0x0b, 0xc0, 0x2e, 0xac, 0x05, 0x58, 0x63) 149/* GUID used as host device on sandbox */ 150#define U_BOOT_HOST_DEV_GUID \ 151 EFI_GUID(0xbbe4e671, 0x5773, 0x4ea1, \ 152 0x9a, 0xab, 0x3a, 0x7d, 0xbf, 0x40, 0xc4, 0x82) 153/* GUID used as root for virtio devices */ 154#define U_BOOT_VIRTIO_DEV_GUID \ 155 EFI_GUID(0x63293792, 0xadf5, 0x9325, \ 156 0xb9, 0x9f, 0x4e, 0x0e, 0x45, 0x5c, 0x1b, 0x1e) 157 158/* GUID for the auto generated boot menu entry */ 159#define EFICONFIG_AUTO_GENERATED_ENTRY_GUID \ 160 EFI_GUID(0x8108ac4e, 0x9f11, 0x4d59, \ 161 0x85, 0x0e, 0xe2, 0x1a, 0x52, 0x2c, 0x59, 0xb2) 162#define U_BOOT_EFI_RT_VAR_FILE_GUID \ 163 EFI_GUID(0xb2ac5fc9, 0x92b7, 0x4acd, \ 164 0xae, 0xac, 0x11, 0xe8, 0x18, 0xc3, 0x13, 0x0c) 165 166 167/* Use internal device tree when starting UEFI application */ 168#define EFI_FDT_USE_INTERNAL NULL 169 170/* Root node */ 171extern efi_handle_t efi_root; 172 173/* Set to EFI_SUCCESS when initialized */ 174extern efi_status_t efi_obj_list_initialized; 175 176/* Flag used by the selftest to avoid detaching devices in ExitBootServices() */ 177extern bool efi_st_keep_devices; 178 179/* EFI system partition */ 180extern struct efi_system_partition { 181 enum uclass_id uclass_id; 182 int devnum; 183 u8 part; 184} efi_system_partition; 185 186int __efi_entry_check(void); 187int __efi_exit_check(void); 188const char *__efi_nesting(void); 189const char *__efi_nesting_inc(void); 190const char *__efi_nesting_dec(void); 191 192/* 193 * Enter the u-boot world from UEFI: 194 */ 195#define EFI_ENTRY(format, ...) do { \ 196 assert(__efi_entry_check()); \ 197 debug("%sEFI: Entry %s(" format ")\n", __efi_nesting_inc(), \ 198 __func__, ##__VA_ARGS__); \ 199 } while(0) 200 201/* 202 * Exit the u-boot world back to UEFI: 203 */ 204#define EFI_EXIT(ret) ({ \ 205 typeof(ret) _r = ret; \ 206 debug("%sEFI: Exit: %s: %u\n", __efi_nesting_dec(), \ 207 __func__, (u32)((uintptr_t) _r & ~EFI_ERROR_MASK)); \ 208 assert(__efi_exit_check()); \ 209 _r; \ 210 }) 211 212/* 213 * Call non-void UEFI function from u-boot and retrieve return value: 214 */ 215#define EFI_CALL(exp) ({ \ 216 debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ 217 assert(__efi_exit_check()); \ 218 typeof(exp) _r = exp; \ 219 assert(__efi_entry_check()); \ 220 debug("%sEFI: %lu returned by %s\n", __efi_nesting_dec(), \ 221 (unsigned long)((uintptr_t)_r & ~EFI_ERROR_MASK), #exp); \ 222 _r; \ 223}) 224 225/* 226 * Call void UEFI function from u-boot: 227 */ 228#define EFI_CALL_VOID(exp) do { \ 229 debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ 230 assert(__efi_exit_check()); \ 231 exp; \ 232 assert(__efi_entry_check()); \ 233 debug("%sEFI: Return From: %s\n", __efi_nesting_dec(), #exp); \ 234 } while(0) 235 236/* 237 * Write an indented message with EFI prefix 238 */ 239#define EFI_PRINT(format, ...) ({ \ 240 debug("%sEFI: " format, __efi_nesting(), \ 241 ##__VA_ARGS__); \ 242 }) 243 244#ifdef CONFIG_SYS_CACHELINE_SIZE 245#define EFI_CACHELINE_SIZE CONFIG_SYS_CACHELINE_SIZE 246#else 247/* Just use the greatest cache flush alignment requirement I'm aware of */ 248#define EFI_CACHELINE_SIZE 128 249#endif 250 251/* max bootmenu title size for volume selection */ 252#define BOOTMENU_DEVICE_NAME_MAX 16 253 254/* Key identifying current memory map */ 255extern efi_uintn_t efi_memory_map_key; 256 257extern struct efi_runtime_services efi_runtime_services; 258extern struct efi_system_table systab; 259 260extern struct efi_simple_text_output_protocol efi_con_out; 261extern struct efi_simple_text_input_protocol efi_con_in; 262extern struct efi_console_control_protocol efi_console_control; 263extern const struct efi_device_path_to_text_protocol efi_device_path_to_text; 264/* implementation of the EFI_DEVICE_PATH_UTILITIES_PROTOCOL */ 265extern const struct efi_device_path_utilities_protocol 266 efi_device_path_utilities; 267/* current version of the EFI_UNICODE_COLLATION_PROTOCOL */ 268extern const struct efi_unicode_collation_protocol 269 efi_unicode_collation_protocol2; 270extern const struct efi_hii_config_routing_protocol efi_hii_config_routing; 271extern const struct efi_hii_config_access_protocol efi_hii_config_access; 272extern const struct efi_hii_database_protocol efi_hii_database; 273extern const struct efi_hii_string_protocol efi_hii_string; 274 275uint16_t *efi_dp_str(struct efi_device_path *dp); 276 277/* GUID for the auto generated boot menu entry */ 278extern const efi_guid_t efi_guid_bootmenu_auto_generated; 279 280/* GUID of the U-Boot root node */ 281extern const efi_guid_t efi_u_boot_guid; 282#ifdef CONFIG_SANDBOX 283/* GUID of U-Boot host device on sandbox */ 284extern const efi_guid_t efi_guid_host_dev; 285#endif 286/* GUID of the EFI_BLOCK_IO_PROTOCOL */ 287extern const efi_guid_t efi_block_io_guid; 288extern const efi_guid_t efi_global_variable_guid; 289extern const efi_guid_t efi_guid_console_control; 290extern const efi_guid_t efi_guid_device_path; 291/* GUID of the EFI system partition */ 292extern const efi_guid_t efi_system_partition_guid; 293/* GUID of the EFI_DRIVER_BINDING_PROTOCOL */ 294extern const efi_guid_t efi_guid_driver_binding_protocol; 295/* event group ExitBootServices() invoked */ 296extern const efi_guid_t efi_guid_event_group_exit_boot_services; 297/* event group SetVirtualAddressMap() invoked */ 298extern const efi_guid_t efi_guid_event_group_virtual_address_change; 299/* event group memory map changed */ 300extern const efi_guid_t efi_guid_event_group_memory_map_change; 301/* event group boot manager about to boot */ 302extern const efi_guid_t efi_guid_event_group_ready_to_boot; 303/* event group ResetSystem() invoked (before ExitBootServices) */ 304extern const efi_guid_t efi_guid_event_group_reset_system; 305/* event group return to efibootmgr */ 306extern const efi_guid_t efi_guid_event_group_return_to_efibootmgr; 307/* GUID of the device tree table */ 308extern const efi_guid_t efi_guid_fdt; 309extern const efi_guid_t efi_guid_loaded_image; 310extern const efi_guid_t efi_guid_loaded_image_device_path; 311extern const efi_guid_t efi_guid_device_path_to_text_protocol; 312extern const efi_guid_t efi_simple_file_system_protocol_guid; 313extern const efi_guid_t efi_file_info_guid; 314/* GUID for file system information */ 315extern const efi_guid_t efi_file_system_info_guid; 316extern const efi_guid_t efi_guid_device_path_utilities_protocol; 317/* GUID of the deprecated Unicode collation protocol */ 318extern const efi_guid_t efi_guid_unicode_collation_protocol; 319/* GUIDs of the Load File and Load File2 protocol */ 320extern const efi_guid_t efi_guid_load_file_protocol; 321extern const efi_guid_t efi_guid_load_file2_protocol; 322/* GUID of the Unicode collation protocol */ 323extern const efi_guid_t efi_guid_unicode_collation_protocol2; 324extern const efi_guid_t efi_guid_hii_config_routing_protocol; 325extern const efi_guid_t efi_guid_hii_config_access_protocol; 326extern const efi_guid_t efi_guid_hii_database_protocol; 327extern const efi_guid_t efi_guid_hii_string_protocol; 328/* GUIDs for authentication */ 329extern const efi_guid_t efi_guid_image_security_database; 330extern const efi_guid_t efi_guid_sha256; 331extern const efi_guid_t efi_guid_cert_x509; 332extern const efi_guid_t efi_guid_cert_x509_sha256; 333extern const efi_guid_t efi_guid_cert_x509_sha384; 334extern const efi_guid_t efi_guid_cert_x509_sha512; 335extern const efi_guid_t efi_guid_cert_type_pkcs7; 336 337/* GUID of RNG protocol */ 338extern const efi_guid_t efi_guid_rng_protocol; 339/* GUID of capsule update result */ 340extern const efi_guid_t efi_guid_capsule_report; 341/* GUID of firmware management protocol */ 342extern const efi_guid_t efi_guid_firmware_management_protocol; 343/* GUID for the ESRT */ 344extern const efi_guid_t efi_esrt_guid; 345/* GUID of the SMBIOS table */ 346extern const efi_guid_t smbios_guid; 347extern const efi_guid_t smbios3_guid; 348/*GUID of console */ 349extern const efi_guid_t efi_guid_text_input_protocol; 350extern const efi_guid_t efi_guid_text_output_protocol; 351 352/** 353 * struct efi_open_protocol_info_item - open protocol info item 354 * 355 * When a protocol is opened a open protocol info entry is created. 356 * These are maintained in a list. 357 * 358 * @link: link to the list of open protocol info entries of a protocol 359 * @info: information about the opening of a protocol 360 */ 361struct efi_open_protocol_info_item { 362 struct list_head link; 363 struct efi_open_protocol_info_entry info; 364}; 365 366/** 367 * struct efi_handler - single protocol interface of a handle 368 * 369 * When the UEFI payload wants to open a protocol on an object to get its 370 * interface (usually a struct with callback functions), this struct maps the 371 * protocol GUID to the respective protocol interface 372 * 373 * @link: link to the list of protocols of a handle 374 * @guid: GUID of the protocol 375 * @protocol_interface: protocol interface 376 * @open_infos: link to the list of open protocol info items 377 */ 378struct efi_handler { 379 struct list_head link; 380 const efi_guid_t guid; 381 void *protocol_interface; 382 struct list_head open_infos; 383}; 384 385/** 386 * enum efi_object_type - type of EFI object 387 * 388 * In UnloadImage we must be able to identify if the handle relates to a 389 * started image. 390 */ 391enum efi_object_type { 392 /** @EFI_OBJECT_TYPE_UNDEFINED: undefined image type */ 393 EFI_OBJECT_TYPE_UNDEFINED = 0, 394 /** @EFI_OBJECT_TYPE_U_BOOT_FIRMWARE: U-Boot firmware */ 395 EFI_OBJECT_TYPE_U_BOOT_FIRMWARE, 396 /** @EFI_OBJECT_TYPE_LOADED_IMAGE: loaded image (not started) */ 397 EFI_OBJECT_TYPE_LOADED_IMAGE, 398 /** @EFI_OBJECT_TYPE_STARTED_IMAGE: started image */ 399 EFI_OBJECT_TYPE_STARTED_IMAGE, 400}; 401 402/** 403 * struct efi_object - dereferenced EFI handle 404 * 405 * @link: pointers to put the handle into a linked list 406 * @protocols: linked list with the protocol interfaces installed on this 407 * handle 408 * @type: image type if the handle relates to an image 409 * @dev: pointer to the DM device which is associated with this EFI handle 410 * 411 * UEFI offers a flexible and expandable object model. The objects in the UEFI 412 * API are devices, drivers, and loaded images. struct efi_object is our storage 413 * structure for these objects. 414 * 415 * When including this structure into a larger structure always put it first so 416 * that when deleting a handle the whole encompassing structure can be freed. 417 * 418 * A pointer to this structure is referred to as a handle. Typedef efi_handle_t 419 * has been created for such pointers. 420 */ 421struct efi_object { 422 /* Every UEFI object is part of a global object list */ 423 struct list_head link; 424 /* The list of protocols */ 425 struct list_head protocols; 426 enum efi_object_type type; 427 struct udevice *dev; 428}; 429 430enum efi_image_auth_status { 431 EFI_IMAGE_AUTH_FAILED = 0, 432 EFI_IMAGE_AUTH_PASSED, 433}; 434 435/** 436 * struct efi_loaded_image_obj - handle of a loaded image 437 * 438 * @header: EFI object header 439 * @exit_status: exit status passed to Exit() 440 * @exit_data_size: exit data size passed to Exit() 441 * @exit_data: exit data passed to Exit() 442 * @exit_jmp: long jump buffer for returning from started image 443 * @entry: entry address of the relocated image 444 * @image_type: indicates if the image is an applicition or a driver 445 * @auth_status: indicates if the image is authenticated 446 */ 447struct efi_loaded_image_obj { 448 struct efi_object header; 449 efi_status_t *exit_status; 450 efi_uintn_t *exit_data_size; 451 u16 **exit_data; 452 struct jmp_buf_data *exit_jmp; 453 EFIAPI efi_status_t (*entry)(efi_handle_t image_handle, 454 struct efi_system_table *st); 455 u16 image_type; 456 enum efi_image_auth_status auth_status; 457}; 458 459/** 460 * struct efi_event 461 * 462 * @link: Link to list of all events 463 * @queue_link: Link to the list of queued events 464 * @type: Type of event, see efi_create_event 465 * @notify_tpl: Task priority level of notifications 466 * @notify_function: Function to call when the event is triggered 467 * @notify_context: Data to be passed to the notify function 468 * @group: Event group 469 * @trigger_time: Period of the timer 470 * @trigger_next: Next time to trigger the timer 471 * @trigger_type: Type of timer, see efi_set_timer 472 * @is_signaled: The event occurred. The event is in the signaled state. 473 */ 474struct efi_event { 475 struct list_head link; 476 struct list_head queue_link; 477 uint32_t type; 478 efi_uintn_t notify_tpl; 479 void (EFIAPI *notify_function)(struct efi_event *event, void *context); 480 void *notify_context; 481 const efi_guid_t *group; 482 u64 trigger_next; 483 u64 trigger_time; 484 enum efi_timer_delay trigger_type; 485 bool is_signaled; 486}; 487 488/* This list contains all UEFI objects we know of */ 489extern struct list_head efi_obj_list; 490/* List of all events */ 491extern struct list_head efi_events; 492 493/** 494 * struct efi_protocol_notification - handle for notified protocol 495 * 496 * When a protocol interface is installed for which an event was registered with 497 * the RegisterProtocolNotify() service this structure is used to hold the 498 * handle on which the protocol interface was installed. 499 * 500 * @link: link to list of all handles notified for this event 501 * @handle: handle on which the notified protocol interface was installed 502 */ 503struct efi_protocol_notification { 504 struct list_head link; 505 efi_handle_t handle; 506}; 507 508/** 509 * struct efi_register_notify_event - event registered by 510 * RegisterProtocolNotify() 511 * 512 * The address of this structure serves as registration value. 513 * 514 * @link: link to list of all registered events 515 * @event: registered event. The same event may registered for multiple 516 * GUIDs. 517 * @protocol: protocol for which the event is registered 518 * @handles: linked list of all handles on which the notified protocol was 519 * installed 520 */ 521struct efi_register_notify_event { 522 struct list_head link; 523 struct efi_event *event; 524 efi_guid_t protocol; 525 struct list_head handles; 526}; 527 528/* called at pre-initialization */ 529int efi_init_early(void); 530/* Initialize efi execution environment */ 531efi_status_t efi_init_obj_list(void); 532/* Append new boot option in BootOrder variable */ 533efi_status_t efi_bootmgr_append_bootorder(u16 index); 534/* Get unused "Boot####" index */ 535efi_status_t efi_bootmgr_get_unused_bootoption(u16 *buf, 536 efi_uintn_t buf_size, u32 *index); 537/* Generate the media device boot option */ 538efi_status_t efi_bootmgr_update_media_device_boot_option(void); 539/* Delete selected boot option */ 540efi_status_t efi_bootmgr_delete_boot_option(u16 boot_index); 541/* Invoke EFI boot manager */ 542efi_status_t efi_bootmgr_run(void *fdt); 543/* search the boot option index in BootOrder */ 544bool efi_search_bootorder(u16 *bootorder, efi_uintn_t num, u32 target, u32 *index); 545/* Set up console modes */ 546void efi_setup_console_size(void); 547/* Set up load options from environment variable */ 548efi_status_t efi_env_set_load_options(efi_handle_t handle, const char *env_var, 549 u16 **load_options); 550/* Get EFI configuration table */ 551void *efi_get_configuration_table(const efi_guid_t *guid); 552/* Install device tree */ 553efi_status_t efi_install_fdt(void *fdt); 554/* Execute loaded UEFI image */ 555efi_status_t do_bootefi_exec(efi_handle_t handle, void *load_options); 556/* Run loaded UEFI image with given fdt */ 557efi_status_t efi_binary_run(void *image, size_t size, void *fdt); 558/* Initialize variable services */ 559efi_status_t efi_init_variables(void); 560/* Notify ExitBootServices() is called */ 561void efi_variables_boot_exit_notify(void); 562efi_status_t efi_tcg2_notify_exit_boot_services_failed(void); 563/* Measure efi application invocation */ 564efi_status_t efi_tcg2_measure_efi_app_invocation(struct efi_loaded_image_obj *handle); 565/* Measure efi application exit */ 566efi_status_t efi_tcg2_measure_efi_app_exit(void); 567/* Measure DTB */ 568efi_status_t efi_tcg2_measure_dtb(void *dtb); 569/* Called by bootefi to initialize root node */ 570efi_status_t efi_root_node_register(void); 571/* Called by bootefi to initialize runtime */ 572efi_status_t efi_initialize_system_table(void); 573/* efi_runtime_detach() - detach unimplemented runtime functions */ 574void efi_runtime_detach(void); 575/* efi_convert_pointer() - convert pointer to virtual address */ 576efi_status_t EFIAPI efi_convert_pointer(efi_uintn_t debug_disposition, 577 void **address); 578/* Carve out DT reserved memory ranges */ 579void efi_carve_out_dt_rsv(void *fdt); 580/* Purge unused kaslr-seed */ 581void efi_try_purge_kaslr_seed(void *fdt); 582/* Called by bootefi to make console interface available */ 583efi_status_t efi_console_register(void); 584/* Called by efi_init_obj_list() to proble all block devices */ 585efi_status_t efi_disks_register(void); 586/* Called by efi_init_obj_list() to install EFI_RNG_PROTOCOL */ 587efi_status_t efi_rng_register(void); 588/* Called by efi_init_obj_list() to install EFI_TCG2_PROTOCOL */ 589efi_status_t efi_tcg2_register(void); 590/* Called by efi_init_obj_list() to install RISCV_EFI_BOOT_PROTOCOL */ 591efi_status_t efi_riscv_register(void); 592/* Called by efi_init_obj_list() to do initial measurement */ 593efi_status_t efi_tcg2_do_initial_measurement(void); 594/* measure the pe-coff image, extend PCR and add Event Log */ 595efi_status_t tcg2_measure_pe_image(void *efi, u64 efi_size, 596 struct efi_loaded_image_obj *handle, 597 struct efi_loaded_image *loaded_image_info); 598/* Create handles and protocols for the partitions of a block device */ 599int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc, 600 const char *uclass_idname, int diskid, 601 const char *pdevname); 602/* Called by bootefi to make GOP (graphical) interface available */ 603efi_status_t efi_gop_register(void); 604/* Called by bootefi to make the network interface available */ 605efi_status_t efi_net_register(void); 606/* Called by bootefi to make the watchdog available */ 607efi_status_t efi_watchdog_register(void); 608efi_status_t efi_initrd_register(void); 609efi_status_t efi_initrd_deregister(void); 610/* Called by bootefi to make SMBIOS tables available */ 611/** 612 * efi_acpi_register() - write out ACPI tables 613 * 614 * Called by bootefi to make ACPI tables available 615 * 616 * Return: 0 if OK, -ENOMEM if no memory is available for the tables 617 */ 618efi_status_t efi_acpi_register(void); 619/** 620 * efi_smbios_register() - write out SMBIOS tables 621 * 622 * Called by bootefi to make SMBIOS tables available 623 * 624 * Return: 0 if OK, -ENOMEM if no memory is available for the tables 625 */ 626efi_status_t efi_smbios_register(void); 627 628struct efi_simple_file_system_protocol * 629efi_fs_from_path(struct efi_device_path *fp); 630 631/* Called by efi_set_watchdog_timer to reset the timer */ 632efi_status_t efi_set_watchdog(unsigned long timeout); 633 634/* Called from places to check whether a timer expired */ 635void efi_timer_check(void); 636/* Check if a buffer contains a PE-COFF image */ 637efi_status_t efi_check_pe(void *buffer, size_t size, void **nt_header); 638/* PE loader implementation */ 639efi_status_t efi_load_pe(struct efi_loaded_image_obj *handle, 640 void *efi, size_t efi_size, 641 struct efi_loaded_image *loaded_image_info); 642/* Called once to store the pristine gd pointer */ 643void efi_save_gd(void); 644/* Call this to relocate the runtime section to an address space */ 645void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map); 646/* Call this to get image parameters */ 647void efi_get_image_parameters(void **img_addr, size_t *img_size); 648/* Add a new object to the object list. */ 649void efi_add_handle(efi_handle_t obj); 650/* Create handle */ 651efi_status_t efi_create_handle(efi_handle_t *handle); 652/* Delete handle */ 653efi_status_t efi_delete_handle(efi_handle_t obj); 654/* Call this to validate a handle and find the EFI object for it */ 655struct efi_object *efi_search_obj(const efi_handle_t handle); 656/* Locate device_path handle */ 657efi_status_t EFIAPI efi_locate_device_path(const efi_guid_t *protocol, 658 struct efi_device_path **device_path, 659 efi_handle_t *device); 660/* Load image */ 661efi_status_t EFIAPI efi_load_image(bool boot_policy, 662 efi_handle_t parent_image, 663 struct efi_device_path *file_path, 664 void *source_buffer, 665 efi_uintn_t source_size, 666 efi_handle_t *image_handle); 667/* Start image */ 668efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle, 669 efi_uintn_t *exit_data_size, 670 u16 **exit_data); 671/* Unload image */ 672efi_status_t EFIAPI efi_unload_image(efi_handle_t image_handle); 673/* Find a protocol on a handle */ 674efi_status_t efi_search_protocol(const efi_handle_t handle, 675 const efi_guid_t *protocol_guid, 676 struct efi_handler **handler); 677/* Install new protocol on a handle */ 678efi_status_t efi_add_protocol(const efi_handle_t handle, 679 const efi_guid_t *protocol, 680 void *protocol_interface); 681/* Open protocol */ 682efi_status_t efi_protocol_open(struct efi_handler *handler, 683 void **protocol_interface, void *agent_handle, 684 void *controller_handle, uint32_t attributes); 685 686/* Install multiple protocol interfaces */ 687efi_status_t EFIAPI 688efi_install_multiple_protocol_interfaces(efi_handle_t *handle, ...); 689efi_status_t EFIAPI 690efi_uninstall_multiple_protocol_interfaces(efi_handle_t handle, ...); 691/* Get handles that support a given protocol */ 692efi_status_t EFIAPI efi_locate_handle_buffer( 693 enum efi_locate_search_type search_type, 694 const efi_guid_t *protocol, void *search_key, 695 efi_uintn_t *no_handles, efi_handle_t **buffer); 696/* Close a previously opened protocol interface */ 697efi_status_t efi_close_protocol(efi_handle_t handle, const efi_guid_t *protocol, 698 efi_handle_t agent_handle, 699 efi_handle_t controller_handle); 700/* Open a protocol interface */ 701efi_status_t EFIAPI efi_handle_protocol(efi_handle_t handle, 702 const efi_guid_t *protocol, 703 void **protocol_interface); 704/* Call this to create an event */ 705efi_status_t efi_create_event(uint32_t type, efi_uintn_t notify_tpl, 706 void (EFIAPI *notify_function) ( 707 struct efi_event *event, 708 void *context), 709 void *notify_context, const efi_guid_t *group, 710 struct efi_event **event); 711/* Call this to set a timer */ 712efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type, 713 uint64_t trigger_time); 714/* Call this to signal an event */ 715void efi_signal_event(struct efi_event *event); 716 717/* return true if the device is removable */ 718bool efi_disk_is_removable(efi_handle_t handle); 719 720/** 721 * efi_create_simple_file_system() - create simple file system protocol 722 * 723 * Create a simple file system protocol for a partition. 724 * 725 * @desc: block device descriptor 726 * @part: partition number 727 * @dp: device path 728 * @fsp: simple file system protocol 729 * Return: status code 730 */ 731efi_status_t 732efi_create_simple_file_system(struct blk_desc *desc, int part, 733 struct efi_device_path *dp, 734 struct efi_simple_file_system_protocol **fsp); 735 736/* open file from device-path: */ 737struct efi_file_handle *efi_file_from_path(struct efi_device_path *fp); 738 739/* Registers a callback function for a notification event. */ 740efi_status_t EFIAPI efi_register_protocol_notify(const efi_guid_t *protocol, 741 struct efi_event *event, 742 void **registration); 743efi_status_t efi_file_size(struct efi_file_handle *fh, efi_uintn_t *size); 744 745/* get a device path from a Boot#### option */ 746struct efi_device_path *efi_get_dp_from_boot(const efi_guid_t *guid); 747 748/* get len, string (used in u-boot crypto from a guid */ 749const char *guid_to_sha_str(const efi_guid_t *guid); 750int algo_to_len(const char *algo); 751 752int efi_link_dev(efi_handle_t handle, struct udevice *dev); 753int efi_unlink_dev(efi_handle_t handle); 754bool efi_varname_is_load_option(u16 *var_name16, int *index); 755efi_status_t efi_next_variable_name(efi_uintn_t *size, u16 **buf, 756 efi_guid_t *guid); 757 758/** 759 * efi_size_in_pages() - convert size in bytes to size in pages 760 * 761 * This macro returns the number of EFI memory pages required to hold 'size' 762 * bytes. 763 * 764 * @size: size in bytes 765 * Return: size in pages 766 */ 767#define efi_size_in_pages(size) (((size) + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT) 768/* Allocate boot service data pool memory */ 769void *efi_alloc(size_t len); 770/* Allocate pages on the specified alignment */ 771void *efi_alloc_aligned_pages(u64 len, int memory_type, size_t align); 772/* More specific EFI memory allocator, called by EFI payloads */ 773efi_status_t efi_allocate_pages(enum efi_allocate_type type, 774 enum efi_memory_type memory_type, 775 efi_uintn_t pages, uint64_t *memory); 776/* EFI memory free function. */ 777efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages); 778/* EFI memory allocator for small allocations */ 779efi_status_t efi_allocate_pool(enum efi_memory_type pool_type, 780 efi_uintn_t size, void **buffer); 781/* EFI pool memory free function. */ 782efi_status_t efi_free_pool(void *buffer); 783/* Allocate and retrieve EFI memory map */ 784efi_status_t efi_get_memory_map_alloc(efi_uintn_t *map_size, 785 struct efi_mem_desc **memory_map); 786/* Returns the EFI memory map */ 787efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size, 788 struct efi_mem_desc *memory_map, 789 efi_uintn_t *map_key, 790 efi_uintn_t *descriptor_size, 791 uint32_t *descriptor_version); 792/* Adds a range into the EFI memory map */ 793efi_status_t efi_add_memory_map(u64 start, u64 size, int memory_type); 794/* Adds a conventional range into the EFI memory map */ 795efi_status_t efi_add_conventional_memory_map(u64 ram_start, u64 ram_end, 796 u64 ram_top); 797 798/* Called by board init to initialize the EFI drivers */ 799efi_status_t efi_driver_init(void); 800/* Called when a block device is added */ 801int efi_disk_probe(void *ctx, struct event *event); 802/* Called when a block device is removed */ 803int efi_disk_remove(void *ctx, struct event *event); 804/* Called by board init to initialize the EFI memory map */ 805int efi_memory_init(void); 806/* Adds new or overrides configuration table entry to the system table */ 807efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table); 808/* Sets up a loaded image */ 809efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path, 810 struct efi_device_path *file_path, 811 struct efi_loaded_image_obj **handle_ptr, 812 struct efi_loaded_image **info_ptr); 813 814#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER 815extern void *efi_bounce_buffer; 816#define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024) 817#endif 818 819/* shorten device path */ 820struct efi_device_path *efi_dp_shorten(struct efi_device_path *dp); 821struct efi_device_path *efi_dp_next(const struct efi_device_path *dp); 822int efi_dp_match(const struct efi_device_path *a, 823 const struct efi_device_path *b); 824efi_handle_t efi_dp_find_obj(struct efi_device_path *dp, 825 const efi_guid_t *guid, 826 struct efi_device_path **rem); 827/* get size of the first device path instance excluding end node */ 828efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp); 829/* size of multi-instance device path excluding end node */ 830efi_uintn_t efi_dp_size(const struct efi_device_path *dp); 831struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp); 832struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp, 833 const struct efi_device_path *node); 834/* Create a device path node of given type, sub-type, length */ 835struct efi_device_path *efi_dp_create_device_node(const u8 type, 836 const u8 sub_type, 837 const u16 length); 838/* Append device path instance */ 839struct efi_device_path *efi_dp_append_instance( 840 const struct efi_device_path *dp, 841 const struct efi_device_path *dpi); 842/* Get next device path instance */ 843struct efi_device_path *efi_dp_get_next_instance(struct efi_device_path **dp, 844 efi_uintn_t *size); 845/* Check if a device path contains muliple instances */ 846bool efi_dp_is_multi_instance(const struct efi_device_path *dp); 847 848struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part); 849/* Create a device node for a block device partition. */ 850struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part); 851struct efi_device_path *efi_dp_from_file(const struct efi_device_path *dp, 852 const char *path); 853struct efi_device_path *efi_dp_from_eth(void); 854struct efi_device_path *efi_dp_from_mem(uint32_t mem_type, 855 uint64_t start_address, 856 uint64_t end_address); 857/* Determine the last device path node that is not the end node. */ 858const struct efi_device_path *efi_dp_last_node( 859 const struct efi_device_path *dp); 860efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path, 861 struct efi_device_path **device_path, 862 struct efi_device_path **file_path); 863struct efi_device_path *efi_dp_from_uart(void); 864efi_status_t efi_dp_from_name(const char *dev, const char *devnr, 865 const char *path, 866 struct efi_device_path **device, 867 struct efi_device_path **file); 868ssize_t efi_dp_check_length(const struct efi_device_path *dp, 869 const size_t maxlen); 870 871#define EFI_DP_TYPE(_dp, _type, _subtype) \ 872 (((_dp)->type == DEVICE_PATH_TYPE_##_type) && \ 873 ((_dp)->sub_type == DEVICE_PATH_SUB_TYPE_##_subtype)) 874 875/* template END node: */ 876extern const struct efi_device_path END; 877 878/* Indicate supported runtime services */ 879efi_status_t efi_init_runtime_supported(void); 880 881/* Update CRC32 in table header */ 882void __efi_runtime efi_update_table_header_crc32(struct efi_table_hdr *table); 883 884/* Boards may provide the functions below to implement RTS functionality */ 885 886void __efi_runtime EFIAPI efi_reset_system( 887 enum efi_reset_type reset_type, 888 efi_status_t reset_status, 889 unsigned long data_size, void *reset_data); 890 891/* Architecture specific initialization of the EFI subsystem */ 892efi_status_t efi_reset_system_init(void); 893 894efi_status_t __efi_runtime EFIAPI efi_get_time( 895 struct efi_time *time, 896 struct efi_time_cap *capabilities); 897 898efi_status_t __efi_runtime EFIAPI efi_set_time(struct efi_time *time); 899 900/* 901 * Entry point for the tests of the EFI API. 902 * It is called by 'bootefi selftest' 903 */ 904efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle, 905 struct efi_system_table *systab); 906 907efi_status_t EFIAPI efi_get_variable(u16 *variable_name, 908 const efi_guid_t *vendor, u32 *attributes, 909 efi_uintn_t *data_size, void *data); 910efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size, 911 u16 *variable_name, 912 efi_guid_t *vendor); 913efi_status_t EFIAPI efi_set_variable(u16 *variable_name, 914 const efi_guid_t *vendor, u32 attributes, 915 efi_uintn_t data_size, const void *data); 916 917efi_status_t EFIAPI efi_query_variable_info( 918 u32 attributes, u64 *maximum_variable_storage_size, 919 u64 *remaining_variable_storage_size, 920 u64 *maximum_variable_size); 921 922void *efi_get_var(const u16 *name, const efi_guid_t *vendor, efi_uintn_t *size); 923 924/* 925 * See section 3.1.3 in the v2.7 UEFI spec for more details on 926 * the layout of EFI_LOAD_OPTION. In short it is: 927 * 928 * typedef struct _EFI_LOAD_OPTION { 929 * UINT32 Attributes; 930 * UINT16 FilePathListLength; 931 * // CHAR16 Description[]; <-- variable length, NULL terminated 932 * // EFI_DEVICE_PATH_PROTOCOL FilePathList[]; 933 * <-- FilePathListLength bytes 934 * // UINT8 OptionalData[]; 935 * } EFI_LOAD_OPTION; 936 */ 937struct efi_load_option { 938 u32 attributes; 939 u16 file_path_length; 940 u16 *label; 941 struct efi_device_path *file_path; 942 const u8 *optional_data; 943}; 944 945struct efi_device_path *efi_dp_from_lo(struct efi_load_option *lo, 946 const efi_guid_t *guid); 947struct efi_device_path *efi_dp_concat(const struct efi_device_path *dp1, 948 const struct efi_device_path *dp2, 949 bool split_end_node); 950struct efi_device_path *search_gpt_dp_node(struct efi_device_path *device_path); 951efi_status_t efi_deserialize_load_option(struct efi_load_option *lo, u8 *data, 952 efi_uintn_t *size); 953unsigned long efi_serialize_load_option(struct efi_load_option *lo, u8 **data); 954efi_status_t efi_set_load_options(efi_handle_t handle, 955 efi_uintn_t load_options_size, 956 void *load_options); 957efi_status_t efi_bootmgr_load(efi_handle_t *handle, void **load_options); 958 959/** 960 * struct efi_image_regions - A list of memory regions 961 * 962 * @max: Maximum number of regions 963 * @num: Number of regions 964 * @reg: array of regions 965 */ 966struct efi_image_regions { 967 int max; 968 int num; 969 struct image_region reg[]; 970}; 971 972/** 973 * struct efi_sig_data - A decoded data of struct efi_signature_data 974 * 975 * This structure represents an internal form of signature in 976 * signature database. A listed list may represent a signature list. 977 * 978 * @next: Pointer to next entry 979 * @owner: Signature owner 980 * @data: Pointer to signature data 981 * @size: Size of signature data 982 */ 983struct efi_sig_data { 984 struct efi_sig_data *next; 985 efi_guid_t owner; 986 void *data; 987 size_t size; 988}; 989 990/** 991 * struct efi_signature_store - A decoded data of signature database 992 * 993 * This structure represents an internal form of signature database. 994 * 995 * @next: Pointer to next entry 996 * @sig_type: Signature type 997 * @sig_data_list: Pointer to signature list 998 */ 999struct efi_signature_store { 1000 struct efi_signature_store *next; 1001 efi_guid_t sig_type; 1002 struct efi_sig_data *sig_data_list; 1003}; 1004 1005struct x509_certificate; 1006struct pkcs7_message; 1007 1008/** 1009 * struct eficonfig_media_boot_option - boot option for (removable) media device 1010 * 1011 * This structure is used to enumerate possible boot option 1012 * 1013 * @lo: Serialized load option data 1014 * @size: Size of serialized load option data 1015 * @exist: Flag to indicate the load option already exists 1016 * in Non-volatile load option 1017 */ 1018struct eficonfig_media_boot_option { 1019 void *lo; 1020 efi_uintn_t size; 1021 bool exist; 1022}; 1023 1024bool efi_hash_regions(struct image_region *regs, int count, 1025 void **hash, const char *hash_algo, int *len); 1026bool efi_signature_lookup_digest(struct efi_image_regions *regs, 1027 struct efi_signature_store *db, 1028 bool dbx); 1029bool efi_signature_verify(struct efi_image_regions *regs, 1030 struct pkcs7_message *msg, 1031 struct efi_signature_store *db, 1032 struct efi_signature_store *dbx); 1033static inline bool efi_signature_verify_one(struct efi_image_regions *regs, 1034 struct pkcs7_message *msg, 1035 struct efi_signature_store *db) 1036{ 1037 return efi_signature_verify(regs, msg, db, NULL); 1038} 1039bool efi_signature_check_signers(struct pkcs7_message *msg, 1040 struct efi_signature_store *dbx); 1041 1042efi_status_t efi_image_region_add(struct efi_image_regions *regs, 1043 const void *start, const void *end, 1044 int nocheck); 1045 1046void efi_sigstore_free(struct efi_signature_store *sigstore); 1047struct efi_signature_store *efi_build_signature_store(void *sig_list, 1048 efi_uintn_t size); 1049struct efi_signature_store *efi_sigstore_parse_sigdb(u16 *name); 1050 1051bool efi_secure_boot_enabled(void); 1052 1053bool efi_capsule_auth_enabled(void); 1054 1055void *efi_prepare_aligned_image(void *efi, u64 *efi_size); 1056 1057bool efi_image_parse(void *efi, size_t len, struct efi_image_regions **regp, 1058 WIN_CERTIFICATE **auth, size_t *auth_len); 1059 1060struct pkcs7_message *efi_parse_pkcs7_header(const void *buf, 1061 size_t buflen, 1062 u8 **tmpbuf); 1063 1064/* runtime implementation of memcpy() */ 1065void efi_memcpy_runtime(void *dest, const void *src, size_t n); 1066 1067/* commonly used helper functions */ 1068u16 *efi_create_indexed_name(u16 *buffer, size_t buffer_size, const char *name, 1069 unsigned int index); 1070efi_string_t efi_convert_string(const char *str); 1071 1072extern const struct efi_firmware_management_protocol efi_fmp_fit; 1073extern const struct efi_firmware_management_protocol efi_fmp_raw; 1074 1075/* Capsule update */ 1076efi_status_t EFIAPI efi_update_capsule( 1077 struct efi_capsule_header **capsule_header_array, 1078 efi_uintn_t capsule_count, 1079 u64 scatter_gather_list); 1080efi_status_t EFIAPI efi_query_capsule_caps( 1081 struct efi_capsule_header **capsule_header_array, 1082 efi_uintn_t capsule_count, 1083 u64 *maximum_capsule_size, 1084 u32 *reset_type); 1085 1086efi_status_t efi_capsule_authenticate(const void *capsule, 1087 efi_uintn_t capsule_size, 1088 void **image, efi_uintn_t *image_size); 1089 1090#define EFI_CAPSULE_DIR u"\\EFI\\UpdateCapsule\\" 1091 1092/** 1093 * struct efi_fw_image - Information on firmware images updatable through 1094 * capsule update 1095 * 1096 * This structure gives information about the firmware images on the platform 1097 * which can be updated through the capsule update mechanism 1098 * 1099 * @image_type_id: Image GUID. Same value is to be used in the capsule 1100 * @fw_name: Name of the firmware image 1101 * @image_index: Image Index, same as value passed to SetImage FMP 1102 * function 1103 */ 1104struct efi_fw_image { 1105 efi_guid_t image_type_id; 1106 u16 *fw_name; 1107 u8 image_index; 1108}; 1109 1110/** 1111 * struct efi_capsule_update_info - Information needed for capsule updates 1112 * 1113 * This structure provides information needed for performing firmware 1114 * updates. The structure needs to be initialised per platform, for all 1115 * platforms which enable capsule updates 1116 * 1117 * @dfu_string: String used to populate dfu_alt_info 1118 * @num_images: The number of images array entries 1119 * @images: Pointer to an array of updatable images 1120 */ 1121struct efi_capsule_update_info { 1122 const char *dfu_string; 1123 int num_images; 1124 struct efi_fw_image *images; 1125}; 1126 1127extern struct efi_capsule_update_info update_info; 1128 1129/** 1130 * Install the ESRT system table. 1131 * 1132 * Return: status code 1133 */ 1134efi_status_t efi_esrt_register(void); 1135 1136/** 1137 * efi_ecpt_register() - Install the ECPT system table. 1138 * 1139 * Return: status code 1140 */ 1141efi_status_t efi_ecpt_register(void); 1142 1143/** 1144 * efi_esrt_populate() - Populates the ESRT entries from the FMP instances 1145 * present in the system. 1146 * If an ESRT already exists, the old ESRT is replaced in the system table. 1147 * The memory of the old ESRT is deallocated. 1148 * 1149 * Return: 1150 * - EFI_SUCCESS if the ESRT is correctly created 1151 * - error code otherwise. 1152 */ 1153efi_status_t efi_esrt_populate(void); 1154efi_status_t efi_load_capsule_drivers(void); 1155 1156efi_status_t platform_get_eventlog(struct udevice *dev, u64 *addr, u32 *sz); 1157 1158efi_status_t efi_locate_handle_buffer_int(enum efi_locate_search_type search_type, 1159 const efi_guid_t *protocol, void *search_key, 1160 efi_uintn_t *no_handles, efi_handle_t **buffer); 1161 1162efi_status_t efi_open_volume_int(struct efi_simple_file_system_protocol *this, 1163 struct efi_file_handle **root); 1164efi_status_t efi_file_open_int(struct efi_file_handle *this, 1165 struct efi_file_handle **new_handle, 1166 u16 *file_name, u64 open_mode, 1167 u64 attributes); 1168efi_status_t efi_file_close_int(struct efi_file_handle *file); 1169efi_status_t efi_file_read_int(struct efi_file_handle *this, 1170 efi_uintn_t *buffer_size, void *buffer); 1171efi_status_t efi_file_setpos_int(struct efi_file_handle *file, u64 pos); 1172 1173typedef efi_status_t (*efi_console_filter_func)(struct efi_input_key *key); 1174efi_status_t efi_console_get_u16_string 1175 (struct efi_simple_text_input_protocol *cin, 1176 u16 *buf, efi_uintn_t count, efi_console_filter_func filer_func, 1177 int row, int col); 1178 1179efi_status_t efi_disk_get_device_name(const efi_handle_t handle, char *buf, int size); 1180 1181/** 1182 * efi_add_known_memory() - add memory banks to EFI memory map 1183 * 1184 * This weak function may be overridden for specific architectures. 1185 */ 1186void efi_add_known_memory(void); 1187 1188#endif /* _EFI_LOADER_H */ 1189