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(uint32_t 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 uint32_t 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, enum efi_timer_delay 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, 320 enum efi_timer_delay type, 321 uint64_t trigger_time) 322 { 323 EFI_ENTRY("%p, %d, %"PRIx64, event, type, trigger_time); 324 return EFI_EXIT(efi_set_timer(event, type, trigger_time)); 325 } 326 327 static efi_status_t EFIAPI efi_wait_for_event(unsigned long num_events, 328 struct efi_event **event, 329 unsigned long *index) 330 { 331 int i, j; 332 333 EFI_ENTRY("%ld, %p, %p", num_events, event, index); 334 335 /* Check parameters */ 336 if (!num_events || !event) 337 return EFI_EXIT(EFI_INVALID_PARAMETER); 338 for (i = 0; i < num_events; ++i) { 339 for (j = 0; j < ARRAY_SIZE(efi_events); ++j) { 340 if (event[i] == &efi_events[j]) 341 goto known_event; 342 } 343 return EFI_EXIT(EFI_INVALID_PARAMETER); 344 known_event: 345 if (!event[i]->type || event[i]->type & EVT_NOTIFY_SIGNAL) 346 return EFI_EXIT(EFI_INVALID_PARAMETER); 347 } 348 349 /* Wait for signal */ 350 for (;;) { 351 for (i = 0; i < num_events; ++i) { 352 if (event[i]->signaled) 353 goto out; 354 } 355 /* Allow events to occur. */ 356 efi_timer_check(); 357 } 358 359 out: 360 /* 361 * Reset the signal which is passed to the caller to allow periodic 362 * events to occur. 363 */ 364 event[i]->signaled = 0; 365 if (index) 366 *index = i; 367 368 return EFI_EXIT(EFI_SUCCESS); 369 } 370 371 static efi_status_t EFIAPI efi_signal_event_ext(struct efi_event *event) 372 { 373 int i; 374 375 EFI_ENTRY("%p", event); 376 for (i = 0; i < ARRAY_SIZE(efi_events); ++i) { 377 if (event != &efi_events[i]) 378 continue; 379 efi_signal_event(event); 380 break; 381 } 382 return EFI_EXIT(EFI_SUCCESS); 383 } 384 385 static efi_status_t EFIAPI efi_close_event(struct efi_event *event) 386 { 387 int i; 388 389 EFI_ENTRY("%p", event); 390 for (i = 0; i < ARRAY_SIZE(efi_events); ++i) { 391 if (event == &efi_events[i]) { 392 event->type = 0; 393 event->trigger_next = -1ULL; 394 event->signaled = 0; 395 return EFI_EXIT(EFI_SUCCESS); 396 } 397 } 398 return EFI_EXIT(EFI_INVALID_PARAMETER); 399 } 400 401 static efi_status_t EFIAPI efi_check_event(struct efi_event *event) 402 { 403 int i; 404 405 EFI_ENTRY("%p", event); 406 efi_timer_check(); 407 for (i = 0; i < ARRAY_SIZE(efi_events); ++i) { 408 if (event != &efi_events[i]) 409 continue; 410 if (!event->type || event->type & EVT_NOTIFY_SIGNAL) 411 break; 412 if (event->signaled) 413 return EFI_EXIT(EFI_SUCCESS); 414 return EFI_EXIT(EFI_NOT_READY); 415 } 416 return EFI_EXIT(EFI_INVALID_PARAMETER); 417 } 418 419 static efi_status_t EFIAPI efi_install_protocol_interface(void **handle, 420 efi_guid_t *protocol, int protocol_interface_type, 421 void *protocol_interface) 422 { 423 struct list_head *lhandle; 424 int i; 425 efi_status_t r; 426 427 if (!handle || !protocol || 428 protocol_interface_type != EFI_NATIVE_INTERFACE) { 429 r = EFI_INVALID_PARAMETER; 430 goto out; 431 } 432 433 /* Create new handle if requested. */ 434 if (!*handle) { 435 r = EFI_OUT_OF_RESOURCES; 436 goto out; 437 } 438 /* Find object. */ 439 list_for_each(lhandle, &efi_obj_list) { 440 struct efi_object *efiobj; 441 efiobj = list_entry(lhandle, struct efi_object, link); 442 443 if (efiobj->handle != *handle) 444 continue; 445 /* Check if protocol is already installed on the handle. */ 446 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 447 struct efi_handler *handler = &efiobj->protocols[i]; 448 449 if (!handler->guid) 450 continue; 451 if (!guidcmp(handler->guid, protocol)) { 452 r = EFI_INVALID_PARAMETER; 453 goto out; 454 } 455 } 456 /* Install protocol in first empty slot. */ 457 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 458 struct efi_handler *handler = &efiobj->protocols[i]; 459 460 if (handler->guid) 461 continue; 462 463 handler->guid = protocol; 464 handler->protocol_interface = protocol_interface; 465 r = EFI_SUCCESS; 466 goto out; 467 } 468 r = EFI_OUT_OF_RESOURCES; 469 goto out; 470 } 471 r = EFI_INVALID_PARAMETER; 472 out: 473 return r; 474 } 475 476 static efi_status_t EFIAPI efi_install_protocol_interface_ext(void **handle, 477 efi_guid_t *protocol, int protocol_interface_type, 478 void *protocol_interface) 479 { 480 EFI_ENTRY("%p, %p, %d, %p", handle, protocol, protocol_interface_type, 481 protocol_interface); 482 483 return EFI_EXIT(efi_install_protocol_interface(handle, protocol, 484 protocol_interface_type, 485 protocol_interface)); 486 } 487 488 static efi_status_t EFIAPI efi_reinstall_protocol_interface(void *handle, 489 efi_guid_t *protocol, void *old_interface, 490 void *new_interface) 491 { 492 EFI_ENTRY("%p, %p, %p, %p", handle, protocol, old_interface, 493 new_interface); 494 return EFI_EXIT(EFI_ACCESS_DENIED); 495 } 496 497 static efi_status_t EFIAPI efi_uninstall_protocol_interface(void *handle, 498 efi_guid_t *protocol, void *protocol_interface) 499 { 500 struct list_head *lhandle; 501 int i; 502 efi_status_t r = EFI_NOT_FOUND; 503 504 if (!handle || !protocol) { 505 r = EFI_INVALID_PARAMETER; 506 goto out; 507 } 508 509 list_for_each(lhandle, &efi_obj_list) { 510 struct efi_object *efiobj; 511 efiobj = list_entry(lhandle, struct efi_object, link); 512 513 if (efiobj->handle != handle) 514 continue; 515 516 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 517 struct efi_handler *handler = &efiobj->protocols[i]; 518 const efi_guid_t *hprotocol = handler->guid; 519 520 if (!hprotocol) 521 continue; 522 if (!guidcmp(hprotocol, protocol)) { 523 if (handler->protocol_interface) { 524 r = EFI_ACCESS_DENIED; 525 } else { 526 handler->guid = 0; 527 r = EFI_SUCCESS; 528 } 529 goto out; 530 } 531 } 532 } 533 534 out: 535 return r; 536 } 537 538 static efi_status_t EFIAPI efi_uninstall_protocol_interface_ext(void *handle, 539 efi_guid_t *protocol, void *protocol_interface) 540 { 541 EFI_ENTRY("%p, %p, %p", handle, protocol, protocol_interface); 542 543 return EFI_EXIT(efi_uninstall_protocol_interface(handle, protocol, 544 protocol_interface)); 545 } 546 547 static efi_status_t EFIAPI efi_register_protocol_notify(efi_guid_t *protocol, 548 struct efi_event *event, 549 void **registration) 550 { 551 EFI_ENTRY("%p, %p, %p", protocol, event, registration); 552 return EFI_EXIT(EFI_OUT_OF_RESOURCES); 553 } 554 555 static int efi_search(enum efi_locate_search_type search_type, 556 efi_guid_t *protocol, void *search_key, 557 struct efi_object *efiobj) 558 { 559 int i; 560 561 switch (search_type) { 562 case all_handles: 563 return 0; 564 case by_register_notify: 565 return -1; 566 case by_protocol: 567 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 568 const efi_guid_t *guid = efiobj->protocols[i].guid; 569 if (guid && !guidcmp(guid, protocol)) 570 return 0; 571 } 572 return -1; 573 } 574 575 return -1; 576 } 577 578 static efi_status_t EFIAPI efi_locate_handle( 579 enum efi_locate_search_type search_type, 580 efi_guid_t *protocol, void *search_key, 581 unsigned long *buffer_size, efi_handle_t *buffer) 582 { 583 struct list_head *lhandle; 584 unsigned long size = 0; 585 586 /* Count how much space we need */ 587 list_for_each(lhandle, &efi_obj_list) { 588 struct efi_object *efiobj; 589 efiobj = list_entry(lhandle, struct efi_object, link); 590 if (!efi_search(search_type, protocol, search_key, efiobj)) { 591 size += sizeof(void*); 592 } 593 } 594 595 if (*buffer_size < size) { 596 *buffer_size = size; 597 return EFI_BUFFER_TOO_SMALL; 598 } 599 600 /* Then fill the array */ 601 list_for_each(lhandle, &efi_obj_list) { 602 struct efi_object *efiobj; 603 efiobj = list_entry(lhandle, struct efi_object, link); 604 if (!efi_search(search_type, protocol, search_key, efiobj)) { 605 *(buffer++) = efiobj->handle; 606 } 607 } 608 609 *buffer_size = size; 610 return EFI_SUCCESS; 611 } 612 613 static efi_status_t EFIAPI efi_locate_handle_ext( 614 enum efi_locate_search_type search_type, 615 efi_guid_t *protocol, void *search_key, 616 unsigned long *buffer_size, efi_handle_t *buffer) 617 { 618 EFI_ENTRY("%d, %p, %p, %p, %p", search_type, protocol, search_key, 619 buffer_size, buffer); 620 621 return EFI_EXIT(efi_locate_handle(search_type, protocol, search_key, 622 buffer_size, buffer)); 623 } 624 625 static efi_status_t EFIAPI efi_locate_device_path(efi_guid_t *protocol, 626 struct efi_device_path **device_path, 627 efi_handle_t *device) 628 { 629 EFI_ENTRY("%p, %p, %p", protocol, device_path, device); 630 return EFI_EXIT(EFI_NOT_FOUND); 631 } 632 633 efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table) 634 { 635 int i; 636 637 /* Check for guid override */ 638 for (i = 0; i < systab.nr_tables; i++) { 639 if (!guidcmp(guid, &efi_conf_table[i].guid)) { 640 efi_conf_table[i].table = table; 641 return EFI_SUCCESS; 642 } 643 } 644 645 /* No override, check for overflow */ 646 if (i >= ARRAY_SIZE(efi_conf_table)) 647 return EFI_OUT_OF_RESOURCES; 648 649 /* Add a new entry */ 650 memcpy(&efi_conf_table[i].guid, guid, sizeof(*guid)); 651 efi_conf_table[i].table = table; 652 systab.nr_tables = i + 1; 653 654 return EFI_SUCCESS; 655 } 656 657 static efi_status_t EFIAPI efi_install_configuration_table_ext(efi_guid_t *guid, 658 void *table) 659 { 660 EFI_ENTRY("%p, %p", guid, table); 661 return EFI_EXIT(efi_install_configuration_table(guid, table)); 662 } 663 664 static efi_status_t EFIAPI efi_load_image(bool boot_policy, 665 efi_handle_t parent_image, 666 struct efi_device_path *file_path, 667 void *source_buffer, 668 unsigned long source_size, 669 efi_handle_t *image_handle) 670 { 671 static struct efi_object loaded_image_info_obj = { 672 .protocols = { 673 { 674 .guid = &efi_guid_loaded_image, 675 }, 676 }, 677 }; 678 struct efi_loaded_image *info; 679 struct efi_object *obj; 680 681 EFI_ENTRY("%d, %p, %p, %p, %ld, %p", boot_policy, parent_image, 682 file_path, source_buffer, source_size, image_handle); 683 info = malloc(sizeof(*info)); 684 loaded_image_info_obj.protocols[0].protocol_interface = info; 685 obj = malloc(sizeof(loaded_image_info_obj)); 686 memset(info, 0, sizeof(*info)); 687 memcpy(obj, &loaded_image_info_obj, sizeof(loaded_image_info_obj)); 688 obj->handle = info; 689 info->file_path = file_path; 690 info->reserved = efi_load_pe(source_buffer, info); 691 if (!info->reserved) { 692 free(info); 693 free(obj); 694 return EFI_EXIT(EFI_UNSUPPORTED); 695 } 696 697 *image_handle = info; 698 list_add_tail(&obj->link, &efi_obj_list); 699 700 return EFI_EXIT(EFI_SUCCESS); 701 } 702 703 static efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle, 704 unsigned long *exit_data_size, 705 s16 **exit_data) 706 { 707 ulong (*entry)(void *image_handle, struct efi_system_table *st); 708 struct efi_loaded_image *info = image_handle; 709 710 EFI_ENTRY("%p, %p, %p", image_handle, exit_data_size, exit_data); 711 entry = info->reserved; 712 713 efi_is_direct_boot = false; 714 715 /* call the image! */ 716 if (setjmp(&info->exit_jmp)) { 717 /* We returned from the child image */ 718 return EFI_EXIT(info->exit_status); 719 } 720 721 entry(image_handle, &systab); 722 723 /* Should usually never get here */ 724 return EFI_EXIT(EFI_SUCCESS); 725 } 726 727 static efi_status_t EFIAPI efi_exit(efi_handle_t image_handle, 728 efi_status_t exit_status, unsigned long exit_data_size, 729 int16_t *exit_data) 730 { 731 struct efi_loaded_image *loaded_image_info = (void*)image_handle; 732 733 EFI_ENTRY("%p, %ld, %ld, %p", image_handle, exit_status, 734 exit_data_size, exit_data); 735 736 loaded_image_info->exit_status = exit_status; 737 longjmp(&loaded_image_info->exit_jmp, 1); 738 739 panic("EFI application exited"); 740 } 741 742 static struct efi_object *efi_search_obj(void *handle) 743 { 744 struct list_head *lhandle; 745 746 list_for_each(lhandle, &efi_obj_list) { 747 struct efi_object *efiobj; 748 efiobj = list_entry(lhandle, struct efi_object, link); 749 if (efiobj->handle == handle) 750 return efiobj; 751 } 752 753 return NULL; 754 } 755 756 static efi_status_t EFIAPI efi_unload_image(void *image_handle) 757 { 758 struct efi_object *efiobj; 759 760 EFI_ENTRY("%p", image_handle); 761 efiobj = efi_search_obj(image_handle); 762 if (efiobj) 763 list_del(&efiobj->link); 764 765 return EFI_EXIT(EFI_SUCCESS); 766 } 767 768 static void efi_exit_caches(void) 769 { 770 #if defined(CONFIG_ARM) && !defined(CONFIG_ARM64) 771 /* 772 * Grub on 32bit ARM needs to have caches disabled before jumping into 773 * a zImage, but does not know of all cache layers. Give it a hand. 774 */ 775 if (efi_is_direct_boot) 776 cleanup_before_linux(); 777 #endif 778 } 779 780 static efi_status_t EFIAPI efi_exit_boot_services(void *image_handle, 781 unsigned long map_key) 782 { 783 EFI_ENTRY("%p, %ld", image_handle, map_key); 784 785 board_quiesce_devices(); 786 787 /* Fix up caches for EFI payloads if necessary */ 788 efi_exit_caches(); 789 790 /* This stops all lingering devices */ 791 bootm_disable_interrupts(); 792 793 /* Give the payload some time to boot */ 794 WATCHDOG_RESET(); 795 796 return EFI_EXIT(EFI_SUCCESS); 797 } 798 799 static efi_status_t EFIAPI efi_get_next_monotonic_count(uint64_t *count) 800 { 801 static uint64_t mono = 0; 802 EFI_ENTRY("%p", count); 803 *count = mono++; 804 return EFI_EXIT(EFI_SUCCESS); 805 } 806 807 static efi_status_t EFIAPI efi_stall(unsigned long microseconds) 808 { 809 EFI_ENTRY("%ld", microseconds); 810 udelay(microseconds); 811 return EFI_EXIT(EFI_SUCCESS); 812 } 813 814 static efi_status_t EFIAPI efi_set_watchdog_timer(unsigned long timeout, 815 uint64_t watchdog_code, 816 unsigned long data_size, 817 uint16_t *watchdog_data) 818 { 819 EFI_ENTRY("%ld, 0x%"PRIx64", %ld, %p", timeout, watchdog_code, 820 data_size, watchdog_data); 821 return EFI_EXIT(efi_unsupported(__func__)); 822 } 823 824 static efi_status_t EFIAPI efi_connect_controller( 825 efi_handle_t controller_handle, 826 efi_handle_t *driver_image_handle, 827 struct efi_device_path *remain_device_path, 828 bool recursive) 829 { 830 EFI_ENTRY("%p, %p, %p, %d", controller_handle, driver_image_handle, 831 remain_device_path, recursive); 832 return EFI_EXIT(EFI_NOT_FOUND); 833 } 834 835 static efi_status_t EFIAPI efi_disconnect_controller(void *controller_handle, 836 void *driver_image_handle, 837 void *child_handle) 838 { 839 EFI_ENTRY("%p, %p, %p", controller_handle, driver_image_handle, 840 child_handle); 841 return EFI_EXIT(EFI_INVALID_PARAMETER); 842 } 843 844 static efi_status_t EFIAPI efi_close_protocol(void *handle, 845 efi_guid_t *protocol, 846 void *agent_handle, 847 void *controller_handle) 848 { 849 EFI_ENTRY("%p, %p, %p, %p", handle, protocol, agent_handle, 850 controller_handle); 851 return EFI_EXIT(EFI_NOT_FOUND); 852 } 853 854 static efi_status_t EFIAPI efi_open_protocol_information(efi_handle_t handle, 855 efi_guid_t *protocol, 856 struct efi_open_protocol_info_entry **entry_buffer, 857 unsigned long *entry_count) 858 { 859 EFI_ENTRY("%p, %p, %p, %p", handle, protocol, entry_buffer, 860 entry_count); 861 return EFI_EXIT(EFI_NOT_FOUND); 862 } 863 864 static efi_status_t EFIAPI efi_protocols_per_handle(void *handle, 865 efi_guid_t ***protocol_buffer, 866 unsigned long *protocol_buffer_count) 867 { 868 EFI_ENTRY("%p, %p, %p", handle, protocol_buffer, 869 protocol_buffer_count); 870 *protocol_buffer_count = 0; 871 return EFI_EXIT(EFI_OUT_OF_RESOURCES); 872 } 873 874 static efi_status_t EFIAPI efi_locate_handle_buffer( 875 enum efi_locate_search_type search_type, 876 efi_guid_t *protocol, void *search_key, 877 unsigned long *no_handles, efi_handle_t **buffer) 878 { 879 efi_status_t r; 880 unsigned long buffer_size = 0; 881 882 EFI_ENTRY("%d, %p, %p, %p, %p", search_type, protocol, search_key, 883 no_handles, buffer); 884 885 if (!no_handles || !buffer) { 886 r = EFI_INVALID_PARAMETER; 887 goto out; 888 } 889 *no_handles = 0; 890 *buffer = NULL; 891 r = efi_locate_handle(search_type, protocol, search_key, &buffer_size, 892 *buffer); 893 if (r != EFI_BUFFER_TOO_SMALL) 894 goto out; 895 r = efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES, buffer_size, 896 (void **)buffer); 897 if (r != EFI_SUCCESS) 898 goto out; 899 r = efi_locate_handle(search_type, protocol, search_key, &buffer_size, 900 *buffer); 901 if (r == EFI_SUCCESS) 902 *no_handles = buffer_size / sizeof(void *); 903 out: 904 return EFI_EXIT(r); 905 } 906 907 static efi_status_t EFIAPI efi_locate_protocol(efi_guid_t *protocol, 908 void *registration, 909 void **protocol_interface) 910 { 911 struct list_head *lhandle; 912 int i; 913 914 EFI_ENTRY("%p, %p, %p", protocol, registration, protocol_interface); 915 916 if (!protocol || !protocol_interface) 917 return EFI_EXIT(EFI_INVALID_PARAMETER); 918 919 list_for_each(lhandle, &efi_obj_list) { 920 struct efi_object *efiobj; 921 922 efiobj = list_entry(lhandle, struct efi_object, link); 923 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 924 struct efi_handler *handler = &efiobj->protocols[i]; 925 926 if (!handler->guid) 927 continue; 928 if (!guidcmp(handler->guid, protocol)) { 929 *protocol_interface = 930 handler->protocol_interface; 931 return EFI_EXIT(EFI_SUCCESS); 932 } 933 } 934 } 935 *protocol_interface = NULL; 936 937 return EFI_EXIT(EFI_NOT_FOUND); 938 } 939 940 static efi_status_t EFIAPI efi_install_multiple_protocol_interfaces( 941 void **handle, ...) 942 { 943 EFI_ENTRY("%p", handle); 944 945 va_list argptr; 946 efi_guid_t *protocol; 947 void *protocol_interface; 948 efi_status_t r = EFI_SUCCESS; 949 int i = 0; 950 951 if (!handle) 952 return EFI_EXIT(EFI_INVALID_PARAMETER); 953 954 va_start(argptr, handle); 955 for (;;) { 956 protocol = va_arg(argptr, efi_guid_t*); 957 if (!protocol) 958 break; 959 protocol_interface = va_arg(argptr, void*); 960 r = efi_install_protocol_interface(handle, protocol, 961 EFI_NATIVE_INTERFACE, 962 protocol_interface); 963 if (r != EFI_SUCCESS) 964 break; 965 i++; 966 } 967 va_end(argptr); 968 if (r == EFI_SUCCESS) 969 return EFI_EXIT(r); 970 971 /* If an error occured undo all changes. */ 972 va_start(argptr, handle); 973 for (; i; --i) { 974 protocol = va_arg(argptr, efi_guid_t*); 975 protocol_interface = va_arg(argptr, void*); 976 efi_uninstall_protocol_interface(handle, protocol, 977 protocol_interface); 978 } 979 va_end(argptr); 980 981 return EFI_EXIT(r); 982 } 983 984 static efi_status_t EFIAPI efi_uninstall_multiple_protocol_interfaces( 985 void *handle, ...) 986 { 987 EFI_ENTRY("%p", handle); 988 return EFI_EXIT(EFI_INVALID_PARAMETER); 989 } 990 991 static efi_status_t EFIAPI efi_calculate_crc32(void *data, 992 unsigned long data_size, 993 uint32_t *crc32_p) 994 { 995 EFI_ENTRY("%p, %ld", data, data_size); 996 *crc32_p = crc32(0, data, data_size); 997 return EFI_EXIT(EFI_SUCCESS); 998 } 999 1000 static void EFIAPI efi_copy_mem(void *destination, void *source, 1001 unsigned long length) 1002 { 1003 EFI_ENTRY("%p, %p, %ld", destination, source, length); 1004 memcpy(destination, source, length); 1005 } 1006 1007 static void EFIAPI efi_set_mem(void *buffer, unsigned long size, uint8_t value) 1008 { 1009 EFI_ENTRY("%p, %ld, 0x%x", buffer, size, value); 1010 memset(buffer, value, size); 1011 } 1012 1013 static efi_status_t EFIAPI efi_open_protocol( 1014 void *handle, efi_guid_t *protocol, 1015 void **protocol_interface, void *agent_handle, 1016 void *controller_handle, uint32_t attributes) 1017 { 1018 struct list_head *lhandle; 1019 int i; 1020 efi_status_t r = EFI_INVALID_PARAMETER; 1021 1022 EFI_ENTRY("%p, %p, %p, %p, %p, 0x%x", handle, protocol, 1023 protocol_interface, agent_handle, controller_handle, 1024 attributes); 1025 1026 if (!handle || !protocol || 1027 (!protocol_interface && attributes != 1028 EFI_OPEN_PROTOCOL_TEST_PROTOCOL)) { 1029 goto out; 1030 } 1031 1032 switch (attributes) { 1033 case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL: 1034 case EFI_OPEN_PROTOCOL_GET_PROTOCOL: 1035 case EFI_OPEN_PROTOCOL_TEST_PROTOCOL: 1036 break; 1037 case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER: 1038 if (controller_handle == handle) 1039 goto out; 1040 case EFI_OPEN_PROTOCOL_BY_DRIVER: 1041 case EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE: 1042 if (controller_handle == NULL) 1043 goto out; 1044 case EFI_OPEN_PROTOCOL_EXCLUSIVE: 1045 if (agent_handle == NULL) 1046 goto out; 1047 break; 1048 default: 1049 goto out; 1050 } 1051 1052 list_for_each(lhandle, &efi_obj_list) { 1053 struct efi_object *efiobj; 1054 efiobj = list_entry(lhandle, struct efi_object, link); 1055 1056 if (efiobj->handle != handle) 1057 continue; 1058 1059 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 1060 struct efi_handler *handler = &efiobj->protocols[i]; 1061 const efi_guid_t *hprotocol = handler->guid; 1062 if (!hprotocol) 1063 continue; 1064 if (!guidcmp(hprotocol, protocol)) { 1065 if (attributes != 1066 EFI_OPEN_PROTOCOL_TEST_PROTOCOL) { 1067 *protocol_interface = 1068 handler->protocol_interface; 1069 } 1070 r = EFI_SUCCESS; 1071 goto out; 1072 } 1073 } 1074 goto unsupported; 1075 } 1076 1077 unsupported: 1078 r = EFI_UNSUPPORTED; 1079 out: 1080 return EFI_EXIT(r); 1081 } 1082 1083 static efi_status_t EFIAPI efi_handle_protocol(void *handle, 1084 efi_guid_t *protocol, 1085 void **protocol_interface) 1086 { 1087 return efi_open_protocol(handle, protocol, protocol_interface, NULL, 1088 NULL, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL); 1089 } 1090 1091 static const struct efi_boot_services efi_boot_services = { 1092 .hdr = { 1093 .headersize = sizeof(struct efi_table_hdr), 1094 }, 1095 .raise_tpl = efi_raise_tpl, 1096 .restore_tpl = efi_restore_tpl, 1097 .allocate_pages = efi_allocate_pages_ext, 1098 .free_pages = efi_free_pages_ext, 1099 .get_memory_map = efi_get_memory_map_ext, 1100 .allocate_pool = efi_allocate_pool_ext, 1101 .free_pool = efi_free_pool_ext, 1102 .create_event = efi_create_event_ext, 1103 .set_timer = efi_set_timer_ext, 1104 .wait_for_event = efi_wait_for_event, 1105 .signal_event = efi_signal_event_ext, 1106 .close_event = efi_close_event, 1107 .check_event = efi_check_event, 1108 .install_protocol_interface = efi_install_protocol_interface_ext, 1109 .reinstall_protocol_interface = efi_reinstall_protocol_interface, 1110 .uninstall_protocol_interface = efi_uninstall_protocol_interface_ext, 1111 .handle_protocol = efi_handle_protocol, 1112 .reserved = NULL, 1113 .register_protocol_notify = efi_register_protocol_notify, 1114 .locate_handle = efi_locate_handle_ext, 1115 .locate_device_path = efi_locate_device_path, 1116 .install_configuration_table = efi_install_configuration_table_ext, 1117 .load_image = efi_load_image, 1118 .start_image = efi_start_image, 1119 .exit = efi_exit, 1120 .unload_image = efi_unload_image, 1121 .exit_boot_services = efi_exit_boot_services, 1122 .get_next_monotonic_count = efi_get_next_monotonic_count, 1123 .stall = efi_stall, 1124 .set_watchdog_timer = efi_set_watchdog_timer, 1125 .connect_controller = efi_connect_controller, 1126 .disconnect_controller = efi_disconnect_controller, 1127 .open_protocol = efi_open_protocol, 1128 .close_protocol = efi_close_protocol, 1129 .open_protocol_information = efi_open_protocol_information, 1130 .protocols_per_handle = efi_protocols_per_handle, 1131 .locate_handle_buffer = efi_locate_handle_buffer, 1132 .locate_protocol = efi_locate_protocol, 1133 .install_multiple_protocol_interfaces = efi_install_multiple_protocol_interfaces, 1134 .uninstall_multiple_protocol_interfaces = efi_uninstall_multiple_protocol_interfaces, 1135 .calculate_crc32 = efi_calculate_crc32, 1136 .copy_mem = efi_copy_mem, 1137 .set_mem = efi_set_mem, 1138 }; 1139 1140 1141 static uint16_t __efi_runtime_data firmware_vendor[] = 1142 { 'D','a','s',' ','U','-','b','o','o','t',0 }; 1143 1144 struct efi_system_table __efi_runtime_data systab = { 1145 .hdr = { 1146 .signature = EFI_SYSTEM_TABLE_SIGNATURE, 1147 .revision = 0x20005, /* 2.5 */ 1148 .headersize = sizeof(struct efi_table_hdr), 1149 }, 1150 .fw_vendor = (long)firmware_vendor, 1151 .con_in = (void*)&efi_con_in, 1152 .con_out = (void*)&efi_con_out, 1153 .std_err = (void*)&efi_con_out, 1154 .runtime = (void*)&efi_runtime_services, 1155 .boottime = (void*)&efi_boot_services, 1156 .nr_tables = 0, 1157 .tables = (void*)efi_conf_table, 1158 }; 1159