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 unsigned long buffer_size; 869 struct efi_object *efiobj; 870 unsigned long i, j; 871 struct list_head *lhandle; 872 efi_status_t r; 873 874 EFI_ENTRY("%p, %p, %p", handle, protocol_buffer, 875 protocol_buffer_count); 876 877 if (!handle || !protocol_buffer || !protocol_buffer_count) 878 return EFI_EXIT(EFI_INVALID_PARAMETER); 879 880 *protocol_buffer = NULL; 881 *protocol_buffer_count = 0; 882 list_for_each(lhandle, &efi_obj_list) { 883 efiobj = list_entry(lhandle, struct efi_object, link); 884 885 if (efiobj->handle != handle) 886 continue; 887 888 /* Count protocols */ 889 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 890 if (efiobj->protocols[i].guid) 891 ++*protocol_buffer_count; 892 } 893 /* Copy guids */ 894 if (*protocol_buffer_count) { 895 buffer_size = sizeof(efi_guid_t *) * 896 *protocol_buffer_count; 897 r = efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES, 898 buffer_size, 899 (void **)protocol_buffer); 900 if (r != EFI_SUCCESS) 901 return EFI_EXIT(r); 902 j = 0; 903 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); ++i) { 904 if (efiobj->protocols[i].guid) { 905 (*protocol_buffer)[j] = (void *) 906 efiobj->protocols[i].guid; 907 ++j; 908 } 909 } 910 } 911 break; 912 } 913 914 return EFI_EXIT(EFI_SUCCESS); 915 } 916 917 static efi_status_t EFIAPI efi_locate_handle_buffer( 918 enum efi_locate_search_type search_type, 919 efi_guid_t *protocol, void *search_key, 920 unsigned long *no_handles, efi_handle_t **buffer) 921 { 922 efi_status_t r; 923 unsigned long buffer_size = 0; 924 925 EFI_ENTRY("%d, %p, %p, %p, %p", search_type, protocol, search_key, 926 no_handles, buffer); 927 928 if (!no_handles || !buffer) { 929 r = EFI_INVALID_PARAMETER; 930 goto out; 931 } 932 *no_handles = 0; 933 *buffer = NULL; 934 r = efi_locate_handle(search_type, protocol, search_key, &buffer_size, 935 *buffer); 936 if (r != EFI_BUFFER_TOO_SMALL) 937 goto out; 938 r = efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES, buffer_size, 939 (void **)buffer); 940 if (r != EFI_SUCCESS) 941 goto out; 942 r = efi_locate_handle(search_type, protocol, search_key, &buffer_size, 943 *buffer); 944 if (r == EFI_SUCCESS) 945 *no_handles = buffer_size / sizeof(void *); 946 out: 947 return EFI_EXIT(r); 948 } 949 950 static efi_status_t EFIAPI efi_locate_protocol(efi_guid_t *protocol, 951 void *registration, 952 void **protocol_interface) 953 { 954 struct list_head *lhandle; 955 int i; 956 957 EFI_ENTRY("%p, %p, %p", protocol, registration, protocol_interface); 958 959 if (!protocol || !protocol_interface) 960 return EFI_EXIT(EFI_INVALID_PARAMETER); 961 962 list_for_each(lhandle, &efi_obj_list) { 963 struct efi_object *efiobj; 964 965 efiobj = list_entry(lhandle, struct efi_object, link); 966 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 967 struct efi_handler *handler = &efiobj->protocols[i]; 968 969 if (!handler->guid) 970 continue; 971 if (!guidcmp(handler->guid, protocol)) { 972 *protocol_interface = 973 handler->protocol_interface; 974 return EFI_EXIT(EFI_SUCCESS); 975 } 976 } 977 } 978 *protocol_interface = NULL; 979 980 return EFI_EXIT(EFI_NOT_FOUND); 981 } 982 983 static efi_status_t EFIAPI efi_install_multiple_protocol_interfaces( 984 void **handle, ...) 985 { 986 EFI_ENTRY("%p", handle); 987 988 va_list argptr; 989 efi_guid_t *protocol; 990 void *protocol_interface; 991 efi_status_t r = EFI_SUCCESS; 992 int i = 0; 993 994 if (!handle) 995 return EFI_EXIT(EFI_INVALID_PARAMETER); 996 997 va_start(argptr, handle); 998 for (;;) { 999 protocol = va_arg(argptr, efi_guid_t*); 1000 if (!protocol) 1001 break; 1002 protocol_interface = va_arg(argptr, void*); 1003 r = efi_install_protocol_interface(handle, protocol, 1004 EFI_NATIVE_INTERFACE, 1005 protocol_interface); 1006 if (r != EFI_SUCCESS) 1007 break; 1008 i++; 1009 } 1010 va_end(argptr); 1011 if (r == EFI_SUCCESS) 1012 return EFI_EXIT(r); 1013 1014 /* If an error occured undo all changes. */ 1015 va_start(argptr, handle); 1016 for (; i; --i) { 1017 protocol = va_arg(argptr, efi_guid_t*); 1018 protocol_interface = va_arg(argptr, void*); 1019 efi_uninstall_protocol_interface(handle, protocol, 1020 protocol_interface); 1021 } 1022 va_end(argptr); 1023 1024 return EFI_EXIT(r); 1025 } 1026 1027 static efi_status_t EFIAPI efi_uninstall_multiple_protocol_interfaces( 1028 void *handle, ...) 1029 { 1030 EFI_ENTRY("%p", handle); 1031 return EFI_EXIT(EFI_INVALID_PARAMETER); 1032 } 1033 1034 static efi_status_t EFIAPI efi_calculate_crc32(void *data, 1035 unsigned long data_size, 1036 uint32_t *crc32_p) 1037 { 1038 EFI_ENTRY("%p, %ld", data, data_size); 1039 *crc32_p = crc32(0, data, data_size); 1040 return EFI_EXIT(EFI_SUCCESS); 1041 } 1042 1043 static void EFIAPI efi_copy_mem(void *destination, void *source, 1044 unsigned long length) 1045 { 1046 EFI_ENTRY("%p, %p, %ld", destination, source, length); 1047 memcpy(destination, source, length); 1048 } 1049 1050 static void EFIAPI efi_set_mem(void *buffer, unsigned long size, uint8_t value) 1051 { 1052 EFI_ENTRY("%p, %ld, 0x%x", buffer, size, value); 1053 memset(buffer, value, size); 1054 } 1055 1056 static efi_status_t EFIAPI efi_open_protocol( 1057 void *handle, efi_guid_t *protocol, 1058 void **protocol_interface, void *agent_handle, 1059 void *controller_handle, uint32_t attributes) 1060 { 1061 struct list_head *lhandle; 1062 int i; 1063 efi_status_t r = EFI_INVALID_PARAMETER; 1064 1065 EFI_ENTRY("%p, %p, %p, %p, %p, 0x%x", handle, protocol, 1066 protocol_interface, agent_handle, controller_handle, 1067 attributes); 1068 1069 if (!handle || !protocol || 1070 (!protocol_interface && attributes != 1071 EFI_OPEN_PROTOCOL_TEST_PROTOCOL)) { 1072 goto out; 1073 } 1074 1075 switch (attributes) { 1076 case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL: 1077 case EFI_OPEN_PROTOCOL_GET_PROTOCOL: 1078 case EFI_OPEN_PROTOCOL_TEST_PROTOCOL: 1079 break; 1080 case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER: 1081 if (controller_handle == handle) 1082 goto out; 1083 case EFI_OPEN_PROTOCOL_BY_DRIVER: 1084 case EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE: 1085 if (controller_handle == NULL) 1086 goto out; 1087 case EFI_OPEN_PROTOCOL_EXCLUSIVE: 1088 if (agent_handle == NULL) 1089 goto out; 1090 break; 1091 default: 1092 goto out; 1093 } 1094 1095 list_for_each(lhandle, &efi_obj_list) { 1096 struct efi_object *efiobj; 1097 efiobj = list_entry(lhandle, struct efi_object, link); 1098 1099 if (efiobj->handle != handle) 1100 continue; 1101 1102 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { 1103 struct efi_handler *handler = &efiobj->protocols[i]; 1104 const efi_guid_t *hprotocol = handler->guid; 1105 if (!hprotocol) 1106 continue; 1107 if (!guidcmp(hprotocol, protocol)) { 1108 if (attributes != 1109 EFI_OPEN_PROTOCOL_TEST_PROTOCOL) { 1110 *protocol_interface = 1111 handler->protocol_interface; 1112 } 1113 r = EFI_SUCCESS; 1114 goto out; 1115 } 1116 } 1117 goto unsupported; 1118 } 1119 1120 unsupported: 1121 r = EFI_UNSUPPORTED; 1122 out: 1123 return EFI_EXIT(r); 1124 } 1125 1126 static efi_status_t EFIAPI efi_handle_protocol(void *handle, 1127 efi_guid_t *protocol, 1128 void **protocol_interface) 1129 { 1130 return efi_open_protocol(handle, protocol, protocol_interface, NULL, 1131 NULL, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL); 1132 } 1133 1134 static const struct efi_boot_services efi_boot_services = { 1135 .hdr = { 1136 .headersize = sizeof(struct efi_table_hdr), 1137 }, 1138 .raise_tpl = efi_raise_tpl, 1139 .restore_tpl = efi_restore_tpl, 1140 .allocate_pages = efi_allocate_pages_ext, 1141 .free_pages = efi_free_pages_ext, 1142 .get_memory_map = efi_get_memory_map_ext, 1143 .allocate_pool = efi_allocate_pool_ext, 1144 .free_pool = efi_free_pool_ext, 1145 .create_event = efi_create_event_ext, 1146 .set_timer = efi_set_timer_ext, 1147 .wait_for_event = efi_wait_for_event, 1148 .signal_event = efi_signal_event_ext, 1149 .close_event = efi_close_event, 1150 .check_event = efi_check_event, 1151 .install_protocol_interface = efi_install_protocol_interface_ext, 1152 .reinstall_protocol_interface = efi_reinstall_protocol_interface, 1153 .uninstall_protocol_interface = efi_uninstall_protocol_interface_ext, 1154 .handle_protocol = efi_handle_protocol, 1155 .reserved = NULL, 1156 .register_protocol_notify = efi_register_protocol_notify, 1157 .locate_handle = efi_locate_handle_ext, 1158 .locate_device_path = efi_locate_device_path, 1159 .install_configuration_table = efi_install_configuration_table_ext, 1160 .load_image = efi_load_image, 1161 .start_image = efi_start_image, 1162 .exit = efi_exit, 1163 .unload_image = efi_unload_image, 1164 .exit_boot_services = efi_exit_boot_services, 1165 .get_next_monotonic_count = efi_get_next_monotonic_count, 1166 .stall = efi_stall, 1167 .set_watchdog_timer = efi_set_watchdog_timer, 1168 .connect_controller = efi_connect_controller, 1169 .disconnect_controller = efi_disconnect_controller, 1170 .open_protocol = efi_open_protocol, 1171 .close_protocol = efi_close_protocol, 1172 .open_protocol_information = efi_open_protocol_information, 1173 .protocols_per_handle = efi_protocols_per_handle, 1174 .locate_handle_buffer = efi_locate_handle_buffer, 1175 .locate_protocol = efi_locate_protocol, 1176 .install_multiple_protocol_interfaces = efi_install_multiple_protocol_interfaces, 1177 .uninstall_multiple_protocol_interfaces = efi_uninstall_multiple_protocol_interfaces, 1178 .calculate_crc32 = efi_calculate_crc32, 1179 .copy_mem = efi_copy_mem, 1180 .set_mem = efi_set_mem, 1181 }; 1182 1183 1184 static uint16_t __efi_runtime_data firmware_vendor[] = 1185 { 'D','a','s',' ','U','-','b','o','o','t',0 }; 1186 1187 struct efi_system_table __efi_runtime_data systab = { 1188 .hdr = { 1189 .signature = EFI_SYSTEM_TABLE_SIGNATURE, 1190 .revision = 0x20005, /* 2.5 */ 1191 .headersize = sizeof(struct efi_table_hdr), 1192 }, 1193 .fw_vendor = (long)firmware_vendor, 1194 .con_in = (void*)&efi_con_in, 1195 .con_out = (void*)&efi_con_out, 1196 .std_err = (void*)&efi_con_out, 1197 .runtime = (void*)&efi_runtime_services, 1198 .boottime = (void*)&efi_boot_services, 1199 .nr_tables = 0, 1200 .tables = (void*)efi_conf_table, 1201 }; 1202