git.sur5r.net Git - u-boot/blob - lib/efi_loader/efi_boottime.c

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