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 <common.h> 12 #include <part_efi.h> 13 #include <efi_api.h> 14 15 /* No need for efi loader support in SPL */ 16 #if CONFIG_IS_ENABLED(EFI_LOADER) 17 18 #include <linux/list.h> 19 20 /* Maximum number of configuration tables */ 21 #define EFI_MAX_CONFIGURATION_TABLES 16 22 23 /* GUID used by the root node */ 24 #define U_BOOT_GUID \ 25 EFI_GUID(0xe61d73b9, 0xa384, 0x4acc, \ 26 0xae, 0xab, 0x82, 0xe8, 0x28, 0xf3, 0x62, 0x8b) 27 28 int __efi_entry_check(void); 29 int __efi_exit_check(void); 30 const char *__efi_nesting(void); 31 const char *__efi_nesting_inc(void); 32 const char *__efi_nesting_dec(void); 33 34 /* 35 * Enter the u-boot world from UEFI: 36 */ 37 #define EFI_ENTRY(format, ...) do { \ 38 assert(__efi_entry_check()); \ 39 debug("%sEFI: Entry %s(" format ")\n", __efi_nesting_inc(), \ 40 __func__, ##__VA_ARGS__); \ 41 } while(0) 42 43 /* 44 * Exit the u-boot world back to UEFI: 45 */ 46 #define EFI_EXIT(ret) ({ \ 47 typeof(ret) _r = ret; \ 48 debug("%sEFI: Exit: %s: %u\n", __efi_nesting_dec(), \ 49 __func__, (u32)((uintptr_t) _r & ~EFI_ERROR_MASK)); \ 50 assert(__efi_exit_check()); \ 51 _r; \ 52 }) 53 54 /* 55 * Call non-void UEFI function from u-boot and retrieve return value: 56 */ 57 #define EFI_CALL(exp) ({ \ 58 debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ 59 assert(__efi_exit_check()); \ 60 typeof(exp) _r = exp; \ 61 assert(__efi_entry_check()); \ 62 debug("%sEFI: %lu returned by %s\n", __efi_nesting_dec(), \ 63 (unsigned long)((uintptr_t)_r & ~EFI_ERROR_MASK), #exp); \ 64 _r; \ 65 }) 66 67 /* 68 * Call void UEFI function from u-boot: 69 */ 70 #define EFI_CALL_VOID(exp) do { \ 71 debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ 72 assert(__efi_exit_check()); \ 73 exp; \ 74 assert(__efi_entry_check()); \ 75 debug("%sEFI: Return From: %s\n", __efi_nesting_dec(), #exp); \ 76 } while(0) 77 78 /* 79 * Write an indented message with EFI prefix 80 */ 81 #define EFI_PRINT(format, ...) ({ \ 82 debug("%sEFI: " format, __efi_nesting(), \ 83 ##__VA_ARGS__); \ 84 }) 85 86 #ifdef CONFIG_SYS_CACHELINE_SIZE 87 #define EFI_CACHELINE_SIZE CONFIG_SYS_CACHELINE_SIZE 88 #else 89 /* Just use the greatest cache flush alignment requirement I'm aware of */ 90 #define EFI_CACHELINE_SIZE 128 91 #endif 92 93 /* Key identifying current memory map */ 94 extern efi_uintn_t efi_memory_map_key; 95 96 extern struct efi_runtime_services efi_runtime_services; 97 extern struct efi_system_table systab; 98 99 extern struct efi_simple_text_output_protocol efi_con_out; 100 extern struct efi_simple_text_input_protocol efi_con_in; 101 extern struct efi_console_control_protocol efi_console_control; 102 extern const struct efi_device_path_to_text_protocol efi_device_path_to_text; 103 /* implementation of the EFI_DEVICE_PATH_UTILITIES_PROTOCOL */ 104 extern const struct efi_device_path_utilities_protocol 105 efi_device_path_utilities; 106 /* Implementation of the EFI_UNICODE_COLLATION_PROTOCOL */ 107 extern const struct efi_unicode_collation_protocol 108 efi_unicode_collation_protocol; 109 110 uint16_t *efi_dp_str(struct efi_device_path *dp); 111 112 /* GUID of the U-Boot root node */ 113 extern const efi_guid_t efi_u_boot_guid; 114 /* GUID of the EFI_BLOCK_IO_PROTOCOL */ 115 extern const efi_guid_t efi_block_io_guid; 116 extern const efi_guid_t efi_global_variable_guid; 117 extern const efi_guid_t efi_guid_console_control; 118 extern const efi_guid_t efi_guid_device_path; 119 /* GUID of the EFI_DRIVER_BINDING_PROTOCOL */ 120 extern const efi_guid_t efi_guid_driver_binding_protocol; 121 /* event group ExitBootServices() invoked */ 122 extern const efi_guid_t efi_guid_event_group_exit_boot_services; 123 /* event group SetVirtualAddressMap() invoked */ 124 extern const efi_guid_t efi_guid_event_group_virtual_address_change; 125 /* event group memory map changed */ 126 extern const efi_guid_t efi_guid_event_group_memory_map_change; 127 /* event group boot manager about to boot */ 128 extern const efi_guid_t efi_guid_event_group_ready_to_boot; 129 /* event group ResetSystem() invoked (before ExitBootServices) */ 130 extern const efi_guid_t efi_guid_event_group_reset_system; 131 /* GUID of the device tree table */ 132 extern const efi_guid_t efi_guid_fdt; 133 extern const efi_guid_t efi_guid_loaded_image; 134 extern const efi_guid_t efi_guid_device_path_to_text_protocol; 135 extern const efi_guid_t efi_simple_file_system_protocol_guid; 136 extern const efi_guid_t efi_file_info_guid; 137 /* GUID for file system information */ 138 extern const efi_guid_t efi_file_system_info_guid; 139 extern const efi_guid_t efi_guid_device_path_utilities_protocol; 140 /* GUID of the Unicode collation protocol */ 141 extern const efi_guid_t efi_guid_unicode_collation_protocol; 142 143 extern unsigned int __efi_runtime_start, __efi_runtime_stop; 144 extern unsigned int __efi_runtime_rel_start, __efi_runtime_rel_stop; 145 146 /* 147 * When a protocol is opened a open protocol info entry is created. 148 * These are maintained in a list. 149 */ 150 struct efi_open_protocol_info_item { 151 /* Link to the list of open protocol info entries of a protocol */ 152 struct list_head link; 153 struct efi_open_protocol_info_entry info; 154 }; 155 156 /* 157 * When the UEFI payload wants to open a protocol on an object to get its 158 * interface (usually a struct with callback functions), this struct maps the 159 * protocol GUID to the respective protocol interface 160 */ 161 struct efi_handler { 162 /* Link to the list of protocols of a handle */ 163 struct list_head link; 164 const efi_guid_t *guid; 165 void *protocol_interface; 166 /* Link to the list of open protocol info items */ 167 struct list_head open_infos; 168 }; 169 170 /** 171 * struct efi_object - dereferenced EFI handle 172 * 173 * @link: pointers to put the handle into a linked list 174 * @protocols: linked list with the protocol interfaces installed on this 175 * handle 176 * 177 * UEFI offers a flexible and expandable object model. The objects in the UEFI 178 * API are devices, drivers, and loaded images. struct efi_object is our storage 179 * structure for these objects. 180 * 181 * When including this structure into a larger structure always put it first so 182 * that when deleting a handle the whole encompassing structure can be freed. 183 * 184 * A pointer to this structure is referred to as a handle. Typedef efi_handle_t 185 * has been created for such pointers. 186 */ 187 struct efi_object { 188 /* Every UEFI object is part of a global object list */ 189 struct list_head link; 190 /* The list of protocols */ 191 struct list_head protocols; 192 }; 193 194 /** 195 * struct efi_loaded_image_obj - handle of a loaded image 196 * 197 * @header: EFI object header 198 * @reloc_base: base address for the relocated image 199 * @reloc_size: size of the relocated image 200 * @exit_jmp: long jump buffer for returning form started image 201 * @entry: entry address of the relocated image 202 */ 203 struct efi_loaded_image_obj { 204 struct efi_object header; 205 void *reloc_base; 206 aligned_u64 reloc_size; 207 efi_status_t exit_status; 208 struct jmp_buf_data exit_jmp; 209 EFIAPI efi_status_t (*entry)(efi_handle_t image_handle, 210 struct efi_system_table *st); 211 }; 212 213 /** 214 * struct efi_event 215 * 216 * @link: Link to list of all events 217 * @type: Type of event, see efi_create_event 218 * @notify_tpl: Task priority level of notifications 219 * @nofify_function: Function to call when the event is triggered 220 * @notify_context: Data to be passed to the notify function 221 * @group: Event group 222 * @trigger_time: Period of the timer 223 * @trigger_next: Next time to trigger the timer 224 * @trigger_type: Type of timer, see efi_set_timer 225 * @is_queued: The notification function is queued 226 * @is_signaled: The event occurred. The event is in the signaled state. 227 */ 228 struct efi_event { 229 struct list_head link; 230 uint32_t type; 231 efi_uintn_t notify_tpl; 232 void (EFIAPI *notify_function)(struct efi_event *event, void *context); 233 void *notify_context; 234 const efi_guid_t *group; 235 u64 trigger_next; 236 u64 trigger_time; 237 enum efi_timer_delay trigger_type; 238 bool is_queued; 239 bool is_signaled; 240 }; 241 242 /* This list contains all UEFI objects we know of */ 243 extern struct list_head efi_obj_list; 244 /* List of all events */ 245 extern struct list_head efi_events; 246 247 /* Initialize efi execution environment */ 248 efi_status_t efi_init_obj_list(void); 249 /* Called by bootefi to initialize root node */ 250 efi_status_t efi_root_node_register(void); 251 /* Called by bootefi to initialize runtime */ 252 efi_status_t efi_initialize_system_table(void); 253 /* Called by bootefi to make console interface available */ 254 efi_status_t efi_console_register(void); 255 /* Called by bootefi to make all disk storage accessible as EFI objects */ 256 efi_status_t efi_disk_register(void); 257 /* Create handles and protocols for the partitions of a block device */ 258 int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc, 259 const char *if_typename, int diskid, 260 const char *pdevname); 261 /* Called by bootefi to make GOP (graphical) interface available */ 262 efi_status_t efi_gop_register(void); 263 /* Called by bootefi to make the network interface available */ 264 efi_status_t efi_net_register(void); 265 /* Called by bootefi to make the watchdog available */ 266 efi_status_t efi_watchdog_register(void); 267 /* Called by bootefi to make SMBIOS tables available */ 268 /** 269 * efi_acpi_register() - write out ACPI tables 270 * 271 * Called by bootefi to make ACPI tables available 272 * 273 * @return 0 if OK, -ENOMEM if no memory is available for the tables 274 */ 275 efi_status_t efi_acpi_register(void); 276 /** 277 * efi_smbios_register() - write out SMBIOS tables 278 * 279 * Called by bootefi to make SMBIOS tables available 280 * 281 * @return 0 if OK, -ENOMEM if no memory is available for the tables 282 */ 283 efi_status_t efi_smbios_register(void); 284 285 struct efi_simple_file_system_protocol * 286 efi_fs_from_path(struct efi_device_path *fp); 287 288 /* Called by networking code to memorize the dhcp ack package */ 289 void efi_net_set_dhcp_ack(void *pkt, int len); 290 /* Called by efi_set_watchdog_timer to reset the timer */ 291 efi_status_t efi_set_watchdog(unsigned long timeout); 292 293 /* Called from places to check whether a timer expired */ 294 void efi_timer_check(void); 295 /* PE loader implementation */ 296 void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, 297 struct efi_loaded_image *loaded_image_info); 298 /* Called once to store the pristine gd pointer */ 299 void efi_save_gd(void); 300 /* Special case handler for error/abort that just tries to dtrt to get 301 * back to u-boot world */ 302 void efi_restore_gd(void); 303 /* Call this to relocate the runtime section to an address space */ 304 void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map); 305 /* Call this to set the current device name */ 306 void efi_set_bootdev(const char *dev, const char *devnr, const char *path); 307 /* Add a new object to the object list. */ 308 void efi_add_handle(efi_handle_t obj); 309 /* Create handle */ 310 efi_status_t efi_create_handle(efi_handle_t *handle); 311 /* Delete handle */ 312 void efi_delete_handle(efi_handle_t obj); 313 /* Call this to validate a handle and find the EFI object for it */ 314 struct efi_object *efi_search_obj(const efi_handle_t handle); 315 /* Find a protocol on a handle */ 316 efi_status_t efi_search_protocol(const efi_handle_t handle, 317 const efi_guid_t *protocol_guid, 318 struct efi_handler **handler); 319 /* Install new protocol on a handle */ 320 efi_status_t efi_add_protocol(const efi_handle_t handle, 321 const efi_guid_t *protocol, 322 void *protocol_interface); 323 /* Delete protocol from a handle */ 324 efi_status_t efi_remove_protocol(const efi_handle_t handle, 325 const efi_guid_t *protocol, 326 void *protocol_interface); 327 /* Delete all protocols from a handle */ 328 efi_status_t efi_remove_all_protocols(const efi_handle_t handle); 329 /* Call this to create an event */ 330 efi_status_t efi_create_event(uint32_t type, efi_uintn_t notify_tpl, 331 void (EFIAPI *notify_function) ( 332 struct efi_event *event, 333 void *context), 334 void *notify_context, efi_guid_t *group, 335 struct efi_event **event); 336 /* Call this to set a timer */ 337 efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type, 338 uint64_t trigger_time); 339 /* Call this to signal an event */ 340 void efi_signal_event(struct efi_event *event, bool check_tpl); 341 342 /* open file system: */ 343 struct efi_simple_file_system_protocol *efi_simple_file_system( 344 struct blk_desc *desc, int part, struct efi_device_path *dp); 345 346 /* open file from device-path: */ 347 struct efi_file_handle *efi_file_from_path(struct efi_device_path *fp); 348 349 /** 350 * efi_size_in_pages() - convert size in bytes to size in pages 351 * 352 * This macro returns the number of EFI memory pages required to hold 'size' 353 * bytes. 354 * 355 * @size: size in bytes 356 * Return: size in pages 357 */ 358 #define efi_size_in_pages(size) ((size + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT) 359 /* Generic EFI memory allocator, call this to get memory */ 360 void *efi_alloc(uint64_t len, int memory_type); 361 /* More specific EFI memory allocator, called by EFI payloads */ 362 efi_status_t efi_allocate_pages(int type, int memory_type, efi_uintn_t pages, 363 uint64_t *memory); 364 /* EFI memory free function. */ 365 efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages); 366 /* EFI memory allocator for small allocations */ 367 efi_status_t efi_allocate_pool(int pool_type, efi_uintn_t size, 368 void **buffer); 369 /* EFI pool memory free function. */ 370 efi_status_t efi_free_pool(void *buffer); 371 /* Returns the EFI memory map */ 372 efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size, 373 struct efi_mem_desc *memory_map, 374 efi_uintn_t *map_key, 375 efi_uintn_t *descriptor_size, 376 uint32_t *descriptor_version); 377 /* Adds a range into the EFI memory map */ 378 uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type, 379 bool overlap_only_ram); 380 /* Called by board init to initialize the EFI drivers */ 381 efi_status_t efi_driver_init(void); 382 /* Called by board init to initialize the EFI memory map */ 383 int efi_memory_init(void); 384 /* Adds new or overrides configuration table entry to the system table */ 385 efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table); 386 /* Sets up a loaded image */ 387 efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path, 388 struct efi_device_path *file_path, 389 struct efi_loaded_image_obj **handle_ptr, 390 struct efi_loaded_image **info_ptr); 391 efi_status_t efi_load_image_from_path(struct efi_device_path *file_path, 392 void **buffer); 393 /* Print information about all loaded images */ 394 void efi_print_image_infos(void *pc); 395 396 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER 397 extern void *efi_bounce_buffer; 398 #define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024) 399 #endif 400 401 402 struct efi_device_path *efi_dp_next(const struct efi_device_path *dp); 403 int efi_dp_match(const struct efi_device_path *a, 404 const struct efi_device_path *b); 405 struct efi_object *efi_dp_find_obj(struct efi_device_path *dp, 406 struct efi_device_path **rem); 407 /* get size of the first device path instance excluding end node */ 408 efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp); 409 /* size of multi-instance device path excluding end node */ 410 efi_uintn_t efi_dp_size(const struct efi_device_path *dp); 411 struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp); 412 struct efi_device_path *efi_dp_append(const struct efi_device_path *dp1, 413 const struct efi_device_path *dp2); 414 struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp, 415 const struct efi_device_path *node); 416 /* Create a device path node of given type, sub-type, length */ 417 struct efi_device_path *efi_dp_create_device_node(const u8 type, 418 const u8 sub_type, 419 const u16 length); 420 /* Append device path instance */ 421 struct efi_device_path *efi_dp_append_instance( 422 const struct efi_device_path *dp, 423 const struct efi_device_path *dpi); 424 /* Get next device path instance */ 425 struct efi_device_path *efi_dp_get_next_instance(struct efi_device_path **dp, 426 efi_uintn_t *size); 427 /* Check if a device path contains muliple instances */ 428 bool efi_dp_is_multi_instance(const struct efi_device_path *dp); 429 430 struct efi_device_path *efi_dp_from_dev(struct udevice *dev); 431 struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part); 432 /* Create a device node for a block device partition. */ 433 struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part); 434 struct efi_device_path *efi_dp_from_file(struct blk_desc *desc, int part, 435 const char *path); 436 struct efi_device_path *efi_dp_from_eth(void); 437 struct efi_device_path *efi_dp_from_mem(uint32_t mem_type, 438 uint64_t start_address, 439 uint64_t end_address); 440 /* Determine the last device path node that is not the end node. */ 441 const struct efi_device_path *efi_dp_last_node( 442 const struct efi_device_path *dp); 443 efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path, 444 struct efi_device_path **device_path, 445 struct efi_device_path **file_path); 446 efi_status_t efi_dp_from_name(const char *dev, const char *devnr, 447 const char *path, 448 struct efi_device_path **device, 449 struct efi_device_path **file); 450 451 #define EFI_DP_TYPE(_dp, _type, _subtype) \ 452 (((_dp)->type == DEVICE_PATH_TYPE_##_type) && \ 453 ((_dp)->sub_type == DEVICE_PATH_SUB_TYPE_##_subtype)) 454 455 /** 456 * ascii2unicode() - convert ASCII string to UTF-16 string 457 * 458 * A zero terminated ASCII string is converted to a zero terminated UTF-16 459 * string. The output buffer must be preassigned. 460 * 461 * @unicode: preassigned output buffer for UTF-16 string 462 * @ascii: ASCII string to be converted 463 */ 464 static inline void ascii2unicode(u16 *unicode, const char *ascii) 465 { 466 while (*ascii) 467 *(unicode++) = *(ascii++); 468 *unicode = 0; 469 } 470 471 static inline int guidcmp(const efi_guid_t *g1, const efi_guid_t *g2) 472 { 473 return memcmp(g1, g2, sizeof(efi_guid_t)); 474 } 475 476 /* 477 * Use these to indicate that your code / data should go into the EFI runtime 478 * section and thus still be available when the OS is running 479 */ 480 #define __efi_runtime_data __attribute__ ((section (".data.efi_runtime"))) 481 #define __efi_runtime __attribute__ ((section (".text.efi_runtime"))) 482 483 /* Update CRC32 in table header */ 484 void __efi_runtime efi_update_table_header_crc32(struct efi_table_hdr *table); 485 486 /* Call this with mmio_ptr as the _pointer_ to a pointer to an MMIO region 487 * to make it available at runtime */ 488 efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len); 489 490 /* Boards may provide the functions below to implement RTS functionality */ 491 492 void __efi_runtime EFIAPI efi_reset_system( 493 enum efi_reset_type reset_type, 494 efi_status_t reset_status, 495 unsigned long data_size, void *reset_data); 496 497 /* Architecture specific initialization of the EFI subsystem */ 498 efi_status_t efi_reset_system_init(void); 499 500 efi_status_t __efi_runtime EFIAPI efi_get_time( 501 struct efi_time *time, 502 struct efi_time_cap *capabilities); 503 504 #ifdef CONFIG_CMD_BOOTEFI_SELFTEST 505 /* 506 * Entry point for the tests of the EFI API. 507 * It is called by 'bootefi selftest' 508 */ 509 efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle, 510 struct efi_system_table *systab); 511 #endif 512 513 efi_status_t EFIAPI efi_get_variable(u16 *variable_name, 514 const efi_guid_t *vendor, u32 *attributes, 515 efi_uintn_t *data_size, void *data); 516 efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size, 517 u16 *variable_name, 518 const efi_guid_t *vendor); 519 efi_status_t EFIAPI efi_set_variable(u16 *variable_name, 520 const efi_guid_t *vendor, u32 attributes, 521 efi_uintn_t data_size, const void *data); 522 523 /* 524 * See section 3.1.3 in the v2.7 UEFI spec for more details on 525 * the layout of EFI_LOAD_OPTION. In short it is: 526 * 527 * typedef struct _EFI_LOAD_OPTION { 528 * UINT32 Attributes; 529 * UINT16 FilePathListLength; 530 * // CHAR16 Description[]; <-- variable length, NULL terminated 531 * // EFI_DEVICE_PATH_PROTOCOL FilePathList[]; 532 * <-- FilePathListLength bytes 533 * // UINT8 OptionalData[]; 534 * } EFI_LOAD_OPTION; 535 */ 536 struct efi_load_option { 537 u32 attributes; 538 u16 file_path_length; 539 u16 *label; 540 struct efi_device_path *file_path; 541 u8 *optional_data; 542 }; 543 544 void efi_deserialize_load_option(struct efi_load_option *lo, u8 *data); 545 unsigned long efi_serialize_load_option(struct efi_load_option *lo, u8 **data); 546 void *efi_bootmgr_load(struct efi_device_path **device_path, 547 struct efi_device_path **file_path); 548 549 #else /* CONFIG_IS_ENABLED(EFI_LOADER) */ 550 551 /* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */ 552 #define __efi_runtime_data 553 #define __efi_runtime 554 static inline efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len) 555 { 556 return EFI_SUCCESS; 557 } 558 559 /* No loader configured, stub out EFI_ENTRY */ 560 static inline void efi_restore_gd(void) { } 561 static inline void efi_set_bootdev(const char *dev, const char *devnr, 562 const char *path) { } 563 static inline void efi_net_set_dhcp_ack(void *pkt, int len) { } 564 static inline void efi_print_image_infos(void *pc) { } 565 566 #endif /* CONFIG_IS_ENABLED(EFI_LOADER) */ 567 568 #endif /* _EFI_LOADER_H */ 569