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