1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * EFI application loader 4 * 5 * Copyright (c) 2016 Alexander Graf 6 */ 7 8 #include <charset.h> 9 #include <common.h> 10 #include <command.h> 11 #include <dm.h> 12 #include <efi_loader.h> 13 #include <efi_selftest.h> 14 #include <errno.h> 15 #include <linux/libfdt.h> 16 #include <linux/libfdt_env.h> 17 #include <mapmem.h> 18 #include <memalign.h> 19 #include <asm/global_data.h> 20 #include <asm-generic/sections.h> 21 #include <asm-generic/unaligned.h> 22 #include <linux/linkage.h> 23 24 #ifdef CONFIG_ARMV7_NONSEC 25 #include <asm/armv7.h> 26 #include <asm/secure.h> 27 #endif 28 29 DECLARE_GLOBAL_DATA_PTR; 30 31 #define OBJ_LIST_NOT_INITIALIZED 1 32 33 static efi_status_t efi_obj_list_initialized = OBJ_LIST_NOT_INITIALIZED; 34 35 static struct efi_device_path *bootefi_image_path; 36 static struct efi_device_path *bootefi_device_path; 37 38 /* Initialize and populate EFI object list */ 39 efi_status_t efi_init_obj_list(void) 40 { 41 efi_status_t ret = EFI_SUCCESS; 42 43 /* Initialize once only */ 44 if (efi_obj_list_initialized != OBJ_LIST_NOT_INITIALIZED) 45 return efi_obj_list_initialized; 46 47 /* Initialize EFI driver uclass */ 48 ret = efi_driver_init(); 49 if (ret != EFI_SUCCESS) 50 goto out; 51 52 ret = efi_console_register(); 53 if (ret != EFI_SUCCESS) 54 goto out; 55 #ifdef CONFIG_PARTITIONS 56 ret = efi_disk_register(); 57 if (ret != EFI_SUCCESS) 58 goto out; 59 #endif 60 #if defined(CONFIG_LCD) || defined(CONFIG_DM_VIDEO) 61 ret = efi_gop_register(); 62 if (ret != EFI_SUCCESS) 63 goto out; 64 #endif 65 #ifdef CONFIG_NET 66 ret = efi_net_register(); 67 if (ret != EFI_SUCCESS) 68 goto out; 69 #endif 70 #ifdef CONFIG_GENERATE_ACPI_TABLE 71 ret = efi_acpi_register(); 72 if (ret != EFI_SUCCESS) 73 goto out; 74 #endif 75 #ifdef CONFIG_GENERATE_SMBIOS_TABLE 76 ret = efi_smbios_register(); 77 if (ret != EFI_SUCCESS) 78 goto out; 79 #endif 80 ret = efi_watchdog_register(); 81 if (ret != EFI_SUCCESS) 82 goto out; 83 84 /* Initialize EFI runtime services */ 85 ret = efi_reset_system_init(); 86 if (ret != EFI_SUCCESS) 87 goto out; 88 ret = efi_get_time_init(); 89 if (ret != EFI_SUCCESS) 90 goto out; 91 92 out: 93 efi_obj_list_initialized = ret; 94 return ret; 95 } 96 97 /* 98 * Allow unaligned memory access. 99 * 100 * This routine is overridden by architectures providing this feature. 101 */ 102 void __weak allow_unaligned(void) 103 { 104 } 105 106 /* 107 * Set the load options of an image from an environment variable. 108 * 109 * @loaded_image_info: the image 110 * @env_var: name of the environment variable 111 */ 112 static void set_load_options(struct efi_loaded_image *loaded_image_info, 113 const char *env_var) 114 { 115 size_t size; 116 const char *env = env_get(env_var); 117 118 loaded_image_info->load_options = NULL; 119 loaded_image_info->load_options_size = 0; 120 if (!env) 121 return; 122 size = strlen(env) + 1; 123 loaded_image_info->load_options = calloc(size, sizeof(u16)); 124 if (!loaded_image_info->load_options) { 125 printf("ERROR: Out of memory\n"); 126 return; 127 } 128 utf8_to_utf16(loaded_image_info->load_options, (u8 *)env, size); 129 loaded_image_info->load_options_size = size * 2; 130 } 131 132 static void *copy_fdt(void *fdt) 133 { 134 u64 fdt_size = fdt_totalsize(fdt); 135 unsigned long fdt_ram_start = -1L, fdt_pages; 136 u64 new_fdt_addr; 137 void *new_fdt; 138 int i; 139 140 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { 141 u64 ram_start = gd->bd->bi_dram[i].start; 142 u64 ram_size = gd->bd->bi_dram[i].size; 143 144 if (!ram_size) 145 continue; 146 147 if (ram_start < fdt_ram_start) 148 fdt_ram_start = ram_start; 149 } 150 151 /* Give us at least 4kb breathing room */ 152 fdt_size = ALIGN(fdt_size + 4096, EFI_PAGE_SIZE); 153 fdt_pages = fdt_size >> EFI_PAGE_SHIFT; 154 155 /* Safe fdt location is at 128MB */ 156 new_fdt_addr = fdt_ram_start + (128 * 1024 * 1024) + fdt_size; 157 if (efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, 158 EFI_RUNTIME_SERVICES_DATA, fdt_pages, 159 &new_fdt_addr) != EFI_SUCCESS) { 160 /* If we can't put it there, put it somewhere */ 161 new_fdt_addr = (ulong)memalign(EFI_PAGE_SIZE, fdt_size); 162 if (efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, 163 EFI_RUNTIME_SERVICES_DATA, fdt_pages, 164 &new_fdt_addr) != EFI_SUCCESS) { 165 printf("ERROR: Failed to reserve space for FDT\n"); 166 return NULL; 167 } 168 } 169 170 new_fdt = (void*)(ulong)new_fdt_addr; 171 memcpy(new_fdt, fdt, fdt_totalsize(fdt)); 172 fdt_set_totalsize(new_fdt, fdt_size); 173 174 return new_fdt; 175 } 176 177 static efi_status_t efi_do_enter( 178 efi_handle_t image_handle, struct efi_system_table *st, 179 EFIAPI efi_status_t (*entry)( 180 efi_handle_t image_handle, 181 struct efi_system_table *st)) 182 { 183 efi_status_t ret = EFI_LOAD_ERROR; 184 185 if (entry) 186 ret = entry(image_handle, st); 187 st->boottime->exit(image_handle, ret, 0, NULL); 188 return ret; 189 } 190 191 #ifdef CONFIG_ARM64 192 static efi_status_t efi_run_in_el2(EFIAPI efi_status_t (*entry)( 193 efi_handle_t image_handle, struct efi_system_table *st), 194 efi_handle_t image_handle, struct efi_system_table *st) 195 { 196 /* Enable caches again */ 197 dcache_enable(); 198 199 return efi_do_enter(image_handle, st, entry); 200 } 201 #endif 202 203 #ifdef CONFIG_ARMV7_NONSEC 204 static bool is_nonsec; 205 206 static efi_status_t efi_run_in_hyp(EFIAPI efi_status_t (*entry)( 207 efi_handle_t image_handle, struct efi_system_table *st), 208 efi_handle_t image_handle, struct efi_system_table *st) 209 { 210 /* Enable caches again */ 211 dcache_enable(); 212 213 is_nonsec = true; 214 215 return efi_do_enter(image_handle, st, entry); 216 } 217 #endif 218 219 /* Carve out DT reserved memory ranges */ 220 static efi_status_t efi_carve_out_dt_rsv(void *fdt) 221 { 222 int nr_rsv, i; 223 uint64_t addr, size, pages; 224 225 nr_rsv = fdt_num_mem_rsv(fdt); 226 227 /* Look for an existing entry and add it to the efi mem map. */ 228 for (i = 0; i < nr_rsv; i++) { 229 if (fdt_get_mem_rsv(fdt, i, &addr, &size) != 0) 230 continue; 231 232 pages = ALIGN(size, EFI_PAGE_SIZE) >> EFI_PAGE_SHIFT; 233 efi_add_memory_map(addr, pages, EFI_RESERVED_MEMORY_TYPE, 234 false); 235 } 236 237 return EFI_SUCCESS; 238 } 239 240 static efi_status_t efi_install_fdt(void *fdt) 241 { 242 bootm_headers_t img = { 0 }; 243 ulong fdt_pages, fdt_size, fdt_start, fdt_end; 244 efi_status_t ret; 245 246 if (fdt_check_header(fdt)) { 247 printf("ERROR: invalid device tree\n"); 248 return EFI_INVALID_PARAMETER; 249 } 250 251 /* Prepare fdt for payload */ 252 fdt = copy_fdt(fdt); 253 if (!fdt) 254 return EFI_OUT_OF_RESOURCES; 255 256 if (image_setup_libfdt(&img, fdt, 0, NULL)) { 257 printf("ERROR: failed to process device tree\n"); 258 return EFI_LOAD_ERROR; 259 } 260 261 if (efi_carve_out_dt_rsv(fdt) != EFI_SUCCESS) { 262 printf("ERROR: failed to carve out memory\n"); 263 return EFI_LOAD_ERROR; 264 } 265 266 /* Link to it in the efi tables */ 267 ret = efi_install_configuration_table(&efi_guid_fdt, fdt); 268 if (ret != EFI_SUCCESS) 269 return EFI_OUT_OF_RESOURCES; 270 271 /* And reserve the space in the memory map */ 272 fdt_start = ((ulong)fdt) & ~EFI_PAGE_MASK; 273 fdt_end = ((ulong)fdt) + fdt_totalsize(fdt); 274 fdt_size = (fdt_end - fdt_start) + EFI_PAGE_MASK; 275 fdt_pages = fdt_size >> EFI_PAGE_SHIFT; 276 /* Give a bootloader the chance to modify the device tree */ 277 fdt_pages += 2; 278 ret = efi_add_memory_map(fdt_start, fdt_pages, 279 EFI_BOOT_SERVICES_DATA, true); 280 return ret; 281 } 282 283 /* 284 * Load an EFI payload into a newly allocated piece of memory, register all 285 * EFI objects it would want to access and jump to it. 286 */ 287 static efi_status_t do_bootefi_exec(void *efi, 288 struct efi_device_path *device_path, 289 struct efi_device_path *image_path) 290 { 291 struct efi_loaded_image loaded_image_info = {}; 292 struct efi_object loaded_image_info_obj = {}; 293 struct efi_object mem_obj = {}; 294 struct efi_device_path *memdp = NULL; 295 efi_status_t ret; 296 297 EFIAPI efi_status_t (*entry)(efi_handle_t image_handle, 298 struct efi_system_table *st); 299 300 /* 301 * Special case for efi payload not loaded from disk, such as 302 * 'bootefi hello' or for example payload loaded directly into 303 * memory via jtag/etc: 304 */ 305 if (!device_path && !image_path) { 306 printf("WARNING: using memory device/image path, this may confuse some payloads!\n"); 307 /* actual addresses filled in after efi_load_pe() */ 308 memdp = efi_dp_from_mem(0, 0, 0); 309 device_path = image_path = memdp; 310 efi_add_handle(&mem_obj); 311 312 ret = efi_add_protocol(mem_obj.handle, &efi_guid_device_path, 313 device_path); 314 if (ret != EFI_SUCCESS) 315 goto exit; 316 } else { 317 assert(device_path && image_path); 318 } 319 320 efi_setup_loaded_image(&loaded_image_info, &loaded_image_info_obj, 321 device_path, image_path); 322 323 /* 324 * gd lives in a fixed register which may get clobbered while we execute 325 * the payload. So save it here and restore it on every callback entry 326 */ 327 efi_save_gd(); 328 329 /* Transfer environment variable bootargs as load options */ 330 set_load_options(&loaded_image_info, "bootargs"); 331 /* Load the EFI payload */ 332 entry = efi_load_pe(efi, &loaded_image_info); 333 if (!entry) { 334 ret = EFI_LOAD_ERROR; 335 goto exit; 336 } 337 338 if (memdp) { 339 struct efi_device_path_memory *mdp = (void *)memdp; 340 mdp->memory_type = loaded_image_info.image_code_type; 341 mdp->start_address = (uintptr_t)loaded_image_info.image_base; 342 mdp->end_address = mdp->start_address + 343 loaded_image_info.image_size; 344 } 345 346 /* we don't support much: */ 347 env_set("efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported", 348 "{ro,boot}(blob)0000000000000000"); 349 350 /* Call our payload! */ 351 debug("%s:%d Jumping to 0x%lx\n", __func__, __LINE__, (long)entry); 352 353 if (setjmp(&loaded_image_info.exit_jmp)) { 354 ret = loaded_image_info.exit_status; 355 goto exit; 356 } 357 358 #ifdef CONFIG_ARM64 359 /* On AArch64 we need to make sure we call our payload in < EL3 */ 360 if (current_el() == 3) { 361 smp_kick_all_cpus(); 362 dcache_disable(); /* flush cache before switch to EL2 */ 363 364 /* Move into EL2 and keep running there */ 365 armv8_switch_to_el2((ulong)entry, 366 (ulong)&loaded_image_info_obj.handle, 367 (ulong)&systab, 0, (ulong)efi_run_in_el2, 368 ES_TO_AARCH64); 369 370 /* Should never reach here, efi exits with longjmp */ 371 while (1) { } 372 } 373 #endif 374 375 #ifdef CONFIG_ARMV7_NONSEC 376 if (armv7_boot_nonsec() && !is_nonsec) { 377 dcache_disable(); /* flush cache before switch to HYP */ 378 379 armv7_init_nonsec(); 380 secure_ram_addr(_do_nonsec_entry)( 381 efi_run_in_hyp, 382 (uintptr_t)entry, 383 (uintptr_t)loaded_image_info_obj.handle, 384 (uintptr_t)&systab); 385 386 /* Should never reach here, efi exits with longjmp */ 387 while (1) { } 388 } 389 #endif 390 391 ret = efi_do_enter(loaded_image_info_obj.handle, &systab, entry); 392 393 exit: 394 /* image has returned, loaded-image obj goes *poof*: */ 395 list_del(&loaded_image_info_obj.link); 396 if (mem_obj.handle) 397 list_del(&mem_obj.link); 398 399 return ret; 400 } 401 402 static int do_bootefi_bootmgr_exec(void) 403 { 404 struct efi_device_path *device_path, *file_path; 405 void *addr; 406 efi_status_t r; 407 408 /* 409 * gd lives in a fixed register which may get clobbered while we execute 410 * the payload. So save it here and restore it on every callback entry 411 */ 412 efi_save_gd(); 413 414 addr = efi_bootmgr_load(&device_path, &file_path); 415 if (!addr) 416 return 1; 417 418 printf("## Starting EFI application at %p ...\n", addr); 419 r = do_bootefi_exec(addr, device_path, file_path); 420 printf("## Application terminated, r = %lu\n", 421 r & ~EFI_ERROR_MASK); 422 423 if (r != EFI_SUCCESS) 424 return 1; 425 426 return 0; 427 } 428 429 /* Interpreter command to boot an arbitrary EFI image from memory */ 430 static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 431 { 432 unsigned long addr; 433 char *saddr; 434 efi_status_t r; 435 unsigned long fdt_addr; 436 void *fdt; 437 438 /* Allow unaligned memory access */ 439 allow_unaligned(); 440 441 /* Initialize EFI drivers */ 442 r = efi_init_obj_list(); 443 if (r != EFI_SUCCESS) { 444 printf("Error: Cannot set up EFI drivers, r = %lu\n", 445 r & ~EFI_ERROR_MASK); 446 return CMD_RET_FAILURE; 447 } 448 449 if (argc < 2) 450 return CMD_RET_USAGE; 451 452 if (argc > 2) { 453 fdt_addr = simple_strtoul(argv[2], NULL, 16); 454 if (!fdt_addr && *argv[2] != '0') 455 return CMD_RET_USAGE; 456 /* Install device tree */ 457 fdt = map_sysmem(fdt_addr, 0); 458 r = efi_install_fdt(fdt); 459 if (r != EFI_SUCCESS) { 460 printf("ERROR: failed to install device tree\n"); 461 return CMD_RET_FAILURE; 462 } 463 } else { 464 /* Remove device tree. EFI_NOT_FOUND can be ignored here */ 465 efi_install_configuration_table(&efi_guid_fdt, NULL); 466 printf("WARNING: booting without device tree\n"); 467 } 468 #ifdef CONFIG_CMD_BOOTEFI_HELLO 469 if (!strcmp(argv[1], "hello")) { 470 ulong size = __efi_helloworld_end - __efi_helloworld_begin; 471 472 saddr = env_get("loadaddr"); 473 if (saddr) 474 addr = simple_strtoul(saddr, NULL, 16); 475 else 476 addr = CONFIG_SYS_LOAD_ADDR; 477 memcpy(map_sysmem(addr, size), __efi_helloworld_begin, size); 478 } else 479 #endif 480 #ifdef CONFIG_CMD_BOOTEFI_SELFTEST 481 if (!strcmp(argv[1], "selftest")) { 482 struct efi_loaded_image loaded_image_info = {}; 483 struct efi_object loaded_image_info_obj = {}; 484 485 /* Construct a dummy device path. */ 486 bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE, 487 (uintptr_t)&efi_selftest, 488 (uintptr_t)&efi_selftest); 489 bootefi_image_path = efi_dp_from_file(NULL, 0, "\\selftest"); 490 491 efi_setup_loaded_image(&loaded_image_info, 492 &loaded_image_info_obj, 493 bootefi_device_path, bootefi_image_path); 494 /* 495 * gd lives in a fixed register which may get clobbered while we 496 * execute the payload. So save it here and restore it on every 497 * callback entry 498 */ 499 efi_save_gd(); 500 /* Transfer environment variable efi_selftest as load options */ 501 set_load_options(&loaded_image_info, "efi_selftest"); 502 /* Execute the test */ 503 r = efi_selftest(loaded_image_info_obj.handle, &systab); 504 efi_restore_gd(); 505 free(loaded_image_info.load_options); 506 list_del(&loaded_image_info_obj.link); 507 return r != EFI_SUCCESS; 508 } else 509 #endif 510 if (!strcmp(argv[1], "bootmgr")) { 511 return do_bootefi_bootmgr_exec(); 512 } else { 513 saddr = argv[1]; 514 515 addr = simple_strtoul(saddr, NULL, 16); 516 /* Check that a numeric value was passed */ 517 if (!addr && *saddr != '0') 518 return CMD_RET_USAGE; 519 520 } 521 522 printf("## Starting EFI application at %08lx ...\n", addr); 523 r = do_bootefi_exec(map_sysmem(addr, 0), bootefi_device_path, 524 bootefi_image_path); 525 printf("## Application terminated, r = %lu\n", 526 r & ~EFI_ERROR_MASK); 527 528 if (r != EFI_SUCCESS) 529 return 1; 530 else 531 return 0; 532 } 533 534 #ifdef CONFIG_SYS_LONGHELP 535 static char bootefi_help_text[] = 536 "<image address> [fdt address]\n" 537 " - boot EFI payload stored at address <image address>.\n" 538 " If specified, the device tree located at <fdt address> gets\n" 539 " exposed as EFI configuration table.\n" 540 #ifdef CONFIG_CMD_BOOTEFI_HELLO 541 "bootefi hello\n" 542 " - boot a sample Hello World application stored within U-Boot\n" 543 #endif 544 #ifdef CONFIG_CMD_BOOTEFI_SELFTEST 545 "bootefi selftest [fdt address]\n" 546 " - boot an EFI selftest application stored within U-Boot\n" 547 " Use environment variable efi_selftest to select a single test.\n" 548 " Use 'setenv efi_selftest list' to enumerate all tests.\n" 549 #endif 550 "bootefi bootmgr [fdt addr]\n" 551 " - load and boot EFI payload based on BootOrder/BootXXXX variables.\n" 552 "\n" 553 " If specified, the device tree located at <fdt address> gets\n" 554 " exposed as EFI configuration table.\n"; 555 #endif 556 557 U_BOOT_CMD( 558 bootefi, 3, 0, do_bootefi, 559 "Boots an EFI payload from memory", 560 bootefi_help_text 561 ); 562 563 void efi_set_bootdev(const char *dev, const char *devnr, const char *path) 564 { 565 char filename[32] = { 0 }; /* dp->str is u16[32] long */ 566 char *s; 567 568 if (strcmp(dev, "Net")) { 569 struct blk_desc *desc; 570 disk_partition_t fs_partition; 571 int part; 572 573 part = blk_get_device_part_str(dev, devnr, &desc, &fs_partition, 574 1); 575 if (part < 0) 576 return; 577 578 bootefi_device_path = efi_dp_from_part(desc, part); 579 } else { 580 #ifdef CONFIG_NET 581 bootefi_device_path = efi_dp_from_eth(); 582 #endif 583 } 584 585 if (!path) 586 return; 587 588 if (strcmp(dev, "Net")) { 589 /* Add leading / to fs paths, because they're absolute */ 590 snprintf(filename, sizeof(filename), "/%s", path); 591 } else { 592 snprintf(filename, sizeof(filename), "%s", path); 593 } 594 /* DOS style file path: */ 595 s = filename; 596 while ((s = strchr(s, '/'))) 597 *s++ = '\\'; 598 bootefi_image_path = efi_dp_from_file(NULL, 0, filename); 599 } 600