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