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 /* Called by bootefi to initialize root node */ 248 efi_status_t efi_root_node_register(void); 249 /* Called by bootefi to initialize runtime */ 250 efi_status_t efi_initialize_system_table(void); 251 /* Called by bootefi to make console interface available */ 252 efi_status_t efi_console_register(void); 253 /* Called by bootefi to make all disk storage accessible as EFI objects */ 254 efi_status_t efi_disk_register(void); 255 /* Create handles and protocols for the partitions of a block device */ 256 int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc, 257 const char *if_typename, int diskid, 258 const char *pdevname); 259 /* Called by bootefi to make GOP (graphical) interface available */ 260 efi_status_t efi_gop_register(void); 261 /* Called by bootefi to make the network interface available */ 262 efi_status_t efi_net_register(void); 263 /* Called by bootefi to make the watchdog available */ 264 efi_status_t efi_watchdog_register(void); 265 /* Called by bootefi to make SMBIOS tables available */ 266 /** 267 * efi_acpi_register() - write out ACPI tables 268 * 269 * Called by bootefi to make ACPI tables available 270 * 271 * @return 0 if OK, -ENOMEM if no memory is available for the tables 272 */ 273 efi_status_t efi_acpi_register(void); 274 /** 275 * efi_smbios_register() - write out SMBIOS tables 276 * 277 * Called by bootefi to make SMBIOS tables available 278 * 279 * @return 0 if OK, -ENOMEM if no memory is available for the tables 280 */ 281 efi_status_t efi_smbios_register(void); 282 283 struct efi_simple_file_system_protocol * 284 efi_fs_from_path(struct efi_device_path *fp); 285 286 /* Called by networking code to memorize the dhcp ack package */ 287 void efi_net_set_dhcp_ack(void *pkt, int len); 288 /* Called by efi_set_watchdog_timer to reset the timer */ 289 efi_status_t efi_set_watchdog(unsigned long timeout); 290 291 /* Called from places to check whether a timer expired */ 292 void efi_timer_check(void); 293 /* PE loader implementation */ 294 void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, 295 struct efi_loaded_image *loaded_image_info); 296 /* Called once to store the pristine gd pointer */ 297 void efi_save_gd(void); 298 /* Special case handler for error/abort that just tries to dtrt to get 299 * back to u-boot world */ 300 void efi_restore_gd(void); 301 /* Call this to relocate the runtime section to an address space */ 302 void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map); 303 /* Call this to set the current device name */ 304 void efi_set_bootdev(const char *dev, const char *devnr, const char *path); 305 /* Add a new object to the object list. */ 306 void efi_add_handle(efi_handle_t obj); 307 /* Create handle */ 308 efi_status_t efi_create_handle(efi_handle_t *handle); 309 /* Delete handle */ 310 void efi_delete_handle(efi_handle_t obj); 311 /* Call this to validate a handle and find the EFI object for it */ 312 struct efi_object *efi_search_obj(const efi_handle_t handle); 313 /* Find a protocol on a handle */ 314 efi_status_t efi_search_protocol(const efi_handle_t handle, 315 const efi_guid_t *protocol_guid, 316 struct efi_handler **handler); 317 /* Install new protocol on a handle */ 318 efi_status_t efi_add_protocol(const efi_handle_t handle, 319 const efi_guid_t *protocol, 320 void *protocol_interface); 321 /* Delete protocol from a handle */ 322 efi_status_t efi_remove_protocol(const efi_handle_t handle, 323 const efi_guid_t *protocol, 324 void *protocol_interface); 325 /* Delete all protocols from a handle */ 326 efi_status_t efi_remove_all_protocols(const efi_handle_t handle); 327 /* Call this to create an event */ 328 efi_status_t efi_create_event(uint32_t type, efi_uintn_t notify_tpl, 329 void (EFIAPI *notify_function) ( 330 struct efi_event *event, 331 void *context), 332 void *notify_context, efi_guid_t *group, 333 struct efi_event **event); 334 /* Call this to set a timer */ 335 efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type, 336 uint64_t trigger_time); 337 /* Call this to signal an event */ 338 void efi_signal_event(struct efi_event *event, bool check_tpl); 339 340 /* open file system: */ 341 struct efi_simple_file_system_protocol *efi_simple_file_system( 342 struct blk_desc *desc, int part, struct efi_device_path *dp); 343 344 /* open file from device-path: */ 345 struct efi_file_handle *efi_file_from_path(struct efi_device_path *fp); 346 347 /** 348 * efi_size_in_pages() - convert size in bytes to size in pages 349 * 350 * This macro returns the number of EFI memory pages required to hold 'size' 351 * bytes. 352 * 353 * @size: size in bytes 354 * Return: size in pages 355 */ 356 #define efi_size_in_pages(size) ((size + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT) 357 /* Generic EFI memory allocator, call this to get memory */ 358 void *efi_alloc(uint64_t len, int memory_type); 359 /* More specific EFI memory allocator, called by EFI payloads */ 360 efi_status_t efi_allocate_pages(int type, int memory_type, efi_uintn_t pages, 361 uint64_t *memory); 362 /* EFI memory free function. */ 363 efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages); 364 /* EFI memory allocator for small allocations */ 365 efi_status_t efi_allocate_pool(int pool_type, efi_uintn_t size, 366 void **buffer); 367 /* EFI pool memory free function. */ 368 efi_status_t efi_free_pool(void *buffer); 369 /* Returns the EFI memory map */ 370 efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size, 371 struct efi_mem_desc *memory_map, 372 efi_uintn_t *map_key, 373 efi_uintn_t *descriptor_size, 374 uint32_t *descriptor_version); 375 /* Adds a range into the EFI memory map */ 376 uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type, 377 bool overlap_only_ram); 378 /* Called by board init to initialize the EFI drivers */ 379 efi_status_t efi_driver_init(void); 380 /* Called by board init to initialize the EFI memory map */ 381 int efi_memory_init(void); 382 /* Adds new or overrides configuration table entry to the system table */ 383 efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table); 384 /* Sets up a loaded image */ 385 efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path, 386 struct efi_device_path *file_path, 387 struct efi_loaded_image_obj **handle_ptr, 388 struct efi_loaded_image **info_ptr); 389 efi_status_t efi_load_image_from_path(struct efi_device_path *file_path, 390 void **buffer); 391 /* Print information about all loaded images */ 392 void efi_print_image_infos(void *pc); 393 394 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER 395 extern void *efi_bounce_buffer; 396 #define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024) 397 #endif 398 399 400 struct efi_device_path *efi_dp_next(const struct efi_device_path *dp); 401 int efi_dp_match(const struct efi_device_path *a, 402 const struct efi_device_path *b); 403 struct efi_object *efi_dp_find_obj(struct efi_device_path *dp, 404 struct efi_device_path **rem); 405 /* get size of the first device path instance excluding end node */ 406 efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp); 407 /* size of multi-instance device path excluding end node */ 408 efi_uintn_t efi_dp_size(const struct efi_device_path *dp); 409 struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp); 410 struct efi_device_path *efi_dp_append(const struct efi_device_path *dp1, 411 const struct efi_device_path *dp2); 412 struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp, 413 const struct efi_device_path *node); 414 /* Create a device path node of given type, sub-type, length */ 415 struct efi_device_path *efi_dp_create_device_node(const u8 type, 416 const u8 sub_type, 417 const u16 length); 418 /* Append device path instance */ 419 struct efi_device_path *efi_dp_append_instance( 420 const struct efi_device_path *dp, 421 const struct efi_device_path *dpi); 422 /* Get next device path instance */ 423 struct efi_device_path *efi_dp_get_next_instance(struct efi_device_path **dp, 424 efi_uintn_t *size); 425 /* Check if a device path contains muliple instances */ 426 bool efi_dp_is_multi_instance(const struct efi_device_path *dp); 427 428 struct efi_device_path *efi_dp_from_dev(struct udevice *dev); 429 struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part); 430 /* Create a device node for a block device partition. */ 431 struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part); 432 struct efi_device_path *efi_dp_from_file(struct blk_desc *desc, int part, 433 const char *path); 434 struct efi_device_path *efi_dp_from_eth(void); 435 struct efi_device_path *efi_dp_from_mem(uint32_t mem_type, 436 uint64_t start_address, 437 uint64_t end_address); 438 /* Determine the last device path node that is not the end node. */ 439 const struct efi_device_path *efi_dp_last_node( 440 const struct efi_device_path *dp); 441 efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path, 442 struct efi_device_path **device_path, 443 struct efi_device_path **file_path); 444 efi_status_t efi_dp_from_name(const char *dev, const char *devnr, 445 const char *path, 446 struct efi_device_path **device, 447 struct efi_device_path **file); 448 449 #define EFI_DP_TYPE(_dp, _type, _subtype) \ 450 (((_dp)->type == DEVICE_PATH_TYPE_##_type) && \ 451 ((_dp)->sub_type == DEVICE_PATH_SUB_TYPE_##_subtype)) 452 453 /** 454 * ascii2unicode() - convert ASCII string to UTF-16 string 455 * 456 * A zero terminated ASCII string is converted to a zero terminated UTF-16 457 * string. The output buffer must be preassigned. 458 * 459 * @unicode: preassigned output buffer for UTF-16 string 460 * @ascii: ASCII string to be converted 461 */ 462 static inline void ascii2unicode(u16 *unicode, const char *ascii) 463 { 464 while (*ascii) 465 *(unicode++) = *(ascii++); 466 *unicode = 0; 467 } 468 469 static inline int guidcmp(const efi_guid_t *g1, const efi_guid_t *g2) 470 { 471 return memcmp(g1, g2, sizeof(efi_guid_t)); 472 } 473 474 /* 475 * Use these to indicate that your code / data should go into the EFI runtime 476 * section and thus still be available when the OS is running 477 */ 478 #define __efi_runtime_data __attribute__ ((section (".data.efi_runtime"))) 479 #define __efi_runtime __attribute__ ((section (".text.efi_runtime"))) 480 481 /* Update CRC32 in table header */ 482 void __efi_runtime efi_update_table_header_crc32(struct efi_table_hdr *table); 483 484 /* Call this with mmio_ptr as the _pointer_ to a pointer to an MMIO region 485 * to make it available at runtime */ 486 efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len); 487 488 /* Boards may provide the functions below to implement RTS functionality */ 489 490 void __efi_runtime EFIAPI efi_reset_system( 491 enum efi_reset_type reset_type, 492 efi_status_t reset_status, 493 unsigned long data_size, void *reset_data); 494 495 /* Architecture specific initialization of the EFI subsystem */ 496 efi_status_t efi_reset_system_init(void); 497 498 efi_status_t __efi_runtime EFIAPI efi_get_time( 499 struct efi_time *time, 500 struct efi_time_cap *capabilities); 501 502 #ifdef CONFIG_CMD_BOOTEFI_SELFTEST 503 /* 504 * Entry point for the tests of the EFI API. 505 * It is called by 'bootefi selftest' 506 */ 507 efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle, 508 struct efi_system_table *systab); 509 #endif 510 511 efi_status_t EFIAPI efi_get_variable(u16 *variable_name, efi_guid_t *vendor, 512 u32 *attributes, efi_uintn_t *data_size, 513 void *data); 514 efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size, 515 u16 *variable_name, 516 efi_guid_t *vendor); 517 efi_status_t EFIAPI efi_set_variable(u16 *variable_name, efi_guid_t *vendor, 518 u32 attributes, efi_uintn_t data_size, 519 void *data); 520 521 /* 522 * See section 3.1.3 in the v2.7 UEFI spec for more details on 523 * the layout of EFI_LOAD_OPTION. In short it is: 524 * 525 * typedef struct _EFI_LOAD_OPTION { 526 * UINT32 Attributes; 527 * UINT16 FilePathListLength; 528 * // CHAR16 Description[]; <-- variable length, NULL terminated 529 * // EFI_DEVICE_PATH_PROTOCOL FilePathList[]; 530 * <-- FilePathListLength bytes 531 * // UINT8 OptionalData[]; 532 * } EFI_LOAD_OPTION; 533 */ 534 struct efi_load_option { 535 u32 attributes; 536 u16 file_path_length; 537 u16 *label; 538 struct efi_device_path *file_path; 539 u8 *optional_data; 540 }; 541 542 void efi_deserialize_load_option(struct efi_load_option *lo, u8 *data); 543 unsigned long efi_serialize_load_option(struct efi_load_option *lo, u8 **data); 544 void *efi_bootmgr_load(struct efi_device_path **device_path, 545 struct efi_device_path **file_path); 546 547 #else /* CONFIG_IS_ENABLED(EFI_LOADER) */ 548 549 /* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */ 550 #define __efi_runtime_data 551 #define __efi_runtime 552 static inline efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len) 553 { 554 return EFI_SUCCESS; 555 } 556 557 /* No loader configured, stub out EFI_ENTRY */ 558 static inline void efi_restore_gd(void) { } 559 static inline void efi_set_bootdev(const char *dev, const char *devnr, 560 const char *path) { } 561 static inline void efi_net_set_dhcp_ack(void *pkt, int len) { } 562 static inline void efi_print_image_infos(void *pc) { } 563 564 #endif /* CONFIG_IS_ENABLED(EFI_LOADER) */ 565 566 #endif /* _EFI_LOADER_H */ 567