1 /* 2 * EFI application boot time services 3 * 4 * Copyright (c) 2016 Alexander Graf 5 * 6 * SPDX-License-Identifier: GPL-2.0+ 7 */ 8 9 #include <common.h> 10 #include <efi_loader.h> 11 #include <malloc.h> 12 #include <asm/global_data.h> 13 #include <libfdt_env.h> 14 #include <u-boot/crc.h> 15 #include <bootm.h> 16 #include <inttypes.h> 17 #include <watchdog.h> 18 19 DECLARE_GLOBAL_DATA_PTR; 20 21 /* This list contains all the EFI objects our payload has access to */ 22 LIST_HEAD(efi_obj_list); 23 24 /* 25 * If we're running on nasty systems (32bit ARM booting into non-EFI Linux) 26 * we need to do trickery with caches. Since we don't want to break the EFI 27 * aware boot path, only apply hacks when loading exiting directly (breaking 28 * direct Linux EFI booting along the way - oh well). 29 */ 30 static bool efi_is_direct_boot = true; 31 32 /* 33 * EFI can pass arbitrary additional "tables" containing vendor specific 34 * information to the payload. One such table is the FDT table which contains 35 * a pointer to a flattened device tree blob. 36 * 37 * In most cases we want to pass an FDT to the payload, so reserve one slot of 38 * config table space for it. The pointer gets populated by do_bootefi_exec(). 39 */ 40 static struct efi_configuration_table __efi_runtime_data efi_conf_table[2]; 41 42 #ifdef CONFIG_ARM 43 /* 44 * The "gd" pointer lives in a register on ARM and AArch64 that we declare 45 * fixed when compiling U-Boot. However, the payload does not know about that 46 * restriction so we need to manually swap its and our view of that register on 47 * EFI callback entry/exit. 48 */ 49 static volatile void *efi_gd, *app_gd; 50 #endif 51 52 /* Called from do_bootefi_exec() */ 53 void efi_save_gd(void) 54 { 55 #ifdef CONFIG_ARM 56 efi_gd = gd; 57 #endif 58 } 59 60 /* Called on every callback entry */ 61 void efi_restore_gd(void) 62 { 63 #ifdef CONFIG_ARM 64 /* Only restore if we're already in EFI context */ 65 if (!efi_gd) 66 return; 67 68 if (gd != efi_gd) 69 app_gd = gd; 70 gd = efi_gd; 71 #endif 72 } 73 74 /* Called on every callback exit */ 75 efi_status_t efi_exit_func(efi_status_t ret) 76 { 77 #ifdef CONFIG_ARM 78 gd = app_gd; 79 #endif 80 81 return ret; 82 } 83 84 /* Low 32 bit */ 85 #define EFI_LOW32(a) (a & 0xFFFFFFFFULL) 86 /* High 32 bit */ 87 #define EFI_HIGH32(a) (a >> 32) 88 89 /* 90 * 64bit division by 10 implemented as multiplication by 1 / 10 91 * 92 * Decimals of one tenth: 0x1 / 0xA = 0x0.19999... 93 */ 94 #define EFI_TENTH 0x199999999999999A 95 static u64 efi_div10(u64 a) 96 { 97 u64 prod; 98 u64 rem; 99 u64 ret; 100 101 ret = EFI_HIGH32(a) * EFI_HIGH32(EFI_TENTH); 102 prod = EFI_HIGH32(a) * EFI_LOW32(EFI_TENTH); 103 rem = EFI_LOW32(prod); 104 ret += EFI_HIGH32(prod); 105 prod = EFI_LOW32(a) * EFI_HIGH32(EFI_TENTH); 106 rem += EFI_LOW32(prod); 107 ret += EFI_HIGH32(prod); 108 prod = EFI_LOW32(a) * EFI_LOW32(EFI_TENTH); 109 rem += EFI_HIGH32(prod); 110 ret += EFI_HIGH32(rem); 111 /* Round to nearest integer */ 112 if (rem >= (1 << 31)) 113 ++ret; 114 return ret; 115 } 116 117 void efi_signal_event(struct efi_event *event) 118 { 119 if (event->signaled) 120 return; 121 event->signaled = 1; 122 if (event->type & EVT_NOTIFY_SIGNAL) { 123 EFI_EXIT(EFI_SUCCESS); 124 event->notify_function(event, event->notify_context); 125 EFI_ENTRY("returning from notification function"); 126 } 127 } 128 129 static efi_status_t efi_unsupported(const char *funcname) 130 { 131 debug("EFI: App called into unimplemented function %s\n", funcname); 132 return EFI_EXIT(EFI_UNSUPPORTED); 133 } 134 135 static unsigned long EFIAPI efi_raise_tpl(UINTN new_tpl) 136 { 137 EFI_ENTRY("0x%zx", new_tpl); 138 return EFI_EXIT(0); 139 } 140 141 static void EFIAPI efi_restore_tpl(UINTN old_tpl) 142 { 143 EFI_ENTRY("0x%zx", old_tpl); 144 EFI_EXIT(efi_unsupported(__func__)); 145 } 146 147 static efi_status_t EFIAPI efi_allocate_pages_ext(int type, int memory_type, 148 unsigned long pages, 149 uint64_t *memory) 150 { 151 efi_status_t r; 152 153 EFI_ENTRY("%d, %d, 0x%lx, %p", type, memory_type, pages, memory); 154 r = efi_allocate_pages(type, memory_type, pages, memory); 155 return EFI_EXIT(r); 156 } 157 158 static efi_status_t EFIAPI efi_free_pages_ext(uint64_t memory, 159 unsigned long pages) 160 { 161 efi_status_t r; 162 163 EFI_ENTRY("%"PRIx64", 0x%lx", memory, pages); 164 r = efi_free_pages(memory, pages); 165 return EFI_EXIT(r); 166 } 167 168 static efi_status_t EFIAPI efi_get_memory_map_ext( 169 unsigned long *memory_map_size, 170 struct efi_mem_desc *memory_map, 171 unsigned long *map_key, 172 unsigned long *descriptor_size, 173 uint32_t *descriptor_version) 174 { 175 efi_status_t r; 176 177 EFI_ENTRY("%p, %p, %p, %p, %p", memory_map_size, memory_map, 178 map_key, descriptor_size, descriptor_version); 179 r = efi_get_memory_map(memory_map_size, memory_map, map_key, 180 descriptor_size, descriptor_version); 181 return EFI_EXIT(r); 182 } 183 184 static efi_status_t EFIAPI efi_allocate_pool_ext(int pool_type, 185 unsigned long size, 186 void **buffer) 187 { 188 efi_status_t r; 189 190 EFI_ENTRY("%d, %ld, %p", pool_type, size, buffer); 191 r = efi_allocate_pool(pool_type, size, buffer); 192 return EFI_EXIT(r); 193 } 194 195 static efi_status_t EFIAPI efi_free_pool_ext(void *buffer) 196 { 197 efi_status_t r; 198 199 EFI_ENTRY("%p", buffer); 200 r = efi_free_pool(buffer); 201 return EFI_EXIT(r); 202 } 203 204 /* 205 * Our event capabilities are very limited. Only a small limited 206 * number of events is allowed to coexist. 207 */ 208 static struct efi_event efi_events[16]; 209 210 efi_status_t efi_create_event(enum efi_event_type type, UINTN notify_tpl, 211 void (EFIAPI *notify_function) ( 212 struct efi_event *event, 213 void *context), 214 void *notify_context, struct efi_event **event) 215 { 216 int i; 217 218 if (event == NULL) 219 return EFI_INVALID_PARAMETER; 220 221 if ((type & EVT_NOTIFY_SIGNAL) && (type & EVT_NOTIFY_WAIT)) 222 return EFI_INVALID_PARAMETER; 223 224 if ((type & (EVT_NOTIFY_SIGNAL|EVT_NOTIFY_WAIT)) && 225 notify_function == NULL) 226 return EFI_INVALID_PARAMETER; 227 228 for (i = 0; i < ARRAY_SIZE(efi_events); ++i) { 229 if (efi_events[i].type) 230 continue; 231 efi_events[i].type = type; 232 efi_events[i].notify_tpl = notify_tpl; 233 efi_events[i].notify_function = notify_function; 234 efi_events[i].notify_context = notify_context; 235 /* Disable timers on bootup */ 236 efi_events[i].trigger_next = -1ULL; 237 efi_events[i].signaled = 0; 238 *event = &efi_events[i]; 239 return EFI_SUCCESS; 240 } 241 return EFI_OUT_OF_RESOURCES; 242 } 243 244 static efi_status_t EFIAPI efi_create_event_ext( 245 enum efi_event_type type, UINTN notify_tpl, 246 void (EFIAPI *notify_function) ( 247 struct efi_event *event, 248 void *context), 249 void *notify_context, struct efi_event **event) 250 { 251 EFI_ENTRY("%d, 0x%zx, %p, %p", type, notify_tpl, notify_function, 252 notify_context); 253 return EFI_EXIT(efi_create_event(type, notify_tpl, notify_function, 254 notify_context, event)); 255 } 256 257 258 /* 259 * Our timers have to work without interrupts, so we check whenever keyboard 260 * input or disk accesses happen if enough time elapsed for it to fire. 261 */ 262 void efi_timer_check(void) 263 { 264 int i; 265 u64 now = timer_get_us(); 266 267 for (i = 0; i < ARRAY_SIZE(efi_events); ++i) { 268 if (!efi_events[i].type || 269 !(efi_events[i].type & EVT_TIMER) || 270 efi_events[i].trigger_type == EFI_TIMER_STOP || 271 now < efi_events[i].trigger_next) 272 continue; 273 if (efi_events[i].trigger_type == EFI_TIMER_PERIODIC) { 274 efi_events[i].trigger_next += 275 efi_events[i].trigger_time; 276 efi_events[i].signaled = 0; 277 } 278 efi_signal_event(&efi_events[i]); 279 } 280 WATCHDOG_RESET(); 281 } 282 283 efi_status_t efi_set_timer(struct efi_event *event, int type, 284 uint64_t trigger_time) 285 { 286 int i; 287 288 /* 289 * The parameter defines a multiple of 100ns. 290 * We use multiples of 1000ns. So divide by 10. 291 */ 292 trigger_time = efi_div10(trigger_time); 293 294 for (i = 0; i < ARRAY_SIZE(efi_events); ++i) { 295 if (event != &efi_events[i]) 296 continue; 297 298 if (!(event->type & EVT_TIMER)) 299 break; 300 switch (type) { 301 case EFI_TIMER_STOP: 302 event->trigger_next = -1ULL; 303 break; 304 case EFI_TIMER_PERIODIC: 305 case EFI_TIMER_RELATIVE: 306 event->trigger_next = 307 timer_get_us() + trigger_time; 308 break; 309 default: 310 return EFI_INVALID_PARAMETER; 311 } 312 event->trigger_type = type; 313 event->trigger_time = trigger_time; 314 return EFI_SUCCESS; 315 } 316 return EFI_INVALID_PARAMETER; 317 } 318 319 static efi_status_t EFIAPI efi_set_timer_ext(struct efi_event *event, int type, 320 uint64_t trigger_time) 321 { 322 EFI_ENTRY("%p, %d, %"PRIx64, event, type, trigger_time); 323 return EFI_EXIT(efi_set_timer(event, type, trigger_time)); 324 } 325 326 static efi_status_t EFIAPI efi_wait_for_event(unsigned long num_events, 327 struct efi_event **event, 328 unsigned long *index) 329 { 330 int i, j; 331 332 EFI_ENTRY("%ld, %p, %p", num_events, event, index); 333 334 /* Check parameters */ 335 if (!num_events || !event) 336 return EFI_EXIT(EFI_INVALID_PARAMETER); 337 for (i = 0; i < num_events; ++i) { 338 for (j = 0; j < ARRAY_SIZE(efi_events); ++j) { 339 if (event[i] == &efi_events[j]) 340 goto known_event; 341 } 342 return EFI_EXIT(EFI_INVALID_PARAMETER); 343 known_event: 344 if (!event[i]->type || event[i]->type & EVT_NOTIFY_SIGNAL) 345 return EFI_EXIT(EFI_INVALID_PARAMETER); 346 } 347 348 /* Wait for signal */ 349 for (;;) { 350 for (i = 0; i < num_events; ++i) { 351 if (event[i]->signaled) 352 goto out; 353 } 354 /* Allow events to occur. */ 355 efi_timer_check(); 356 } 357 358 out: 359 /* 360 * Reset the signal which is passed to the caller to allow periodic 361 * events to occur. 362 */ 363 event[i]->signaled = 0; 364 if (index) 365 *index = i; 366 367 return EFI_EXIT(EFI_SUCCESS); 368 } 369 370 static efi_status_t EFIAPI efi_signal_event_ext(struct efi_event *event) 371 { 372 int i; 373 374 EFI_ENTRY("%p", event); 375 for (i = 0; i < ARRAY_SIZE(efi_events); ++i) { 376 if (event != &efi_events[i]) 377 continue; 378 efi_signal_event(event); 379 break; 380 } 381 return EFI_EXIT(EFI_SUCCESS); 382 } 383 384 static efi_status_t EFIAPI efi_close_event(struct efi_event *event) 385 { 386 int i; 387 388 EFI_ENTRY("%p", event); 389 for (i = 0; i < ARRAY_SIZE(efi_events); ++i) { 390 if (event == &efi_events[i]) { 391 event->type = 0; 392 event->trigger_next = -1ULL; 393 event->signaled = 0; 394 return EFI_EXIT(EFI_SUCCESS); 395 } 396 } 397 return EFI_EXIT(EFI_INVALID_PARAMETER); 398 } 399 400 static efi_status_t EFIAPI efi_check_event(struct efi_event *event) 401 { 402 int i; 403 404 EFI_ENTRY("%p", event); 405 efi_timer_check(); 406 for (i = 0; i < ARRAY_SIZE(efi_events); ++i) { 407 if (event != &efi_events[i]) 408 continue; 409 if (!event->type || event->type & EVT_NOTIFY_SIGNAL) 410 break; 411 if (event->signaled) 412 return EFI_EXIT(EFI_SUCCESS); 413 return EFI_EXIT(EFI_NOT_READY); 414 } 415 return EFI_EXIT(EFI_INVALID_PARAMETER); 416 } 417 418 static efi_status_t EFIAPI efi_install_protocol_interface(void **handle, 419 efi_guid_t *protocol, int protocol_interface_type, 420 void *protocol_interface) 421 { 422 struct list_head *lhandle; 423 int i; 424 efi_status_t r; 425 426 if (!handle || !protocol || 427 protocol_interface_type != EFI_NATIVE_INTERFACE) { 428 r = EFI_INVALID_PARAMETER; 429 goto out; 430 } 431 432 /* Create new handle if requested. */ 433 if (!*handle) { 434 r = EFI_OUT_OF_RESOURCES; 435 goto out; 436 } 437 /* Find object. */ 438 list_for_each(lhandle, &efi_obj_list) { 439 struct efi_object *efiobj; 440 efiobj = list_entry(lhandle, struct efi_object, link); 441 442 if (efiobj->handle != *handle) 443 continue; 444 /* Check if protocol is already installed on the handle. */ 445 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 446 struct efi_handler *handler = &efiobj->protocols[i]; 447 448 if (!handler->guid) 449 continue; 450 if (!guidcmp(handler->guid, protocol)) { 451 r = EFI_INVALID_PARAMETER; 452 goto out; 453 } 454 } 455 /* Install protocol in first empty slot. */ 456 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 457 struct efi_handler *handler = &efiobj->protocols[i]; 458 459 if (handler->guid) 460 continue; 461 462 handler->guid = protocol; 463 handler->protocol_interface = protocol_interface; 464 r = EFI_SUCCESS; 465 goto out; 466 } 467 r = EFI_OUT_OF_RESOURCES; 468 goto out; 469 } 470 r = EFI_INVALID_PARAMETER; 471 out: 472 return r; 473 } 474 475 static efi_status_t EFIAPI efi_install_protocol_interface_ext(void **handle, 476 efi_guid_t *protocol, int protocol_interface_type, 477 void *protocol_interface) 478 { 479 EFI_ENTRY("%p, %p, %d, %p", handle, protocol, protocol_interface_type, 480 protocol_interface); 481 482 return EFI_EXIT(efi_install_protocol_interface(handle, protocol, 483 protocol_interface_type, 484 protocol_interface)); 485 } 486 487 static efi_status_t EFIAPI efi_reinstall_protocol_interface(void *handle, 488 efi_guid_t *protocol, void *old_interface, 489 void *new_interface) 490 { 491 EFI_ENTRY("%p, %p, %p, %p", handle, protocol, old_interface, 492 new_interface); 493 return EFI_EXIT(EFI_ACCESS_DENIED); 494 } 495 496 static efi_status_t EFIAPI efi_uninstall_protocol_interface(void *handle, 497 efi_guid_t *protocol, void *protocol_interface) 498 { 499 struct list_head *lhandle; 500 int i; 501 efi_status_t r = EFI_NOT_FOUND; 502 503 if (!handle || !protocol) { 504 r = EFI_INVALID_PARAMETER; 505 goto out; 506 } 507 508 list_for_each(lhandle, &efi_obj_list) { 509 struct efi_object *efiobj; 510 efiobj = list_entry(lhandle, struct efi_object, link); 511 512 if (efiobj->handle != handle) 513 continue; 514 515 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 516 struct efi_handler *handler = &efiobj->protocols[i]; 517 const efi_guid_t *hprotocol = handler->guid; 518 519 if (!hprotocol) 520 continue; 521 if (!guidcmp(hprotocol, protocol)) { 522 if (handler->protocol_interface) { 523 r = EFI_ACCESS_DENIED; 524 } else { 525 handler->guid = 0; 526 r = EFI_SUCCESS; 527 } 528 goto out; 529 } 530 } 531 } 532 533 out: 534 return r; 535 } 536 537 static efi_status_t EFIAPI efi_uninstall_protocol_interface_ext(void *handle, 538 efi_guid_t *protocol, void *protocol_interface) 539 { 540 EFI_ENTRY("%p, %p, %p", handle, protocol, protocol_interface); 541 542 return EFI_EXIT(efi_uninstall_protocol_interface(handle, protocol, 543 protocol_interface)); 544 } 545 546 static efi_status_t EFIAPI efi_register_protocol_notify(efi_guid_t *protocol, 547 struct efi_event *event, 548 void **registration) 549 { 550 EFI_ENTRY("%p, %p, %p", protocol, event, registration); 551 return EFI_EXIT(EFI_OUT_OF_RESOURCES); 552 } 553 554 static int efi_search(enum efi_locate_search_type search_type, 555 efi_guid_t *protocol, void *search_key, 556 struct efi_object *efiobj) 557 { 558 int i; 559 560 switch (search_type) { 561 case all_handles: 562 return 0; 563 case by_register_notify: 564 return -1; 565 case by_protocol: 566 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 567 const efi_guid_t *guid = efiobj->protocols[i].guid; 568 if (guid && !guidcmp(guid, protocol)) 569 return 0; 570 } 571 return -1; 572 } 573 574 return -1; 575 } 576 577 static efi_status_t EFIAPI efi_locate_handle( 578 enum efi_locate_search_type search_type, 579 efi_guid_t *protocol, void *search_key, 580 unsigned long *buffer_size, efi_handle_t *buffer) 581 { 582 struct list_head *lhandle; 583 unsigned long size = 0; 584 585 /* Count how much space we need */ 586 list_for_each(lhandle, &efi_obj_list) { 587 struct efi_object *efiobj; 588 efiobj = list_entry(lhandle, struct efi_object, link); 589 if (!efi_search(search_type, protocol, search_key, efiobj)) { 590 size += sizeof(void*); 591 } 592 } 593 594 if (*buffer_size < size) { 595 *buffer_size = size; 596 return EFI_BUFFER_TOO_SMALL; 597 } 598 599 /* Then fill the array */ 600 list_for_each(lhandle, &efi_obj_list) { 601 struct efi_object *efiobj; 602 efiobj = list_entry(lhandle, struct efi_object, link); 603 if (!efi_search(search_type, protocol, search_key, efiobj)) { 604 *(buffer++) = efiobj->handle; 605 } 606 } 607 608 *buffer_size = size; 609 return EFI_SUCCESS; 610 } 611 612 static efi_status_t EFIAPI efi_locate_handle_ext( 613 enum efi_locate_search_type search_type, 614 efi_guid_t *protocol, void *search_key, 615 unsigned long *buffer_size, efi_handle_t *buffer) 616 { 617 EFI_ENTRY("%d, %p, %p, %p, %p", search_type, protocol, search_key, 618 buffer_size, buffer); 619 620 return EFI_EXIT(efi_locate_handle(search_type, protocol, search_key, 621 buffer_size, buffer)); 622 } 623 624 static efi_status_t EFIAPI efi_locate_device_path(efi_guid_t *protocol, 625 struct efi_device_path **device_path, 626 efi_handle_t *device) 627 { 628 EFI_ENTRY("%p, %p, %p", protocol, device_path, device); 629 return EFI_EXIT(EFI_NOT_FOUND); 630 } 631 632 efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table) 633 { 634 int i; 635 636 /* Check for guid override */ 637 for (i = 0; i < systab.nr_tables; i++) { 638 if (!guidcmp(guid, &efi_conf_table[i].guid)) { 639 efi_conf_table[i].table = table; 640 return EFI_SUCCESS; 641 } 642 } 643 644 /* No override, check for overflow */ 645 if (i >= ARRAY_SIZE(efi_conf_table)) 646 return EFI_OUT_OF_RESOURCES; 647 648 /* Add a new entry */ 649 memcpy(&efi_conf_table[i].guid, guid, sizeof(*guid)); 650 efi_conf_table[i].table = table; 651 systab.nr_tables = i + 1; 652 653 return EFI_SUCCESS; 654 } 655 656 static efi_status_t EFIAPI efi_install_configuration_table_ext(efi_guid_t *guid, 657 void *table) 658 { 659 EFI_ENTRY("%p, %p", guid, table); 660 return EFI_EXIT(efi_install_configuration_table(guid, table)); 661 } 662 663 static efi_status_t EFIAPI efi_load_image(bool boot_policy, 664 efi_handle_t parent_image, 665 struct efi_device_path *file_path, 666 void *source_buffer, 667 unsigned long source_size, 668 efi_handle_t *image_handle) 669 { 670 static struct efi_object loaded_image_info_obj = { 671 .protocols = { 672 { 673 .guid = &efi_guid_loaded_image, 674 }, 675 }, 676 }; 677 struct efi_loaded_image *info; 678 struct efi_object *obj; 679 680 EFI_ENTRY("%d, %p, %p, %p, %ld, %p", boot_policy, parent_image, 681 file_path, source_buffer, source_size, image_handle); 682 info = malloc(sizeof(*info)); 683 loaded_image_info_obj.protocols[0].protocol_interface = info; 684 obj = malloc(sizeof(loaded_image_info_obj)); 685 memset(info, 0, sizeof(*info)); 686 memcpy(obj, &loaded_image_info_obj, sizeof(loaded_image_info_obj)); 687 obj->handle = info; 688 info->file_path = file_path; 689 info->reserved = efi_load_pe(source_buffer, info); 690 if (!info->reserved) { 691 free(info); 692 free(obj); 693 return EFI_EXIT(EFI_UNSUPPORTED); 694 } 695 696 *image_handle = info; 697 list_add_tail(&obj->link, &efi_obj_list); 698 699 return EFI_EXIT(EFI_SUCCESS); 700 } 701 702 static efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle, 703 unsigned long *exit_data_size, 704 s16 **exit_data) 705 { 706 ulong (*entry)(void *image_handle, struct efi_system_table *st); 707 struct efi_loaded_image *info = image_handle; 708 709 EFI_ENTRY("%p, %p, %p", image_handle, exit_data_size, exit_data); 710 entry = info->reserved; 711 712 efi_is_direct_boot = false; 713 714 /* call the image! */ 715 if (setjmp(&info->exit_jmp)) { 716 /* We returned from the child image */ 717 return EFI_EXIT(info->exit_status); 718 } 719 720 entry(image_handle, &systab); 721 722 /* Should usually never get here */ 723 return EFI_EXIT(EFI_SUCCESS); 724 } 725 726 static efi_status_t EFIAPI efi_exit(efi_handle_t image_handle, 727 efi_status_t exit_status, unsigned long exit_data_size, 728 int16_t *exit_data) 729 { 730 struct efi_loaded_image *loaded_image_info = (void*)image_handle; 731 732 EFI_ENTRY("%p, %ld, %ld, %p", image_handle, exit_status, 733 exit_data_size, exit_data); 734 735 loaded_image_info->exit_status = exit_status; 736 longjmp(&loaded_image_info->exit_jmp, 1); 737 738 panic("EFI application exited"); 739 } 740 741 static struct efi_object *efi_search_obj(void *handle) 742 { 743 struct list_head *lhandle; 744 745 list_for_each(lhandle, &efi_obj_list) { 746 struct efi_object *efiobj; 747 efiobj = list_entry(lhandle, struct efi_object, link); 748 if (efiobj->handle == handle) 749 return efiobj; 750 } 751 752 return NULL; 753 } 754 755 static efi_status_t EFIAPI efi_unload_image(void *image_handle) 756 { 757 struct efi_object *efiobj; 758 759 EFI_ENTRY("%p", image_handle); 760 efiobj = efi_search_obj(image_handle); 761 if (efiobj) 762 list_del(&efiobj->link); 763 764 return EFI_EXIT(EFI_SUCCESS); 765 } 766 767 static void efi_exit_caches(void) 768 { 769 #if defined(CONFIG_ARM) && !defined(CONFIG_ARM64) 770 /* 771 * Grub on 32bit ARM needs to have caches disabled before jumping into 772 * a zImage, but does not know of all cache layers. Give it a hand. 773 */ 774 if (efi_is_direct_boot) 775 cleanup_before_linux(); 776 #endif 777 } 778 779 static efi_status_t EFIAPI efi_exit_boot_services(void *image_handle, 780 unsigned long map_key) 781 { 782 EFI_ENTRY("%p, %ld", image_handle, map_key); 783 784 board_quiesce_devices(); 785 786 /* Fix up caches for EFI payloads if necessary */ 787 efi_exit_caches(); 788 789 /* This stops all lingering devices */ 790 bootm_disable_interrupts(); 791 792 /* Give the payload some time to boot */ 793 WATCHDOG_RESET(); 794 795 return EFI_EXIT(EFI_SUCCESS); 796 } 797 798 static efi_status_t EFIAPI efi_get_next_monotonic_count(uint64_t *count) 799 { 800 static uint64_t mono = 0; 801 EFI_ENTRY("%p", count); 802 *count = mono++; 803 return EFI_EXIT(EFI_SUCCESS); 804 } 805 806 static efi_status_t EFIAPI efi_stall(unsigned long microseconds) 807 { 808 EFI_ENTRY("%ld", microseconds); 809 udelay(microseconds); 810 return EFI_EXIT(EFI_SUCCESS); 811 } 812 813 static efi_status_t EFIAPI efi_set_watchdog_timer(unsigned long timeout, 814 uint64_t watchdog_code, 815 unsigned long data_size, 816 uint16_t *watchdog_data) 817 { 818 EFI_ENTRY("%ld, 0x%"PRIx64", %ld, %p", timeout, watchdog_code, 819 data_size, watchdog_data); 820 return EFI_EXIT(efi_unsupported(__func__)); 821 } 822 823 static efi_status_t EFIAPI efi_connect_controller( 824 efi_handle_t controller_handle, 825 efi_handle_t *driver_image_handle, 826 struct efi_device_path *remain_device_path, 827 bool recursive) 828 { 829 EFI_ENTRY("%p, %p, %p, %d", controller_handle, driver_image_handle, 830 remain_device_path, recursive); 831 return EFI_EXIT(EFI_NOT_FOUND); 832 } 833 834 static efi_status_t EFIAPI efi_disconnect_controller(void *controller_handle, 835 void *driver_image_handle, 836 void *child_handle) 837 { 838 EFI_ENTRY("%p, %p, %p", controller_handle, driver_image_handle, 839 child_handle); 840 return EFI_EXIT(EFI_INVALID_PARAMETER); 841 } 842 843 static efi_status_t EFIAPI efi_close_protocol(void *handle, 844 efi_guid_t *protocol, 845 void *agent_handle, 846 void *controller_handle) 847 { 848 EFI_ENTRY("%p, %p, %p, %p", handle, protocol, agent_handle, 849 controller_handle); 850 return EFI_EXIT(EFI_NOT_FOUND); 851 } 852 853 static efi_status_t EFIAPI efi_open_protocol_information(efi_handle_t handle, 854 efi_guid_t *protocol, 855 struct efi_open_protocol_info_entry **entry_buffer, 856 unsigned long *entry_count) 857 { 858 EFI_ENTRY("%p, %p, %p, %p", handle, protocol, entry_buffer, 859 entry_count); 860 return EFI_EXIT(EFI_NOT_FOUND); 861 } 862 863 static efi_status_t EFIAPI efi_protocols_per_handle(void *handle, 864 efi_guid_t ***protocol_buffer, 865 unsigned long *protocol_buffer_count) 866 { 867 EFI_ENTRY("%p, %p, %p", handle, protocol_buffer, 868 protocol_buffer_count); 869 return EFI_EXIT(EFI_OUT_OF_RESOURCES); 870 } 871 872 static efi_status_t EFIAPI efi_locate_handle_buffer( 873 enum efi_locate_search_type search_type, 874 efi_guid_t *protocol, void *search_key, 875 unsigned long *no_handles, efi_handle_t **buffer) 876 { 877 efi_status_t r; 878 unsigned long buffer_size = 0; 879 880 EFI_ENTRY("%d, %p, %p, %p, %p", search_type, protocol, search_key, 881 no_handles, buffer); 882 883 if (!no_handles || !buffer) { 884 r = EFI_INVALID_PARAMETER; 885 goto out; 886 } 887 *no_handles = 0; 888 *buffer = NULL; 889 r = efi_locate_handle(search_type, protocol, search_key, &buffer_size, 890 *buffer); 891 if (r != EFI_BUFFER_TOO_SMALL) 892 goto out; 893 r = efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES, buffer_size, 894 (void **)buffer); 895 if (r != EFI_SUCCESS) 896 goto out; 897 r = efi_locate_handle(search_type, protocol, search_key, &buffer_size, 898 *buffer); 899 if (r == EFI_SUCCESS) 900 *no_handles = buffer_size / sizeof(void *); 901 out: 902 return EFI_EXIT(r); 903 } 904 905 static efi_status_t EFIAPI efi_locate_protocol(efi_guid_t *protocol, 906 void *registration, 907 void **protocol_interface) 908 { 909 struct list_head *lhandle; 910 int i; 911 912 EFI_ENTRY("%p, %p, %p", protocol, registration, protocol_interface); 913 914 if (!protocol || !protocol_interface) 915 return EFI_EXIT(EFI_INVALID_PARAMETER); 916 917 list_for_each(lhandle, &efi_obj_list) { 918 struct efi_object *efiobj; 919 920 efiobj = list_entry(lhandle, struct efi_object, link); 921 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 922 struct efi_handler *handler = &efiobj->protocols[i]; 923 924 if (!handler->guid) 925 continue; 926 if (!guidcmp(handler->guid, protocol)) { 927 *protocol_interface = 928 handler->protocol_interface; 929 return EFI_EXIT(EFI_SUCCESS); 930 } 931 } 932 } 933 *protocol_interface = NULL; 934 935 return EFI_EXIT(EFI_NOT_FOUND); 936 } 937 938 static efi_status_t EFIAPI efi_install_multiple_protocol_interfaces( 939 void **handle, ...) 940 { 941 EFI_ENTRY("%p", handle); 942 943 va_list argptr; 944 efi_guid_t *protocol; 945 void *protocol_interface; 946 efi_status_t r = EFI_SUCCESS; 947 int i = 0; 948 949 if (!handle) 950 return EFI_EXIT(EFI_INVALID_PARAMETER); 951 952 va_start(argptr, handle); 953 for (;;) { 954 protocol = va_arg(argptr, efi_guid_t*); 955 if (!protocol) 956 break; 957 protocol_interface = va_arg(argptr, void*); 958 r = efi_install_protocol_interface(handle, protocol, 959 EFI_NATIVE_INTERFACE, 960 protocol_interface); 961 if (r != EFI_SUCCESS) 962 break; 963 i++; 964 } 965 va_end(argptr); 966 if (r == EFI_SUCCESS) 967 return EFI_EXIT(r); 968 969 /* If an error occured undo all changes. */ 970 va_start(argptr, handle); 971 for (; i; --i) { 972 protocol = va_arg(argptr, efi_guid_t*); 973 protocol_interface = va_arg(argptr, void*); 974 efi_uninstall_protocol_interface(handle, protocol, 975 protocol_interface); 976 } 977 va_end(argptr); 978 979 return EFI_EXIT(r); 980 } 981 982 static efi_status_t EFIAPI efi_uninstall_multiple_protocol_interfaces( 983 void *handle, ...) 984 { 985 EFI_ENTRY("%p", handle); 986 return EFI_EXIT(EFI_INVALID_PARAMETER); 987 } 988 989 static efi_status_t EFIAPI efi_calculate_crc32(void *data, 990 unsigned long data_size, 991 uint32_t *crc32_p) 992 { 993 EFI_ENTRY("%p, %ld", data, data_size); 994 *crc32_p = crc32(0, data, data_size); 995 return EFI_EXIT(EFI_SUCCESS); 996 } 997 998 static void EFIAPI efi_copy_mem(void *destination, void *source, 999 unsigned long length) 1000 { 1001 EFI_ENTRY("%p, %p, %ld", destination, source, length); 1002 memcpy(destination, source, length); 1003 } 1004 1005 static void EFIAPI efi_set_mem(void *buffer, unsigned long size, uint8_t value) 1006 { 1007 EFI_ENTRY("%p, %ld, 0x%x", buffer, size, value); 1008 memset(buffer, value, size); 1009 } 1010 1011 static efi_status_t EFIAPI efi_open_protocol( 1012 void *handle, efi_guid_t *protocol, 1013 void **protocol_interface, void *agent_handle, 1014 void *controller_handle, uint32_t attributes) 1015 { 1016 struct list_head *lhandle; 1017 int i; 1018 efi_status_t r = EFI_INVALID_PARAMETER; 1019 1020 EFI_ENTRY("%p, %p, %p, %p, %p, 0x%x", handle, protocol, 1021 protocol_interface, agent_handle, controller_handle, 1022 attributes); 1023 1024 if (!handle || !protocol || 1025 (!protocol_interface && attributes != 1026 EFI_OPEN_PROTOCOL_TEST_PROTOCOL)) { 1027 goto out; 1028 } 1029 1030 switch (attributes) { 1031 case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL: 1032 case EFI_OPEN_PROTOCOL_GET_PROTOCOL: 1033 case EFI_OPEN_PROTOCOL_TEST_PROTOCOL: 1034 break; 1035 case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER: 1036 if (controller_handle == handle) 1037 goto out; 1038 case EFI_OPEN_PROTOCOL_BY_DRIVER: 1039 case EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE: 1040 if (controller_handle == NULL) 1041 goto out; 1042 case EFI_OPEN_PROTOCOL_EXCLUSIVE: 1043 if (agent_handle == NULL) 1044 goto out; 1045 break; 1046 default: 1047 goto out; 1048 } 1049 1050 list_for_each(lhandle, &efi_obj_list) { 1051 struct efi_object *efiobj; 1052 efiobj = list_entry(lhandle, struct efi_object, link); 1053 1054 if (efiobj->handle != handle) 1055 continue; 1056 1057 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 1058 struct efi_handler *handler = &efiobj->protocols[i]; 1059 const efi_guid_t *hprotocol = handler->guid; 1060 if (!hprotocol) 1061 continue; 1062 if (!guidcmp(hprotocol, protocol)) { 1063 if (attributes != 1064 EFI_OPEN_PROTOCOL_TEST_PROTOCOL) { 1065 *protocol_interface = 1066 handler->protocol_interface; 1067 } 1068 r = EFI_SUCCESS; 1069 goto out; 1070 } 1071 } 1072 goto unsupported; 1073 } 1074 1075 unsupported: 1076 r = EFI_UNSUPPORTED; 1077 out: 1078 return EFI_EXIT(r); 1079 } 1080 1081 static efi_status_t EFIAPI efi_handle_protocol(void *handle, 1082 efi_guid_t *protocol, 1083 void **protocol_interface) 1084 { 1085 return efi_open_protocol(handle, protocol, protocol_interface, NULL, 1086 NULL, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL); 1087 } 1088 1089 static const struct efi_boot_services efi_boot_services = { 1090 .hdr = { 1091 .headersize = sizeof(struct efi_table_hdr), 1092 }, 1093 .raise_tpl = efi_raise_tpl, 1094 .restore_tpl = efi_restore_tpl, 1095 .allocate_pages = efi_allocate_pages_ext, 1096 .free_pages = efi_free_pages_ext, 1097 .get_memory_map = efi_get_memory_map_ext, 1098 .allocate_pool = efi_allocate_pool_ext, 1099 .free_pool = efi_free_pool_ext, 1100 .create_event = efi_create_event_ext, 1101 .set_timer = efi_set_timer_ext, 1102 .wait_for_event = efi_wait_for_event, 1103 .signal_event = efi_signal_event_ext, 1104 .close_event = efi_close_event, 1105 .check_event = efi_check_event, 1106 .install_protocol_interface = efi_install_protocol_interface_ext, 1107 .reinstall_protocol_interface = efi_reinstall_protocol_interface, 1108 .uninstall_protocol_interface = efi_uninstall_protocol_interface_ext, 1109 .handle_protocol = efi_handle_protocol, 1110 .reserved = NULL, 1111 .register_protocol_notify = efi_register_protocol_notify, 1112 .locate_handle = efi_locate_handle_ext, 1113 .locate_device_path = efi_locate_device_path, 1114 .install_configuration_table = efi_install_configuration_table_ext, 1115 .load_image = efi_load_image, 1116 .start_image = efi_start_image, 1117 .exit = efi_exit, 1118 .unload_image = efi_unload_image, 1119 .exit_boot_services = efi_exit_boot_services, 1120 .get_next_monotonic_count = efi_get_next_monotonic_count, 1121 .stall = efi_stall, 1122 .set_watchdog_timer = efi_set_watchdog_timer, 1123 .connect_controller = efi_connect_controller, 1124 .disconnect_controller = efi_disconnect_controller, 1125 .open_protocol = efi_open_protocol, 1126 .close_protocol = efi_close_protocol, 1127 .open_protocol_information = efi_open_protocol_information, 1128 .protocols_per_handle = efi_protocols_per_handle, 1129 .locate_handle_buffer = efi_locate_handle_buffer, 1130 .locate_protocol = efi_locate_protocol, 1131 .install_multiple_protocol_interfaces = efi_install_multiple_protocol_interfaces, 1132 .uninstall_multiple_protocol_interfaces = efi_uninstall_multiple_protocol_interfaces, 1133 .calculate_crc32 = efi_calculate_crc32, 1134 .copy_mem = efi_copy_mem, 1135 .set_mem = efi_set_mem, 1136 }; 1137 1138 1139 static uint16_t __efi_runtime_data firmware_vendor[] = 1140 { 'D','a','s',' ','U','-','b','o','o','t',0 }; 1141 1142 struct efi_system_table __efi_runtime_data systab = { 1143 .hdr = { 1144 .signature = EFI_SYSTEM_TABLE_SIGNATURE, 1145 .revision = 0x20005, /* 2.5 */ 1146 .headersize = sizeof(struct efi_table_hdr), 1147 }, 1148 .fw_vendor = (long)firmware_vendor, 1149 .con_in = (void*)&efi_con_in, 1150 .con_out = (void*)&efi_con_out, 1151 .std_err = (void*)&efi_con_out, 1152 .runtime = (void*)&efi_runtime_services, 1153 .boottime = (void*)&efi_boot_services, 1154 .nr_tables = 0, 1155 .tables = (void*)efi_conf_table, 1156 }; 1157