1 /* 2 * EFI application loader 3 * 4 * Copyright (c) 2016 Alexander Graf 5 * 6 * SPDX-License-Identifier: GPL-2.0+ 7 */ 8 9 #include <common.h> 10 #include <part_efi.h> 11 #include <efi_api.h> 12 13 /* No need for efi loader support in SPL */ 14 #if defined(CONFIG_EFI_LOADER) && !defined(CONFIG_SPL_BUILD) 15 16 #include <linux/list.h> 17 18 int __efi_entry_check(void); 19 int __efi_exit_check(void); 20 const char *__efi_nesting_inc(void); 21 const char *__efi_nesting_dec(void); 22 23 /* 24 * Enter the u-boot world from UEFI: 25 */ 26 #define EFI_ENTRY(format, ...) do { \ 27 assert(__efi_entry_check()); \ 28 debug("%sEFI: Entry %s(" format ")\n", __efi_nesting_inc(), \ 29 __func__, ##__VA_ARGS__); \ 30 } while(0) 31 32 /* 33 * Exit the u-boot world back to UEFI: 34 */ 35 #define EFI_EXIT(ret) ({ \ 36 efi_status_t _r = ret; \ 37 debug("%sEFI: Exit: %s: %u\n", __efi_nesting_dec(), \ 38 __func__, (u32)(_r & ~EFI_ERROR_MASK)); \ 39 assert(__efi_exit_check()); \ 40 _r; \ 41 }) 42 43 /* 44 * Callback into UEFI world from u-boot: 45 */ 46 #define EFI_CALL(exp) do { \ 47 debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ 48 assert(__efi_exit_check()); \ 49 exp; \ 50 assert(__efi_entry_check()); \ 51 debug("%sEFI: Return From: %s\n", __efi_nesting_dec(), #exp); \ 52 } while(0) 53 54 extern struct efi_runtime_services efi_runtime_services; 55 extern struct efi_system_table systab; 56 57 extern const struct efi_simple_text_output_protocol efi_con_out; 58 extern struct efi_simple_input_interface efi_con_in; 59 extern const struct efi_console_control_protocol efi_console_control; 60 extern const struct efi_device_path_to_text_protocol efi_device_path_to_text; 61 62 extern const efi_guid_t efi_guid_console_control; 63 extern const efi_guid_t efi_guid_device_path; 64 extern const efi_guid_t efi_guid_loaded_image; 65 extern const efi_guid_t efi_guid_device_path_to_text_protocol; 66 67 extern unsigned int __efi_runtime_start, __efi_runtime_stop; 68 extern unsigned int __efi_runtime_rel_start, __efi_runtime_rel_stop; 69 70 /* 71 * When the UEFI payload wants to open a protocol on an object to get its 72 * interface (usually a struct with callback functions), this struct maps the 73 * protocol GUID to the respective protocol interface */ 74 struct efi_handler { 75 const efi_guid_t *guid; 76 void *protocol_interface; 77 }; 78 79 /* 80 * UEFI has a poor man's OO model where one "object" can be polymorphic and have 81 * multiple different protocols (classes) attached to it. 82 * 83 * This struct is the parent struct for all of our actual implementation objects 84 * that can include it to make themselves an EFI object 85 */ 86 struct efi_object { 87 /* Every UEFI object is part of a global object list */ 88 struct list_head link; 89 /* We support up to 8 "protocols" an object can be accessed through */ 90 struct efi_handler protocols[8]; 91 /* The object spawner can either use this for data or as identifier */ 92 void *handle; 93 }; 94 95 #define EFI_PROTOCOL_OBJECT(_guid, _protocol) (struct efi_object){ \ 96 .protocols = {{ \ 97 .guid = &(_guid), \ 98 .protocol_interface = (void *)(_protocol), \ 99 }}, \ 100 .handle = (void *)(_protocol), \ 101 } 102 103 /** 104 * struct efi_event 105 * 106 * @type: Type of event, see efi_create_event 107 * @notify_tpl: Task priority level of notifications 108 * @trigger_time: Period of the timer 109 * @trigger_next: Next time to trigger the timer 110 * @nofify_function: Function to call when the event is triggered 111 * @notify_context: Data to be passed to the notify function 112 * @trigger_type: Type of timer, see efi_set_timer 113 * @signaled: The notify function was already called 114 */ 115 struct efi_event { 116 uint32_t type; 117 UINTN notify_tpl; 118 void (EFIAPI *notify_function)(struct efi_event *event, void *context); 119 void *notify_context; 120 u64 trigger_next; 121 u64 trigger_time; 122 enum efi_timer_delay trigger_type; 123 int signaled; 124 }; 125 126 127 /* This list contains all UEFI objects we know of */ 128 extern struct list_head efi_obj_list; 129 130 /* Called by bootefi to make console interface available */ 131 int efi_console_register(void); 132 /* Called by bootefi to make all disk storage accessible as EFI objects */ 133 int efi_disk_register(void); 134 /* Called by bootefi to make GOP (graphical) interface available */ 135 int efi_gop_register(void); 136 /* Called by bootefi to make the network interface available */ 137 int efi_net_register(void **handle); 138 /* Called by bootefi to make SMBIOS tables available */ 139 void efi_smbios_register(void); 140 141 /* Called by networking code to memorize the dhcp ack package */ 142 void efi_net_set_dhcp_ack(void *pkt, int len); 143 144 /* Called from places to check whether a timer expired */ 145 void efi_timer_check(void); 146 /* PE loader implementation */ 147 void *efi_load_pe(void *efi, struct efi_loaded_image *loaded_image_info); 148 /* Called once to store the pristine gd pointer */ 149 void efi_save_gd(void); 150 /* Special case handler for error/abort that just tries to dtrt to get 151 * back to u-boot world */ 152 void efi_restore_gd(void); 153 /* Call this to relocate the runtime section to an address space */ 154 void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map); 155 /* Call this to set the current device name */ 156 void efi_set_bootdev(const char *dev, const char *devnr, const char *path); 157 /* Call this to create an event */ 158 efi_status_t efi_create_event(uint32_t type, UINTN notify_tpl, 159 void (EFIAPI *notify_function) ( 160 struct efi_event *event, 161 void *context), 162 void *notify_context, struct efi_event **event); 163 /* Call this to set a timer */ 164 efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type, 165 uint64_t trigger_time); 166 /* Call this to signal an event */ 167 void efi_signal_event(struct efi_event *event); 168 169 /* Generic EFI memory allocator, call this to get memory */ 170 void *efi_alloc(uint64_t len, int memory_type); 171 /* More specific EFI memory allocator, called by EFI payloads */ 172 efi_status_t efi_allocate_pages(int type, int memory_type, unsigned long pages, 173 uint64_t *memory); 174 /* EFI memory free function. */ 175 efi_status_t efi_free_pages(uint64_t memory, unsigned long pages); 176 /* EFI memory allocator for small allocations */ 177 efi_status_t efi_allocate_pool(int pool_type, unsigned long size, 178 void **buffer); 179 /* EFI pool memory free function. */ 180 efi_status_t efi_free_pool(void *buffer); 181 /* Returns the EFI memory map */ 182 efi_status_t efi_get_memory_map(unsigned long *memory_map_size, 183 struct efi_mem_desc *memory_map, 184 unsigned long *map_key, 185 unsigned long *descriptor_size, 186 uint32_t *descriptor_version); 187 /* Adds a range into the EFI memory map */ 188 uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type, 189 bool overlap_only_ram); 190 /* Called by board init to initialize the EFI memory map */ 191 int efi_memory_init(void); 192 /* Adds new or overrides configuration table entry to the system table */ 193 efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table); 194 195 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER 196 extern void *efi_bounce_buffer; 197 #define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024) 198 #endif 199 200 /* Convert strings from normal C strings to uEFI strings */ 201 static inline void ascii2unicode(u16 *unicode, const char *ascii) 202 { 203 while (*ascii) 204 *(unicode++) = *(ascii++); 205 } 206 207 static inline int guidcmp(const efi_guid_t *g1, const efi_guid_t *g2) 208 { 209 return memcmp(g1, g2, sizeof(efi_guid_t)); 210 } 211 212 /* 213 * Use these to indicate that your code / data should go into the EFI runtime 214 * section and thus still be available when the OS is running 215 */ 216 #define __efi_runtime_data __attribute__ ((section ("efi_runtime_data"))) 217 #define __efi_runtime __attribute__ ((section ("efi_runtime_text"))) 218 219 /* Call this with mmio_ptr as the _pointer_ to a pointer to an MMIO region 220 * to make it available at runtime */ 221 void efi_add_runtime_mmio(void *mmio_ptr, u64 len); 222 223 /* Boards may provide the functions below to implement RTS functionality */ 224 225 void __efi_runtime EFIAPI efi_reset_system( 226 enum efi_reset_type reset_type, 227 efi_status_t reset_status, 228 unsigned long data_size, void *reset_data); 229 void efi_reset_system_init(void); 230 231 efi_status_t __efi_runtime EFIAPI efi_get_time( 232 struct efi_time *time, 233 struct efi_time_cap *capabilities); 234 void efi_get_time_init(void); 235 236 #else /* defined(EFI_LOADER) && !defined(CONFIG_SPL_BUILD) */ 237 238 /* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */ 239 #define __efi_runtime_data 240 #define __efi_runtime 241 static inline void efi_add_runtime_mmio(void *mmio_ptr, u64 len) { } 242 243 /* No loader configured, stub out EFI_ENTRY */ 244 static inline void efi_restore_gd(void) { } 245 static inline void efi_set_bootdev(const char *dev, const char *devnr, 246 const char *path) { } 247 static inline void efi_net_set_dhcp_ack(void *pkt, int len) { } 248 249 #endif 250