]>
Commit | Line | Data |
---|---|---|
b9939336 AG |
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 <command.h> | |
9d922450 | 11 | #include <dm.h> |
b9939336 AG |
12 | #include <efi_loader.h> |
13 | #include <errno.h> | |
14 | #include <libfdt.h> | |
15 | #include <libfdt_env.h> | |
ad0c1a3d | 16 | #include <memalign.h> |
0d9d501f | 17 | #include <asm/global_data.h> |
e275458c SG |
18 | #include <asm-generic/sections.h> |
19 | #include <linux/linkage.h> | |
0d9d501f AG |
20 | |
21 | DECLARE_GLOBAL_DATA_PTR; | |
b9939336 | 22 | |
7cbc1241 HS |
23 | static uint8_t efi_obj_list_initalized; |
24 | ||
b9939336 AG |
25 | /* |
26 | * When booting using the "bootefi" command, we don't know which | |
27 | * physical device the file came from. So we create a pseudo-device | |
28 | * called "bootefi" with the device path /bootefi. | |
29 | * | |
30 | * In addition to the originating device we also declare the file path | |
31 | * of "bootefi" based loads to be /bootefi. | |
32 | */ | |
0f4060eb | 33 | static struct efi_device_path_file_path bootefi_image_path[] = { |
b9939336 AG |
34 | { |
35 | .dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE, | |
36 | .dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH, | |
0f4060eb | 37 | .dp.length = sizeof(bootefi_image_path[0]), |
b9939336 AG |
38 | .str = { 'b','o','o','t','e','f','i' }, |
39 | }, { | |
40 | .dp.type = DEVICE_PATH_TYPE_END, | |
41 | .dp.sub_type = DEVICE_PATH_SUB_TYPE_END, | |
0f4060eb | 42 | .dp.length = sizeof(bootefi_image_path[0]), |
b9939336 AG |
43 | } |
44 | }; | |
45 | ||
c07ad7c0 AG |
46 | static struct efi_device_path_file_path bootefi_device_path[] = { |
47 | { | |
48 | .dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE, | |
49 | .dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH, | |
50 | .dp.length = sizeof(bootefi_image_path[0]), | |
51 | .str = { 'b','o','o','t','e','f','i' }, | |
52 | }, { | |
53 | .dp.type = DEVICE_PATH_TYPE_END, | |
54 | .dp.sub_type = DEVICE_PATH_SUB_TYPE_END, | |
55 | .dp.length = sizeof(bootefi_image_path[0]), | |
56 | } | |
57 | }; | |
58 | ||
b9939336 AG |
59 | /* The EFI loaded_image interface for the image executed via "bootefi" */ |
60 | static struct efi_loaded_image loaded_image_info = { | |
c07ad7c0 | 61 | .device_handle = bootefi_device_path, |
0f4060eb | 62 | .file_path = bootefi_image_path, |
b9939336 AG |
63 | }; |
64 | ||
65 | /* The EFI object struct for the image executed via "bootefi" */ | |
66 | static struct efi_object loaded_image_info_obj = { | |
67 | .handle = &loaded_image_info, | |
68 | .protocols = { | |
69 | { | |
70 | /* | |
71 | * When asking for the loaded_image interface, just | |
72 | * return handle which points to loaded_image_info | |
73 | */ | |
74 | .guid = &efi_guid_loaded_image, | |
b5349f74 | 75 | .protocol_interface = &loaded_image_info, |
b9939336 AG |
76 | }, |
77 | { | |
78 | /* | |
79 | * When asking for the device path interface, return | |
c07ad7c0 | 80 | * bootefi_device_path |
b9939336 AG |
81 | */ |
82 | .guid = &efi_guid_device_path, | |
b5349f74 | 83 | .protocol_interface = bootefi_device_path, |
b9939336 | 84 | }, |
88adae5e | 85 | { |
86 | .guid = &efi_guid_console_control, | |
87 | .protocol_interface = (void *) &efi_console_control | |
88 | }, | |
cc5b7081 | 89 | { |
90 | .guid = &efi_guid_device_path_to_text_protocol, | |
91 | .protocol_interface = (void *) &efi_device_path_to_text | |
92 | }, | |
b9939336 AG |
93 | }, |
94 | }; | |
95 | ||
96 | /* The EFI object struct for the device the "bootefi" image was loaded from */ | |
97 | static struct efi_object bootefi_device_obj = { | |
c07ad7c0 | 98 | .handle = bootefi_device_path, |
b9939336 AG |
99 | .protocols = { |
100 | { | |
101 | /* When asking for the device path interface, return | |
c07ad7c0 | 102 | * bootefi_device_path */ |
b9939336 | 103 | .guid = &efi_guid_device_path, |
b5349f74 | 104 | .protocol_interface = bootefi_device_path |
b9939336 AG |
105 | } |
106 | }, | |
107 | }; | |
108 | ||
7cbc1241 HS |
109 | /* Initialize and populate EFI object list */ |
110 | static void efi_init_obj_list(void) | |
111 | { | |
112 | efi_obj_list_initalized = 1; | |
113 | ||
114 | list_add_tail(&loaded_image_info_obj.link, &efi_obj_list); | |
115 | list_add_tail(&bootefi_device_obj.link, &efi_obj_list); | |
116 | efi_console_register(); | |
117 | #ifdef CONFIG_PARTITIONS | |
118 | efi_disk_register(); | |
119 | #endif | |
120 | #if defined(CONFIG_LCD) || defined(CONFIG_DM_VIDEO) | |
121 | efi_gop_register(); | |
122 | #endif | |
123 | #ifdef CONFIG_NET | |
124 | void *nethandle = loaded_image_info.device_handle; | |
125 | efi_net_register(&nethandle); | |
126 | ||
127 | if (!memcmp(bootefi_device_path[0].str, "N\0e\0t", 6)) | |
128 | loaded_image_info.device_handle = nethandle; | |
129 | else | |
130 | loaded_image_info.device_handle = bootefi_device_path; | |
131 | #endif | |
132 | #ifdef CONFIG_GENERATE_SMBIOS_TABLE | |
133 | efi_smbios_register(); | |
134 | #endif | |
135 | ||
136 | /* Initialize EFI runtime services */ | |
137 | efi_reset_system_init(); | |
138 | efi_get_time_init(); | |
139 | } | |
140 | ||
0d9d501f AG |
141 | static void *copy_fdt(void *fdt) |
142 | { | |
143 | u64 fdt_size = fdt_totalsize(fdt); | |
ad0c1a3d AG |
144 | unsigned long fdt_ram_start = -1L, fdt_pages; |
145 | u64 new_fdt_addr; | |
0d9d501f | 146 | void *new_fdt; |
ad0c1a3d | 147 | int i; |
0d9d501f | 148 | |
ad0c1a3d AG |
149 | for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { |
150 | u64 ram_start = gd->bd->bi_dram[i].start; | |
151 | u64 ram_size = gd->bd->bi_dram[i].size; | |
0d9d501f | 152 | |
ad0c1a3d AG |
153 | if (!ram_size) |
154 | continue; | |
155 | ||
156 | if (ram_start < fdt_ram_start) | |
157 | fdt_ram_start = ram_start; | |
158 | } | |
159 | ||
160 | /* Give us at least 4kb breathing room */ | |
a44bffcc | 161 | fdt_size = ALIGN(fdt_size + 4096, EFI_PAGE_SIZE); |
ad0c1a3d AG |
162 | fdt_pages = fdt_size >> EFI_PAGE_SHIFT; |
163 | ||
164 | /* Safe fdt location is at 128MB */ | |
165 | new_fdt_addr = fdt_ram_start + (128 * 1024 * 1024) + fdt_size; | |
166 | if (efi_allocate_pages(1, EFI_BOOT_SERVICES_DATA, fdt_pages, | |
167 | &new_fdt_addr) != EFI_SUCCESS) { | |
168 | /* If we can't put it there, put it somewhere */ | |
a44bffcc | 169 | new_fdt_addr = (ulong)memalign(EFI_PAGE_SIZE, fdt_size); |
85a6e9b3 AG |
170 | if (efi_allocate_pages(1, EFI_BOOT_SERVICES_DATA, fdt_pages, |
171 | &new_fdt_addr) != EFI_SUCCESS) { | |
172 | printf("ERROR: Failed to reserve space for FDT\n"); | |
173 | return NULL; | |
174 | } | |
ad0c1a3d | 175 | } |
85a6e9b3 | 176 | |
ad0c1a3d | 177 | new_fdt = (void*)(ulong)new_fdt_addr; |
0d9d501f AG |
178 | memcpy(new_fdt, fdt, fdt_totalsize(fdt)); |
179 | fdt_set_totalsize(new_fdt, fdt_size); | |
180 | ||
181 | return new_fdt; | |
182 | } | |
183 | ||
b06d8ac3 | 184 | static ulong efi_do_enter(void *image_handle, |
185 | struct efi_system_table *st, | |
186 | asmlinkage ulong (*entry)(void *image_handle, | |
187 | struct efi_system_table *st)) | |
188 | { | |
189 | efi_status_t ret = EFI_LOAD_ERROR; | |
190 | ||
191 | if (entry) | |
192 | ret = entry(image_handle, st); | |
193 | st->boottime->exit(image_handle, ret, 0, NULL); | |
194 | return ret; | |
195 | } | |
196 | ||
ec6617c3 | 197 | #ifdef CONFIG_ARM64 |
b06d8ac3 | 198 | static unsigned long efi_run_in_el2(asmlinkage ulong (*entry)( |
199 | void *image_handle, struct efi_system_table *st), | |
200 | void *image_handle, struct efi_system_table *st) | |
ec6617c3 AW |
201 | { |
202 | /* Enable caches again */ | |
203 | dcache_enable(); | |
204 | ||
b06d8ac3 | 205 | return efi_do_enter(image_handle, st, entry); |
ec6617c3 AW |
206 | } |
207 | #endif | |
208 | ||
b9939336 AG |
209 | /* |
210 | * Load an EFI payload into a newly allocated piece of memory, register all | |
211 | * EFI objects it would want to access and jump to it. | |
212 | */ | |
1c39809b | 213 | static unsigned long do_bootefi_exec(void *efi, void *fdt) |
b9939336 | 214 | { |
e275458c SG |
215 | ulong (*entry)(void *image_handle, struct efi_system_table *st) |
216 | asmlinkage; | |
b9939336 | 217 | ulong fdt_pages, fdt_size, fdt_start, fdt_end; |
f4f9993f | 218 | const efi_guid_t fdt_guid = EFI_FDT_GUID; |
dea2174d | 219 | bootm_headers_t img = { 0 }; |
b9939336 AG |
220 | |
221 | /* | |
222 | * gd lives in a fixed register which may get clobbered while we execute | |
223 | * the payload. So save it here and restore it on every callback entry | |
224 | */ | |
225 | efi_save_gd(); | |
226 | ||
1c39809b | 227 | if (fdt && !fdt_check_header(fdt)) { |
dea2174d | 228 | /* Prepare fdt for payload */ |
0d9d501f AG |
229 | fdt = copy_fdt(fdt); |
230 | ||
231 | if (image_setup_libfdt(&img, fdt, 0, NULL)) { | |
dea2174d AG |
232 | printf("ERROR: Failed to process device tree\n"); |
233 | return -EINVAL; | |
234 | } | |
235 | ||
236 | /* Link to it in the efi tables */ | |
f4f9993f | 237 | efi_install_configuration_table(&fdt_guid, fdt); |
b9939336 AG |
238 | |
239 | /* And reserve the space in the memory map */ | |
0d9d501f AG |
240 | fdt_start = ((ulong)fdt) & ~EFI_PAGE_MASK; |
241 | fdt_end = ((ulong)fdt) + fdt_totalsize(fdt); | |
b9939336 AG |
242 | fdt_size = (fdt_end - fdt_start) + EFI_PAGE_MASK; |
243 | fdt_pages = fdt_size >> EFI_PAGE_SHIFT; | |
244 | /* Give a bootloader the chance to modify the device tree */ | |
245 | fdt_pages += 2; | |
246 | efi_add_memory_map(fdt_start, fdt_pages, | |
247 | EFI_BOOT_SERVICES_DATA, true); | |
b9939336 | 248 | } else { |
1c39809b | 249 | printf("WARNING: Invalid device tree, expect boot to fail\n"); |
f4f9993f | 250 | efi_install_configuration_table(&fdt_guid, NULL); |
b9939336 AG |
251 | } |
252 | ||
253 | /* Load the EFI payload */ | |
254 | entry = efi_load_pe(efi, &loaded_image_info); | |
255 | if (!entry) | |
256 | return -ENOENT; | |
257 | ||
258 | /* Initialize and populate EFI object list */ | |
7cbc1241 HS |
259 | if (!efi_obj_list_initalized) |
260 | efi_init_obj_list(); | |
80a4800e | 261 | |
b9939336 | 262 | /* Call our payload! */ |
edcef3ba | 263 | debug("%s:%d Jumping to 0x%lx\n", __func__, __LINE__, (long)entry); |
a86aeaf2 AG |
264 | |
265 | if (setjmp(&loaded_image_info.exit_jmp)) { | |
1da1bac4 | 266 | return loaded_image_info.exit_status; |
a86aeaf2 AG |
267 | } |
268 | ||
69bd459d AG |
269 | #ifdef CONFIG_ARM64 |
270 | /* On AArch64 we need to make sure we call our payload in < EL3 */ | |
271 | if (current_el() == 3) { | |
272 | smp_kick_all_cpus(); | |
273 | dcache_disable(); /* flush cache before switch to EL2 */ | |
ec6617c3 AW |
274 | |
275 | /* Move into EL2 and keep running there */ | |
276 | armv8_switch_to_el2((ulong)entry, (ulong)&loaded_image_info, | |
7c5e1feb | 277 | (ulong)&systab, 0, (ulong)efi_run_in_el2, |
ec6617c3 AW |
278 | ES_TO_AARCH64); |
279 | ||
280 | /* Should never reach here, efi exits with longjmp */ | |
281 | while (1) { } | |
69bd459d AG |
282 | } |
283 | #endif | |
284 | ||
b06d8ac3 | 285 | return efi_do_enter(&loaded_image_info, &systab, entry); |
b9939336 AG |
286 | } |
287 | ||
288 | ||
289 | /* Interpreter command to boot an arbitrary EFI image from memory */ | |
290 | static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) | |
291 | { | |
1c39809b AG |
292 | char *saddr, *sfdt; |
293 | unsigned long addr, fdt_addr = 0; | |
1da1bac4 | 294 | unsigned long r; |
b9939336 AG |
295 | |
296 | if (argc < 2) | |
3c1dcef6 | 297 | return CMD_RET_USAGE; |
c7ae3dfd SG |
298 | #ifdef CONFIG_CMD_BOOTEFI_HELLO |
299 | if (!strcmp(argv[1], "hello")) { | |
300 | ulong size = __efi_hello_world_end - __efi_hello_world_begin; | |
b9939336 | 301 | |
c7ae3dfd SG |
302 | addr = CONFIG_SYS_LOAD_ADDR; |
303 | memcpy((char *)addr, __efi_hello_world_begin, size); | |
304 | } else | |
305 | #endif | |
306 | { | |
307 | saddr = argv[1]; | |
b9939336 | 308 | |
c7ae3dfd SG |
309 | addr = simple_strtoul(saddr, NULL, 16); |
310 | ||
311 | if (argc > 2) { | |
312 | sfdt = argv[2]; | |
313 | fdt_addr = simple_strtoul(sfdt, NULL, 16); | |
314 | } | |
1c39809b AG |
315 | } |
316 | ||
5ee31baf | 317 | printf("## Starting EFI application at %08lx ...\n", addr); |
1c39809b | 318 | r = do_bootefi_exec((void *)addr, (void*)fdt_addr); |
1da1bac4 | 319 | printf("## Application terminated, r = %lu\n", |
320 | r & ~EFI_ERROR_MASK); | |
b9939336 | 321 | |
1da1bac4 | 322 | if (r != EFI_SUCCESS) |
323 | return 1; | |
324 | else | |
325 | return 0; | |
b9939336 AG |
326 | } |
327 | ||
328 | #ifdef CONFIG_SYS_LONGHELP | |
329 | static char bootefi_help_text[] = | |
1c39809b AG |
330 | "<image address> [fdt address]\n" |
331 | " - boot EFI payload stored at address <image address>.\n" | |
332 | " If specified, the device tree located at <fdt address> gets\n" | |
c7ae3dfd SG |
333 | " exposed as EFI configuration table.\n" |
334 | #ifdef CONFIG_CMD_BOOTEFI_HELLO | |
335 | "hello\n" | |
336 | " - boot a sample Hello World application stored within U-Boot" | |
337 | #endif | |
338 | ; | |
b9939336 AG |
339 | #endif |
340 | ||
341 | U_BOOT_CMD( | |
1c39809b | 342 | bootefi, 3, 0, do_bootefi, |
92dfd922 | 343 | "Boots an EFI payload from memory", |
b9939336 AG |
344 | bootefi_help_text |
345 | ); | |
0f4060eb | 346 | |
c07ad7c0 | 347 | void efi_set_bootdev(const char *dev, const char *devnr, const char *path) |
0f4060eb | 348 | { |
8c3df0bf | 349 | __maybe_unused struct blk_desc *desc; |
ecbe1a07 | 350 | char devname[32] = { 0 }; /* dp->str is u16[32] long */ |
3e433e96 | 351 | char *colon, *s; |
0f4060eb | 352 | |
1acc0087 | 353 | #if defined(CONFIG_BLK) || CONFIG_IS_ENABLED(ISO_PARTITION) |
f9d334bd AG |
354 | desc = blk_get_dev(dev, simple_strtol(devnr, NULL, 10)); |
355 | #endif | |
356 | ||
357 | #ifdef CONFIG_BLK | |
358 | if (desc) { | |
359 | snprintf(devname, sizeof(devname), "%s", desc->bdev->name); | |
360 | } else | |
361 | #endif | |
362 | ||
363 | { | |
364 | /* Assemble the condensed device name we use in efi_disk.c */ | |
365 | snprintf(devname, sizeof(devname), "%s%s", dev, devnr); | |
366 | } | |
367 | ||
0f4060eb | 368 | colon = strchr(devname, ':'); |
8c3df0bf | 369 | |
1acc0087 | 370 | #if CONFIG_IS_ENABLED(ISO_PARTITION) |
8c3df0bf | 371 | /* For ISOs we create partition block devices */ |
8c3df0bf AG |
372 | if (desc && (desc->type != DEV_TYPE_UNKNOWN) && |
373 | (desc->part_type == PART_TYPE_ISO)) { | |
374 | if (!colon) | |
f9d334bd AG |
375 | snprintf(devname, sizeof(devname), "%s:1", devname); |
376 | ||
8c3df0bf AG |
377 | colon = NULL; |
378 | } | |
379 | #endif | |
380 | ||
0f4060eb AG |
381 | if (colon) |
382 | *colon = '\0'; | |
383 | ||
c07ad7c0 AG |
384 | /* Patch bootefi_device_path to the target device */ |
385 | memset(bootefi_device_path[0].str, 0, sizeof(bootefi_device_path[0].str)); | |
386 | ascii2unicode(bootefi_device_path[0].str, devname); | |
387 | ||
388 | /* Patch bootefi_image_path to the target file path */ | |
0f4060eb | 389 | memset(bootefi_image_path[0].str, 0, sizeof(bootefi_image_path[0].str)); |
49271666 AG |
390 | if (strcmp(dev, "Net")) { |
391 | /* Add leading / to fs paths, because they're absolute */ | |
392 | snprintf(devname, sizeof(devname), "/%s", path); | |
393 | } else { | |
394 | snprintf(devname, sizeof(devname), "%s", path); | |
395 | } | |
3e433e96 RC |
396 | /* DOS style file path: */ |
397 | s = devname; | |
398 | while ((s = strchr(s, '/'))) | |
399 | *s++ = '\\'; | |
0f4060eb AG |
400 | ascii2unicode(bootefi_image_path[0].str, devname); |
401 | } |