lib/efi_loader/efi_boottime.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  EFI application boot time services
   4  *
   5  *  Copyright (c) 2016 Alexander Graf
   6  */
   7
   8 #include <common.h>
   9 #include <div64.h>
  10 #include <efi_loader.h>
  11 #include <environment.h>
  12 #include <malloc.h>
  13 #include <linux/libfdt_env.h>
  14 #include <u-boot/crc.h>
  15 #include <bootm.h>
  16 #include <pe.h>
  17 #include <watchdog.h>
  18
  19 DECLARE_GLOBAL_DATA_PTR;
  20
  21 /* Task priority level */
  22 static efi_uintn_t efi_tpl = TPL_APPLICATION;
  23
  24 /* This list contains all the EFI objects our payload has access to */
  25 LIST_HEAD(efi_obj_list);
  26
  27 /* List of all events */
  28 LIST_HEAD(efi_events);
  29
  30 /* List of all events registered by RegisterProtocolNotify() */
  31 LIST_HEAD(efi_register_notify_events);
  32
  33 /* Handle of the currently executing image */
  34 static efi_handle_t current_image;
  35
  36 /*
  37  * If we're running on nasty systems (32bit ARM booting into non-EFI Linux)
  38  * we need to do trickery with caches. Since we don't want to break the EFI
  39  * aware boot path, only apply hacks when loading exiting directly (breaking
  40  * direct Linux EFI booting along the way - oh well).
  41  */
  42 static bool efi_is_direct_boot = true;
  43
  44 #ifdef CONFIG_ARM
  45 /*
  46  * The "gd" pointer lives in a register on ARM and AArch64 that we declare
  47  * fixed when compiling U-Boot. However, the payload does not know about that
  48  * restriction so we need to manually swap its and our view of that register on
  49  * EFI callback entry/exit.
  50  */
  51 static volatile void *efi_gd, *app_gd;
  52 #endif
  53
  54 /* 1 if inside U-Boot code, 0 if inside EFI payload code */
  55 static int entry_count = 1;
  56 static int nesting_level;
  57 /* GUID of the device tree table */
  58 const efi_guid_t efi_guid_fdt = EFI_FDT_GUID;
  59 /* GUID of the EFI_DRIVER_BINDING_PROTOCOL */
  60 const efi_guid_t efi_guid_driver_binding_protocol =
  61                         EFI_DRIVER_BINDING_PROTOCOL_GUID;
  62
  63 /* event group ExitBootServices() invoked */
  64 const efi_guid_t efi_guid_event_group_exit_boot_services =
  65                         EFI_EVENT_GROUP_EXIT_BOOT_SERVICES;
  66 /* event group SetVirtualAddressMap() invoked */
  67 const efi_guid_t efi_guid_event_group_virtual_address_change =
  68                         EFI_EVENT_GROUP_VIRTUAL_ADDRESS_CHANGE;
  69 /* event group memory map changed */
  70 const efi_guid_t efi_guid_event_group_memory_map_change =
  71                         EFI_EVENT_GROUP_MEMORY_MAP_CHANGE;
  72 /* event group boot manager about to boot */
  73 const efi_guid_t efi_guid_event_group_ready_to_boot =
  74                         EFI_EVENT_GROUP_READY_TO_BOOT;
  75 /* event group ResetSystem() invoked (before ExitBootServices) */
  76 const efi_guid_t efi_guid_event_group_reset_system =
  77                         EFI_EVENT_GROUP_RESET_SYSTEM;
  78
  79 static efi_status_t EFIAPI efi_disconnect_controller(
  80                                         efi_handle_t controller_handle,
  81                                         efi_handle_t driver_image_handle,
  82                                         efi_handle_t child_handle);
  83
  84 /* Called on every callback entry */
  85 int __efi_entry_check(void)
  86 {
  87         int ret = entry_count++ == 0;
  88 #ifdef CONFIG_ARM
  89         assert(efi_gd);
  90         app_gd = gd;
  91         gd = efi_gd;
  92 #endif
  93         return ret;
  94 }
  95
  96 /* Called on every callback exit */
  97 int __efi_exit_check(void)
  98 {
  99         int ret = --entry_count == 0;
 100 #ifdef CONFIG_ARM
 101         gd = app_gd;
 102 #endif
 103         return ret;
 104 }
 105
 106 /* Called from do_bootefi_exec() */
 107 void efi_save_gd(void)
 108 {
 109 #ifdef CONFIG_ARM
 110         efi_gd = gd;
 111 #endif
 112 }
 113
 114 /*
 115  * Special case handler for error/abort that just forces things back to u-boot
 116  * world so we can dump out an abort message, without any care about returning
 117  * back to UEFI world.
 118  */
 119 void efi_restore_gd(void)
 120 {
 121 #ifdef CONFIG_ARM
 122         /* Only restore if we're already in EFI context */
 123         if (!efi_gd)
 124                 return;
 125         gd = efi_gd;
 126 #endif
 127 }
 128
 129 /**
 130  * indent_string() - returns a string for indenting with two spaces per level
 131  * @level: indent level
 132  *
 133  * A maximum of ten indent levels is supported. Higher indent levels will be
 134  * truncated.
 135  *
 136  * Return: A string for indenting with two spaces per level is
 137  *         returned.
 138  */
 139 static const char *indent_string(int level)
 140 {
 141         const char *indent = "                    ";
 142         const int max = strlen(indent);
 143
 144         level = min(max, level * 2);
 145         return &indent[max - level];
 146 }
 147
 148 const char *__efi_nesting(void)
 149 {
 150         return indent_string(nesting_level);
 151 }
 152
 153 const char *__efi_nesting_inc(void)
 154 {
 155         return indent_string(nesting_level++);
 156 }
 157
 158 const char *__efi_nesting_dec(void)
 159 {
 160         return indent_string(--nesting_level);
 161 }
 162
 163 /**
 164  * efi_queue_event() - queue an EFI event
 165  * @event:     event to signal
 166  * @check_tpl: check the TPL level
 167  *
 168  * This function queues the notification function of the event for future
 169  * execution.
 170  *
 171  * The notification function is called if the task priority level of the event
 172  * is higher than the current task priority level.
 173  *
 174  * For the SignalEvent service see efi_signal_event_ext.
 175  *
 176  */
 177 static void efi_queue_event(struct efi_event *event, bool check_tpl)
 178 {
 179         if (event->notify_function) {
 180                 event->is_queued = true;
 181                 /* Check TPL */
 182                 if (check_tpl && efi_tpl >= event->notify_tpl)
 183                         return;
 184                 event->is_queued = false;
 185                 EFI_CALL_VOID(event->notify_function(event,
 186                                                      event->notify_context));
 187         } else {
 188                 event->is_queued = false;
 189         }
 190 }
 191
 192 /**
 193  * is_valid_tpl() - check if the task priority level is valid
 194  *
 195  * @tpl:                TPL level to check
 196  * Return:              status code
 197  */
 198 efi_status_t is_valid_tpl(efi_uintn_t tpl)
 199 {
 200         switch (tpl) {
 201         case TPL_APPLICATION:
 202         case TPL_CALLBACK:
 203         case TPL_NOTIFY:
 204         case TPL_HIGH_LEVEL:
 205                 return EFI_SUCCESS;
 206         default:
 207                 return EFI_INVALID_PARAMETER;
 208         }
 209 }
 210
 211 /**
 212  * efi_signal_event() - signal an EFI event
 213  * @event:     event to signal
 214  * @check_tpl: check the TPL level
 215  *
 216  * This function signals an event. If the event belongs to an event group all
 217  * events of the group are signaled. If they are of type EVT_NOTIFY_SIGNAL
 218  * their notification function is queued.
 219  *
 220  * For the SignalEvent service see efi_signal_event_ext.
 221  */
 222 void efi_signal_event(struct efi_event *event, bool check_tpl)
 223 {
 224         if (event->group) {
 225                 struct efi_event *evt;
 226
 227                 /*
 228                  * The signaled state has to set before executing any
 229                  * notification function
 230                  */
 231                 list_for_each_entry(evt, &efi_events, link) {
 232                         if (!evt->group || guidcmp(evt->group, event->group))
 233                                 continue;
 234                         if (evt->is_signaled)
 235                                 continue;
 236                         evt->is_signaled = true;
 237                         if (evt->type & EVT_NOTIFY_SIGNAL &&
 238                             evt->notify_function)
 239                                 evt->is_queued = true;
 240                 }
 241                 list_for_each_entry(evt, &efi_events, link) {
 242                         if (!evt->group || guidcmp(evt->group, event->group))
 243                                 continue;
 244                         if (evt->is_queued)
 245                                 efi_queue_event(evt, check_tpl);
 246                 }
 247         } else {
 248                 event->is_signaled = true;
 249                 if (event->type & EVT_NOTIFY_SIGNAL)
 250                         efi_queue_event(event, check_tpl);
 251         }
 252 }
 253
 254 /**
 255  * efi_raise_tpl() - raise the task priority level
 256  * @new_tpl: new value of the task priority level
 257  *
 258  * This function implements the RaiseTpl service.
 259  *
 260  * See the Unified Extensible Firmware Interface (UEFI) specification for
 261  * details.
 262  *
 263  * Return: old value of the task priority level
 264  */
 265 static unsigned long EFIAPI efi_raise_tpl(efi_uintn_t new_tpl)
 266 {
 267         efi_uintn_t old_tpl = efi_tpl;
 268
 269         EFI_ENTRY("0x%zx", new_tpl);
 270
 271         if (new_tpl < efi_tpl)
 272                 EFI_PRINT("WARNING: new_tpl < current_tpl in %s\n", __func__);
 273         efi_tpl = new_tpl;
 274         if (efi_tpl > TPL_HIGH_LEVEL)
 275                 efi_tpl = TPL_HIGH_LEVEL;
 276
 277         EFI_EXIT(EFI_SUCCESS);
 278         return old_tpl;
 279 }
 280
 281 /**
 282  * efi_restore_tpl() - lower the task priority level
 283  * @old_tpl: value of the task priority level to be restored
 284  *
 285  * This function implements the RestoreTpl service.
 286  *
 287  * See the Unified Extensible Firmware Interface (UEFI) specification for
 288  * details.
 289  */
 290 static void EFIAPI efi_restore_tpl(efi_uintn_t old_tpl)
 291 {
 292         EFI_ENTRY("0x%zx", old_tpl);
 293
 294         if (old_tpl > efi_tpl)
 295                 EFI_PRINT("WARNING: old_tpl > current_tpl in %s\n", __func__);
 296         efi_tpl = old_tpl;
 297         if (efi_tpl > TPL_HIGH_LEVEL)
 298                 efi_tpl = TPL_HIGH_LEVEL;
 299
 300         /*
 301          * Lowering the TPL may have made queued events eligible for execution.
 302          */
 303         efi_timer_check();
 304
 305         EFI_EXIT(EFI_SUCCESS);
 306 }
 307
 308 /**
 309  * efi_allocate_pages_ext() - allocate memory pages
 310  * @type:        type of allocation to be performed
 311  * @memory_type: usage type of the allocated memory
 312  * @pages:       number of pages to be allocated
 313  * @memory:      allocated memory
 314  *
 315  * This function implements the AllocatePages service.
 316  *
 317  * See the Unified Extensible Firmware Interface (UEFI) specification for
 318  * details.
 319  *
 320  * Return: status code
 321  */
 322 static efi_status_t EFIAPI efi_allocate_pages_ext(int type, int memory_type,
 323                                                   efi_uintn_t pages,
 324                                                   uint64_t *memory)
 325 {
 326         efi_status_t r;
 327
 328         EFI_ENTRY("%d, %d, 0x%zx, %p", type, memory_type, pages, memory);
 329         r = efi_allocate_pages(type, memory_type, pages, memory);
 330         return EFI_EXIT(r);
 331 }
 332
 333 /**
 334  * efi_free_pages_ext() - Free memory pages.
 335  * @memory: start of the memory area to be freed
 336  * @pages:  number of pages to be freed
 337  *
 338  * This function implements the FreePages service.
 339  *
 340  * See the Unified Extensible Firmware Interface (UEFI) specification for
 341  * details.
 342  *
 343  * Return: status code
 344  */
 345 static efi_status_t EFIAPI efi_free_pages_ext(uint64_t memory,
 346                                               efi_uintn_t pages)
 347 {
 348         efi_status_t r;
 349
 350         EFI_ENTRY("%llx, 0x%zx", memory, pages);
 351         r = efi_free_pages(memory, pages);
 352         return EFI_EXIT(r);
 353 }
 354
 355 /**
 356  * efi_get_memory_map_ext() - get map describing memory usage
 357  * @memory_map_size:    on entry the size, in bytes, of the memory map buffer,
 358  *                      on exit the size of the copied memory map
 359  * @memory_map:         buffer to which the memory map is written
 360  * @map_key:            key for the memory map
 361  * @descriptor_size:    size of an individual memory descriptor
 362  * @descriptor_version: version number of the memory descriptor structure
 363  *
 364  * This function implements the GetMemoryMap service.
 365  *
 366  * See the Unified Extensible Firmware Interface (UEFI) specification for
 367  * details.
 368  *
 369  * Return: status code
 370  */
 371 static efi_status_t EFIAPI efi_get_memory_map_ext(
 372                                         efi_uintn_t *memory_map_size,
 373                                         struct efi_mem_desc *memory_map,
 374                                         efi_uintn_t *map_key,
 375                                         efi_uintn_t *descriptor_size,
 376                                         uint32_t *descriptor_version)
 377 {
 378         efi_status_t r;
 379
 380         EFI_ENTRY("%p, %p, %p, %p, %p", memory_map_size, memory_map,
 381                   map_key, descriptor_size, descriptor_version);
 382         r = efi_get_memory_map(memory_map_size, memory_map, map_key,
 383                                descriptor_size, descriptor_version);
 384         return EFI_EXIT(r);
 385 }
 386
 387 /**
 388  * efi_allocate_pool_ext() - allocate memory from pool
 389  * @pool_type: type of the pool from which memory is to be allocated
 390  * @size:      number of bytes to be allocated
 391  * @buffer:    allocated memory
 392  *
 393  * This function implements the AllocatePool service.
 394  *
 395  * See the Unified Extensible Firmware Interface (UEFI) specification for
 396  * details.
 397  *
 398  * Return: status code
 399  */
 400 static efi_status_t EFIAPI efi_allocate_pool_ext(int pool_type,
 401                                                  efi_uintn_t size,
 402                                                  void **buffer)
 403 {
 404         efi_status_t r;
 405
 406         EFI_ENTRY("%d, %zd, %p", pool_type, size, buffer);
 407         r = efi_allocate_pool(pool_type, size, buffer);
 408         return EFI_EXIT(r);
 409 }
 410
 411 /**
 412  * efi_free_pool_ext() - free memory from pool
 413  * @buffer: start of memory to be freed
 414  *
 415  * This function implements the FreePool service.
 416  *
 417  * See the Unified Extensible Firmware Interface (UEFI) specification for
 418  * details.
 419  *
 420  * Return: status code
 421  */
 422 static efi_status_t EFIAPI efi_free_pool_ext(void *buffer)
 423 {
 424         efi_status_t r;
 425
 426         EFI_ENTRY("%p", buffer);
 427         r = efi_free_pool(buffer);
 428         return EFI_EXIT(r);
 429 }
 430
 431 /**
 432  * efi_add_handle() - add a new handle to the object list
 433  *
 434  * @handle:     handle to be added
 435  *
 436  * The protocols list is initialized. The handle is added to the list of known
 437  * UEFI objects.
 438  */
 439 void efi_add_handle(efi_handle_t handle)
 440 {
 441         if (!handle)
 442                 return;
 443         INIT_LIST_HEAD(&handle->protocols);
 444         list_add_tail(&handle->link, &efi_obj_list);
 445 }
 446
 447 /**
 448  * efi_create_handle() - create handle
 449  * @handle: new handle
 450  *
 451  * Return: status code
 452  */
 453 efi_status_t efi_create_handle(efi_handle_t *handle)
 454 {
 455         struct efi_object *obj;
 456
 457         obj = calloc(1, sizeof(struct efi_object));
 458         if (!obj)
 459                 return EFI_OUT_OF_RESOURCES;
 460
 461         efi_add_handle(obj);
 462         *handle = obj;
 463
 464         return EFI_SUCCESS;
 465 }
 466
 467 /**
 468  * efi_search_protocol() - find a protocol on a handle.
 469  * @handle:        handle
 470  * @protocol_guid: GUID of the protocol
 471  * @handler:       reference to the protocol
 472  *
 473  * Return: status code
 474  */
 475 efi_status_t efi_search_protocol(const efi_handle_t handle,
 476                                  const efi_guid_t *protocol_guid,
 477                                  struct efi_handler **handler)
 478 {
 479         struct efi_object *efiobj;
 480         struct list_head *lhandle;
 481
 482         if (!handle || !protocol_guid)
 483                 return EFI_INVALID_PARAMETER;
 484         efiobj = efi_search_obj(handle);
 485         if (!efiobj)
 486                 return EFI_INVALID_PARAMETER;
 487         list_for_each(lhandle, &efiobj->protocols) {
 488                 struct efi_handler *protocol;
 489
 490                 protocol = list_entry(lhandle, struct efi_handler, link);
 491                 if (!guidcmp(protocol->guid, protocol_guid)) {
 492                         if (handler)
 493                                 *handler = protocol;
 494                         return EFI_SUCCESS;
 495                 }
 496         }
 497         return EFI_NOT_FOUND;
 498 }
 499
 500 /**
 501  * efi_remove_protocol() - delete protocol from a handle
 502  * @handle:             handle from which the protocol shall be deleted
 503  * @protocol:           GUID of the protocol to be deleted
 504  * @protocol_interface: interface of the protocol implementation
 505  *
 506  * Return: status code
 507  */
 508 efi_status_t efi_remove_protocol(const efi_handle_t handle,
 509                                  const efi_guid_t *protocol,
 510                                  void *protocol_interface)
 511 {
 512         struct efi_handler *handler;
 513         efi_status_t ret;
 514
 515         ret = efi_search_protocol(handle, protocol, &handler);
 516         if (ret != EFI_SUCCESS)
 517                 return ret;
 518         if (handler->protocol_interface != protocol_interface)
 519                 return EFI_NOT_FOUND;
 520         list_del(&handler->link);
 521         free(handler);
 522         return EFI_SUCCESS;
 523 }
 524
 525 /**
 526  * efi_remove_all_protocols() - delete all protocols from a handle
 527  * @handle: handle from which the protocols shall be deleted
 528  *
 529  * Return: status code
 530  */
 531 efi_status_t efi_remove_all_protocols(const efi_handle_t handle)
 532 {
 533         struct efi_object *efiobj;
 534         struct efi_handler *protocol;
 535         struct efi_handler *pos;
 536
 537         efiobj = efi_search_obj(handle);
 538         if (!efiobj)
 539                 return EFI_INVALID_PARAMETER;
 540         list_for_each_entry_safe(protocol, pos, &efiobj->protocols, link) {
 541                 efi_status_t ret;
 542
 543                 ret = efi_remove_protocol(handle, protocol->guid,
 544                                           protocol->protocol_interface);
 545                 if (ret != EFI_SUCCESS)
 546                         return ret;
 547         }
 548         return EFI_SUCCESS;
 549 }
 550
 551 /**
 552  * efi_delete_handle() - delete handle
 553  *
 554  * @obj: handle to delete
 555  */
 556 void efi_delete_handle(efi_handle_t handle)
 557 {
 558         if (!handle)
 559                 return;
 560         efi_remove_all_protocols(handle);
 561         list_del(&handle->link);
 562         free(handle);
 563 }
 564
 565 /**
 566  * efi_is_event() - check if a pointer is a valid event
 567  * @event: pointer to check
 568  *
 569  * Return: status code
 570  */
 571 static efi_status_t efi_is_event(const struct efi_event *event)
 572 {
 573         const struct efi_event *evt;
 574
 575         if (!event)
 576                 return EFI_INVALID_PARAMETER;
 577         list_for_each_entry(evt, &efi_events, link) {
 578                 if (evt == event)
 579                         return EFI_SUCCESS;
 580         }
 581         return EFI_INVALID_PARAMETER;
 582 }
 583
 584 /**
 585  * efi_create_event() - create an event
 586  * @type:            type of the event to create
 587  * @notify_tpl:      task priority level of the event
 588  * @notify_function: notification function of the event
 589  * @notify_context:  pointer passed to the notification function
 590  * @group:           event group
 591  * @event:           created event
 592  *
 593  * This function is used inside U-Boot code to create an event.
 594  *
 595  * For the API function implementing the CreateEvent service see
 596  * efi_create_event_ext.
 597  *
 598  * Return: status code
 599  */
 600 efi_status_t efi_create_event(uint32_t type, efi_uintn_t notify_tpl,
 601                               void (EFIAPI *notify_function) (
 602                                         struct efi_event *event,
 603                                         void *context),
 604                               void *notify_context, efi_guid_t *group,
 605                               struct efi_event **event)
 606 {
 607         struct efi_event *evt;
 608
 609         if (event == NULL)
 610                 return EFI_INVALID_PARAMETER;
 611
 612         switch (type) {
 613         case 0:
 614         case EVT_TIMER:
 615         case EVT_NOTIFY_SIGNAL:
 616         case EVT_TIMER | EVT_NOTIFY_SIGNAL:
 617         case EVT_NOTIFY_WAIT:
 618         case EVT_TIMER | EVT_NOTIFY_WAIT:
 619         case EVT_SIGNAL_EXIT_BOOT_SERVICES:
 620         case EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE:
 621                 break;
 622         default:
 623                 return EFI_INVALID_PARAMETER;
 624         }
 625
 626         if ((type & (EVT_NOTIFY_WAIT | EVT_NOTIFY_SIGNAL)) &&
 627             (!notify_function || is_valid_tpl(notify_tpl) != EFI_SUCCESS))
 628                 return EFI_INVALID_PARAMETER;
 629
 630         evt = calloc(1, sizeof(struct efi_event));
 631         if (!evt)
 632                 return EFI_OUT_OF_RESOURCES;
 633         evt->type = type;
 634         evt->notify_tpl = notify_tpl;
 635         evt->notify_function = notify_function;
 636         evt->notify_context = notify_context;
 637         evt->group = group;
 638         /* Disable timers on boot up */
 639         evt->trigger_next = -1ULL;
 640         evt->is_queued = false;
 641         evt->is_signaled = false;
 642         list_add_tail(&evt->link, &efi_events);
 643         *event = evt;
 644         return EFI_SUCCESS;
 645 }
 646
 647 /*
 648  * efi_create_event_ex() - create an event in a group
 649  * @type:            type of the event to create
 650  * @notify_tpl:      task priority level of the event
 651  * @notify_function: notification function of the event
 652  * @notify_context:  pointer passed to the notification function
 653  * @event:           created event
 654  * @event_group:     event group
 655  *
 656  * This function implements the CreateEventEx service.
 657  *
 658  * See the Unified Extensible Firmware Interface (UEFI) specification for
 659  * details.
 660  *
 661  * Return: status code
 662  */
 663 efi_status_t EFIAPI efi_create_event_ex(uint32_t type, efi_uintn_t notify_tpl,
 664                                         void (EFIAPI *notify_function) (
 665                                                         struct efi_event *event,
 666                                                         void *context),
 667                                         void *notify_context,
 668                                         efi_guid_t *event_group,
 669                                         struct efi_event **event)
 670 {
 671         efi_status_t ret;
 672
 673         EFI_ENTRY("%d, 0x%zx, %p, %p, %pUl", type, notify_tpl, notify_function,
 674                   notify_context, event_group);
 675
 676         /*
 677          * The allowable input parameters are the same as in CreateEvent()
 678          * except for the following two disallowed event types.
 679          */
 680         switch (type) {
 681         case EVT_SIGNAL_EXIT_BOOT_SERVICES:
 682         case EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE:
 683                 ret = EFI_INVALID_PARAMETER;
 684                 goto out;
 685         }
 686
 687         ret = efi_create_event(type, notify_tpl, notify_function,
 688                                notify_context, event_group, event);
 689 out:
 690         return EFI_EXIT(ret);
 691 }
 692
 693 /**
 694  * efi_create_event_ext() - create an event
 695  * @type:            type of the event to create
 696  * @notify_tpl:      task priority level of the event
 697  * @notify_function: notification function of the event
 698  * @notify_context:  pointer passed to the notification function
 699  * @event:           created event
 700  *
 701  * This function implements the CreateEvent service.
 702  *
 703  * See the Unified Extensible Firmware Interface (UEFI) specification for
 704  * details.
 705  *
 706  * Return: status code
 707  */
 708 static efi_status_t EFIAPI efi_create_event_ext(
 709                         uint32_t type, efi_uintn_t notify_tpl,
 710                         void (EFIAPI *notify_function) (
 711                                         struct efi_event *event,
 712                                         void *context),
 713                         void *notify_context, struct efi_event **event)
 714 {
 715         EFI_ENTRY("%d, 0x%zx, %p, %p", type, notify_tpl, notify_function,
 716                   notify_context);
 717         return EFI_EXIT(efi_create_event(type, notify_tpl, notify_function,
 718                                          notify_context, NULL, event));
 719 }
 720
 721 /**
 722  * efi_timer_check() - check if a timer event has occurred
 723  *
 724  * Check if a timer event has occurred or a queued notification function should
 725  * be called.
 726  *
 727  * Our timers have to work without interrupts, so we check whenever keyboard
 728  * input or disk accesses happen if enough time elapsed for them to fire.
 729  */
 730 void efi_timer_check(void)
 731 {
 732         struct efi_event *evt;
 733         u64 now = timer_get_us();
 734
 735         list_for_each_entry(evt, &efi_events, link) {
 736                 if (evt->is_queued)
 737                         efi_queue_event(evt, true);
 738                 if (!(evt->type & EVT_TIMER) || now < evt->trigger_next)
 739                         continue;
 740                 switch (evt->trigger_type) {
 741                 case EFI_TIMER_RELATIVE:
 742                         evt->trigger_type = EFI_TIMER_STOP;
 743                         break;
 744                 case EFI_TIMER_PERIODIC:
 745                         evt->trigger_next += evt->trigger_time;
 746                         break;
 747                 default:
 748                         continue;
 749                 }
 750                 evt->is_signaled = false;
 751                 efi_signal_event(evt, true);
 752         }
 753         WATCHDOG_RESET();
 754 }
 755
 756 /**
 757  * efi_set_timer() - set the trigger time for a timer event or stop the event
 758  * @event:        event for which the timer is set
 759  * @type:         type of the timer
 760  * @trigger_time: trigger period in multiples of 100 ns
 761  *
 762  * This is the function for internal usage in U-Boot. For the API function
 763  * implementing the SetTimer service see efi_set_timer_ext.
 764  *
 765  * Return: status code
 766  */
 767 efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type,
 768                            uint64_t trigger_time)
 769 {
 770         /* Check that the event is valid */
 771         if (efi_is_event(event) != EFI_SUCCESS || !(event->type & EVT_TIMER))
 772                 return EFI_INVALID_PARAMETER;
 773
 774         /*
 775          * The parameter defines a multiple of 100 ns.
 776          * We use multiples of 1000 ns. So divide by 10.
 777          */
 778         do_div(trigger_time, 10);
 779
 780         switch (type) {
 781         case EFI_TIMER_STOP:
 782                 event->trigger_next = -1ULL;
 783                 break;
 784         case EFI_TIMER_PERIODIC:
 785         case EFI_TIMER_RELATIVE:
 786                 event->trigger_next = timer_get_us() + trigger_time;
 787                 break;
 788         default:
 789                 return EFI_INVALID_PARAMETER;
 790         }
 791         event->trigger_type = type;
 792         event->trigger_time = trigger_time;
 793         event->is_signaled = false;
 794         return EFI_SUCCESS;
 795 }
 796
 797 /**
 798  * efi_set_timer_ext() - Set the trigger time for a timer event or stop the
 799  *                       event
 800  * @event:        event for which the timer is set
 801  * @type:         type of the timer
 802  * @trigger_time: trigger period in multiples of 100 ns
 803  *
 804  * This function implements the SetTimer service.
 805  *
 806  * See the Unified Extensible Firmware Interface (UEFI) specification for
 807  * details.
 808  *
 809  *
 810  * Return: status code
 811  */
 812 static efi_status_t EFIAPI efi_set_timer_ext(struct efi_event *event,
 813                                              enum efi_timer_delay type,
 814                                              uint64_t trigger_time)
 815 {
 816         EFI_ENTRY("%p, %d, %llx", event, type, trigger_time);
 817         return EFI_EXIT(efi_set_timer(event, type, trigger_time));
 818 }
 819
 820 /**
 821  * efi_wait_for_event() - wait for events to be signaled
 822  * @num_events: number of events to be waited for
 823  * @event:      events to be waited for
 824  * @index:      index of the event that was signaled
 825  *
 826  * This function implements the WaitForEvent service.
 827  *
 828  * See the Unified Extensible Firmware Interface (UEFI) specification for
 829  * details.
 830  *
 831  * Return: status code
 832  */
 833 static efi_status_t EFIAPI efi_wait_for_event(efi_uintn_t num_events,
 834                                               struct efi_event **event,
 835                                               efi_uintn_t *index)
 836 {
 837         int i;
 838
 839         EFI_ENTRY("%zd, %p, %p", num_events, event, index);
 840
 841         /* Check parameters */
 842         if (!num_events || !event)
 843                 return EFI_EXIT(EFI_INVALID_PARAMETER);
 844         /* Check TPL */
 845         if (efi_tpl != TPL_APPLICATION)
 846                 return EFI_EXIT(EFI_UNSUPPORTED);
 847         for (i = 0; i < num_events; ++i) {
 848                 if (efi_is_event(event[i]) != EFI_SUCCESS)
 849                         return EFI_EXIT(EFI_INVALID_PARAMETER);
 850                 if (!event[i]->type || event[i]->type & EVT_NOTIFY_SIGNAL)
 851                         return EFI_EXIT(EFI_INVALID_PARAMETER);
 852                 if (!event[i]->is_signaled)
 853                         efi_queue_event(event[i], true);
 854         }
 855
 856         /* Wait for signal */
 857         for (;;) {
 858                 for (i = 0; i < num_events; ++i) {
 859                         if (event[i]->is_signaled)
 860                                 goto out;
 861                 }
 862                 /* Allow events to occur. */
 863                 efi_timer_check();
 864         }
 865
 866 out:
 867         /*
 868          * Reset the signal which is passed to the caller to allow periodic
 869          * events to occur.
 870          */
 871         event[i]->is_signaled = false;
 872         if (index)
 873                 *index = i;
 874
 875         return EFI_EXIT(EFI_SUCCESS);
 876 }
 877
 878 /**
 879  * efi_signal_event_ext() - signal an EFI event
 880  * @event: event to signal
 881  *
 882  * This function implements the SignalEvent service.
 883  *
 884  * See the Unified Extensible Firmware Interface (UEFI) specification for
 885  * details.
 886  *
 887  * This functions sets the signaled state of the event and queues the
 888  * notification function for execution.
 889  *
 890  * Return: status code
 891  */
 892 static efi_status_t EFIAPI efi_signal_event_ext(struct efi_event *event)
 893 {
 894         EFI_ENTRY("%p", event);
 895         if (efi_is_event(event) != EFI_SUCCESS)
 896                 return EFI_EXIT(EFI_INVALID_PARAMETER);
 897         efi_signal_event(event, true);
 898         return EFI_EXIT(EFI_SUCCESS);
 899 }
 900
 901 /**
 902  * efi_close_event() - close an EFI event
 903  * @event: event to close
 904  *
 905  * This function implements the CloseEvent service.
 906  *
 907  * See the Unified Extensible Firmware Interface (UEFI) specification for
 908  * details.
 909  *
 910  * Return: status code
 911  */
 912 static efi_status_t EFIAPI efi_close_event(struct efi_event *event)
 913 {
 914         struct efi_register_notify_event *item, *next;
 915
 916         EFI_ENTRY("%p", event);
 917         if (efi_is_event(event) != EFI_SUCCESS)
 918                 return EFI_EXIT(EFI_INVALID_PARAMETER);
 919
 920         /* Remove protocol notify registrations for the event */
 921         list_for_each_entry_safe(item, next, &efi_register_notify_events,
 922                                  link) {
 923                 if (event == item->event) {
 924                         list_del(&item->link);
 925                         free(item);
 926                 }
 927         }
 928
 929         list_del(&event->link);
 930         free(event);
 931         return EFI_EXIT(EFI_SUCCESS);
 932 }
 933
 934 /**
 935  * efi_check_event() - check if an event is signaled
 936  * @event: event to check
 937  *
 938  * This function implements the CheckEvent service.
 939  *
 940  * See the Unified Extensible Firmware Interface (UEFI) specification for
 941  * details.
 942  *
 943  * If an event is not signaled yet, the notification function is queued. The
 944  * signaled state is cleared.
 945  *
 946  * Return: status code
 947  */
 948 static efi_status_t EFIAPI efi_check_event(struct efi_event *event)
 949 {
 950         EFI_ENTRY("%p", event);
 951         efi_timer_check();
 952         if (efi_is_event(event) != EFI_SUCCESS ||
 953             event->type & EVT_NOTIFY_SIGNAL)
 954                 return EFI_EXIT(EFI_INVALID_PARAMETER);
 955         if (!event->is_signaled)
 956                 efi_queue_event(event, true);
 957         if (event->is_signaled) {
 958                 event->is_signaled = false;
 959                 return EFI_EXIT(EFI_SUCCESS);
 960         }
 961         return EFI_EXIT(EFI_NOT_READY);
 962 }
 963
 964 /**
 965  * efi_search_obj() - find the internal EFI object for a handle
 966  * @handle: handle to find
 967  *
 968  * Return: EFI object
 969  */
 970 struct efi_object *efi_search_obj(const efi_handle_t handle)
 971 {
 972         struct efi_object *efiobj;
 973
 974         if (!handle)
 975                 return NULL;
 976
 977         list_for_each_entry(efiobj, &efi_obj_list, link) {
 978                 if (efiobj == handle)
 979                         return efiobj;
 980         }
 981         return NULL;
 982 }
 983
 984 /**
 985  * efi_open_protocol_info_entry() - create open protocol info entry and add it
 986  *                                  to a protocol
 987  * @handler: handler of a protocol
 988  *
 989  * Return: open protocol info entry
 990  */
 991 static struct efi_open_protocol_info_entry *efi_create_open_info(
 992                         struct efi_handler *handler)
 993 {
 994         struct efi_open_protocol_info_item *item;
 995
 996         item = calloc(1, sizeof(struct efi_open_protocol_info_item));
 997         if (!item)
 998                 return NULL;
 999         /* Append the item to the open protocol info list. */
1000         list_add_tail(&item->link, &handler->open_infos);
1001
1002         return &item->info;
1003 }
1004
1005 /**
1006  * efi_delete_open_info() - remove an open protocol info entry from a protocol
1007  * @item: open protocol info entry to delete
1008  *
1009  * Return: status code
1010  */
1011 static efi_status_t efi_delete_open_info(
1012                         struct efi_open_protocol_info_item *item)
1013 {
1014         list_del(&item->link);
1015         free(item);
1016         return EFI_SUCCESS;
1017 }
1018
1019 /**
1020  * efi_add_protocol() - install new protocol on a handle
1021  * @handle:             handle on which the protocol shall be installed
1022  * @protocol:           GUID of the protocol to be installed
1023  * @protocol_interface: interface of the protocol implementation
1024  *
1025  * Return: status code
1026  */
1027 efi_status_t efi_add_protocol(const efi_handle_t handle,
1028                               const efi_guid_t *protocol,
1029                               void *protocol_interface)
1030 {
1031         struct efi_object *efiobj;
1032         struct efi_handler *handler;
1033         efi_status_t ret;
1034         struct efi_register_notify_event *event;
1035
1036         efiobj = efi_search_obj(handle);
1037         if (!efiobj)
1038                 return EFI_INVALID_PARAMETER;
1039         ret = efi_search_protocol(handle, protocol, NULL);
1040         if (ret != EFI_NOT_FOUND)
1041                 return EFI_INVALID_PARAMETER;
1042         handler = calloc(1, sizeof(struct efi_handler));
1043         if (!handler)
1044                 return EFI_OUT_OF_RESOURCES;
1045         handler->guid = protocol;
1046         handler->protocol_interface = protocol_interface;
1047         INIT_LIST_HEAD(&handler->open_infos);
1048         list_add_tail(&handler->link, &efiobj->protocols);
1049
1050         /* Notify registered events */
1051         list_for_each_entry(event, &efi_register_notify_events, link) {
1052                 if (!guidcmp(protocol, &event->protocol))
1053                         efi_signal_event(event->event, true);
1054         }
1055
1056         if (!guidcmp(&efi_guid_device_path, protocol))
1057                 EFI_PRINT("installed device path '%pD'\n", protocol_interface);
1058         return EFI_SUCCESS;
1059 }
1060
1061 /**
1062  * efi_install_protocol_interface() - install protocol interface
1063  * @handle:                  handle on which the protocol shall be installed
1064  * @protocol:                GUID of the protocol to be installed
1065  * @protocol_interface_type: type of the interface to be installed,
1066  *                           always EFI_NATIVE_INTERFACE
1067  * @protocol_interface:      interface of the protocol implementation
1068  *
1069  * This function implements the InstallProtocolInterface service.
1070  *
1071  * See the Unified Extensible Firmware Interface (UEFI) specification for
1072  * details.
1073  *
1074  * Return: status code
1075  */
1076 static efi_status_t EFIAPI efi_install_protocol_interface(
1077                         efi_handle_t *handle, const efi_guid_t *protocol,
1078                         int protocol_interface_type, void *protocol_interface)
1079 {
1080         efi_status_t r;
1081
1082         EFI_ENTRY("%p, %pUl, %d, %p", handle, protocol, protocol_interface_type,
1083                   protocol_interface);
1084
1085         if (!handle || !protocol ||
1086             protocol_interface_type != EFI_NATIVE_INTERFACE) {
1087                 r = EFI_INVALID_PARAMETER;
1088                 goto out;
1089         }
1090
1091         /* Create new handle if requested. */
1092         if (!*handle) {
1093                 r = efi_create_handle(handle);
1094                 if (r != EFI_SUCCESS)
1095                         goto out;
1096                 EFI_PRINT("new handle %p\n", *handle);
1097         } else {
1098                 EFI_PRINT("handle %p\n", *handle);
1099         }
1100         /* Add new protocol */
1101         r = efi_add_protocol(*handle, protocol, protocol_interface);
1102 out:
1103         return EFI_EXIT(r);
1104 }
1105
1106 /**
1107  * efi_get_drivers() - get all drivers associated to a controller
1108  * @handle:               handle of the controller
1109  * @protocol:             protocol GUID (optional)
1110  * @number_of_drivers:    number of child controllers
1111  * @driver_handle_buffer: handles of the the drivers
1112  *
1113  * The allocated buffer has to be freed with free().
1114  *
1115  * Return: status code
1116  */
1117 static efi_status_t efi_get_drivers(efi_handle_t handle,
1118                                     const efi_guid_t *protocol,
1119                                     efi_uintn_t *number_of_drivers,
1120                                     efi_handle_t **driver_handle_buffer)
1121 {
1122         struct efi_handler *handler;
1123         struct efi_open_protocol_info_item *item;
1124         efi_uintn_t count = 0, i;
1125         bool duplicate;
1126
1127         /* Count all driver associations */
1128         list_for_each_entry(handler, &handle->protocols, link) {
1129                 if (protocol && guidcmp(handler->guid, protocol))
1130                         continue;
1131                 list_for_each_entry(item, &handler->open_infos, link) {
1132                         if (item->info.attributes &
1133                             EFI_OPEN_PROTOCOL_BY_DRIVER)
1134                                 ++count;
1135                 }
1136         }
1137         /*
1138          * Create buffer. In case of duplicate driver assignments the buffer
1139          * will be too large. But that does not harm.
1140          */
1141         *number_of_drivers = 0;
1142         *driver_handle_buffer = calloc(count, sizeof(efi_handle_t));
1143         if (!*driver_handle_buffer)
1144                 return EFI_OUT_OF_RESOURCES;
1145         /* Collect unique driver handles */
1146         list_for_each_entry(handler, &handle->protocols, link) {
1147                 if (protocol && guidcmp(handler->guid, protocol))
1148                         continue;
1149                 list_for_each_entry(item, &handler->open_infos, link) {
1150                         if (item->info.attributes &
1151                             EFI_OPEN_PROTOCOL_BY_DRIVER) {
1152                                 /* Check this is a new driver */
1153                                 duplicate = false;
1154                                 for (i = 0; i < *number_of_drivers; ++i) {
1155                                         if ((*driver_handle_buffer)[i] ==
1156                                             item->info.agent_handle)
1157                                                 duplicate = true;
1158                                 }
1159                                 /* Copy handle to buffer */
1160                                 if (!duplicate) {
1161                                         i = (*number_of_drivers)++;
1162                                         (*driver_handle_buffer)[i] =
1163                                                 item->info.agent_handle;
1164                                 }
1165                         }
1166                 }
1167         }
1168         return EFI_SUCCESS;
1169 }
1170
1171 /**
1172  * efi_disconnect_all_drivers() - disconnect all drivers from a controller
1173  * @handle:       handle of the controller
1174  * @protocol:     protocol GUID (optional)
1175  * @child_handle: handle of the child to destroy
1176  *
1177  * This function implements the DisconnectController service.
1178  *
1179  * See the Unified Extensible Firmware Interface (UEFI) specification for
1180  * details.
1181  *
1182  * Return: status code
1183  */
1184 static efi_status_t efi_disconnect_all_drivers
1185                                 (efi_handle_t handle,
1186                                  const efi_guid_t *protocol,
1187                                  efi_handle_t child_handle)
1188 {
1189         efi_uintn_t number_of_drivers;
1190         efi_handle_t *driver_handle_buffer;
1191         efi_status_t r, ret;
1192
1193         ret = efi_get_drivers(handle, protocol, &number_of_drivers,
1194                               &driver_handle_buffer);
1195         if (ret != EFI_SUCCESS)
1196                 return ret;
1197
1198         ret = EFI_NOT_FOUND;
1199         while (number_of_drivers) {
1200                 r = EFI_CALL(efi_disconnect_controller(
1201                                 handle,
1202                                 driver_handle_buffer[--number_of_drivers],
1203                                 child_handle));
1204                 if (r == EFI_SUCCESS)
1205                         ret = r;
1206         }
1207         free(driver_handle_buffer);
1208         return ret;
1209 }
1210
1211 /**
1212  * efi_uninstall_protocol() - uninstall protocol interface
1213  *
1214  * @handle:             handle from which the protocol shall be removed
1215  * @protocol:           GUID of the protocol to be removed
1216  * @protocol_interface: interface to be removed
1217  *
1218  * This function DOES NOT delete a handle without installed protocol.
1219  *
1220  * Return: status code
1221  */
1222 static efi_status_t efi_uninstall_protocol
1223                         (efi_handle_t handle, const efi_guid_t *protocol,
1224                          void *protocol_interface)
1225 {
1226         struct efi_object *efiobj;
1227         struct efi_handler *handler;
1228         struct efi_open_protocol_info_item *item;
1229         struct efi_open_protocol_info_item *pos;
1230         efi_status_t r;
1231
1232         /* Check handle */
1233         efiobj = efi_search_obj(handle);
1234         if (!efiobj) {
1235                 r = EFI_INVALID_PARAMETER;
1236                 goto out;
1237         }
1238         /* Find the protocol on the handle */
1239         r = efi_search_protocol(handle, protocol, &handler);
1240         if (r != EFI_SUCCESS)
1241                 goto out;
1242         /* Disconnect controllers */
1243         efi_disconnect_all_drivers(efiobj, protocol, NULL);
1244         if (!list_empty(&handler->open_infos)) {
1245                 r =  EFI_ACCESS_DENIED;
1246                 goto out;
1247         }
1248         /* Close protocol */
1249         list_for_each_entry_safe(item, pos, &handler->open_infos, link) {
1250                 if (item->info.attributes ==
1251                         EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL ||
1252                     item->info.attributes == EFI_OPEN_PROTOCOL_GET_PROTOCOL ||
1253                     item->info.attributes == EFI_OPEN_PROTOCOL_TEST_PROTOCOL)
1254                         list_del(&item->link);
1255         }
1256         if (!list_empty(&handler->open_infos)) {
1257                 r =  EFI_ACCESS_DENIED;
1258                 goto out;
1259         }
1260         r = efi_remove_protocol(handle, protocol, protocol_interface);
1261 out:
1262         return r;
1263 }
1264
1265 /**
1266  * efi_uninstall_protocol_interface() - uninstall protocol interface
1267  * @handle:             handle from which the protocol shall be removed
1268  * @protocol:           GUID of the protocol to be removed
1269  * @protocol_interface: interface to be removed
1270  *
1271  * This function implements the UninstallProtocolInterface service.
1272  *
1273  * See the Unified Extensible Firmware Interface (UEFI) specification for
1274  * details.
1275  *
1276  * Return: status code
1277  */
1278 static efi_status_t EFIAPI efi_uninstall_protocol_interface
1279                         (efi_handle_t handle, const efi_guid_t *protocol,
1280                          void *protocol_interface)
1281 {
1282         efi_status_t ret;
1283
1284         EFI_ENTRY("%p, %pUl, %p", handle, protocol, protocol_interface);
1285
1286         ret = efi_uninstall_protocol(handle, protocol, protocol_interface);
1287         if (ret != EFI_SUCCESS)
1288                 goto out;
1289
1290         /* If the last protocol has been removed, delete the handle. */
1291         if (list_empty(&handle->protocols)) {
1292                 list_del(&handle->link);
1293                 free(handle);
1294         }
1295 out:
1296         return EFI_EXIT(ret);
1297 }
1298
1299 /**
1300  * efi_register_protocol_notify() - register an event for notification when a
1301  *                                  protocol is installed.
1302  * @protocol:     GUID of the protocol whose installation shall be notified
1303  * @event:        event to be signaled upon installation of the protocol
1304  * @registration: key for retrieving the registration information
1305  *
1306  * This function implements the RegisterProtocolNotify service.
1307  * See the Unified Extensible Firmware Interface (UEFI) specification
1308  * for details.
1309  *
1310  * Return: status code
1311  */
1312 static efi_status_t EFIAPI efi_register_protocol_notify(
1313                                                 const efi_guid_t *protocol,
1314                                                 struct efi_event *event,
1315                                                 void **registration)
1316 {
1317         struct efi_register_notify_event *item;
1318         efi_status_t ret = EFI_SUCCESS;
1319
1320         EFI_ENTRY("%pUl, %p, %p", protocol, event, registration);
1321
1322         if (!protocol || !event || !registration) {
1323                 ret = EFI_INVALID_PARAMETER;
1324                 goto out;
1325         }
1326
1327         item = calloc(1, sizeof(struct efi_register_notify_event));
1328         if (!item) {
1329                 ret = EFI_OUT_OF_RESOURCES;
1330                 goto out;
1331         }
1332
1333         item->event = event;
1334         memcpy(&item->protocol, protocol, sizeof(efi_guid_t));
1335
1336         list_add_tail(&item->link, &efi_register_notify_events);
1337
1338         *registration = item;
1339 out:
1340         return EFI_EXIT(ret);
1341 }
1342
1343 /**
1344  * efi_search() - determine if an EFI handle implements a protocol
1345  * @search_type: selection criterion
1346  * @protocol:    GUID of the protocol
1347  * @search_key:  registration key
1348  * @handle:      handle
1349  *
1350  * See the documentation of the LocateHandle service in the UEFI specification.
1351  *
1352  * Return: 0 if the handle implements the protocol
1353  */
1354 static int efi_search(enum efi_locate_search_type search_type,
1355                       const efi_guid_t *protocol, efi_handle_t handle)
1356 {
1357         efi_status_t ret;
1358
1359         switch (search_type) {
1360         case ALL_HANDLES:
1361                 return 0;
1362         case BY_REGISTER_NOTIFY:
1363         case BY_PROTOCOL:
1364                 ret = efi_search_protocol(handle, protocol, NULL);
1365                 return (ret != EFI_SUCCESS);
1366         default:
1367                 /* Invalid search type */
1368                 return -1;
1369         }
1370 }
1371
1372 /**
1373  * efi_locate_handle() - locate handles implementing a protocol
1374  *
1375  * @search_type:        selection criterion
1376  * @protocol:           GUID of the protocol
1377  * @search_key:         registration key
1378  * @buffer_size:        size of the buffer to receive the handles in bytes
1379  * @buffer:             buffer to receive the relevant handles
1380  *
1381  * This function is meant for U-Boot internal calls. For the API implementation
1382  * of the LocateHandle service see efi_locate_handle_ext.
1383  *
1384  * Return: status code
1385  */
1386 static efi_status_t efi_locate_handle(
1387                         enum efi_locate_search_type search_type,
1388                         const efi_guid_t *protocol, void *search_key,
1389                         efi_uintn_t *buffer_size, efi_handle_t *buffer)
1390 {
1391         struct efi_object *efiobj;
1392         efi_uintn_t size = 0;
1393         struct efi_register_notify_event *item, *event = NULL;
1394
1395         /* Check parameters */
1396         switch (search_type) {
1397         case ALL_HANDLES:
1398                 break;
1399         case BY_REGISTER_NOTIFY:
1400                 if (!search_key)
1401                         return EFI_INVALID_PARAMETER;
1402                 /* Check that the registration key is valid */
1403                 list_for_each_entry(item, &efi_register_notify_events, link) {
1404                         if (item ==
1405                             (struct efi_register_notify_event *)search_key) {
1406                                 event = item;
1407                                 break;
1408                         }
1409                 }
1410                 if (!event)
1411                         return EFI_INVALID_PARAMETER;
1412
1413                 protocol = &event->protocol;
1414                 break;
1415         case BY_PROTOCOL:
1416                 if (!protocol)
1417                         return EFI_INVALID_PARAMETER;
1418                 break;
1419         default:
1420                 return EFI_INVALID_PARAMETER;
1421         }
1422
1423         /* Count how much space we need */
1424         list_for_each_entry(efiobj, &efi_obj_list, link) {
1425                 if (!efi_search(search_type, protocol, efiobj))
1426                         size += sizeof(void *);
1427         }
1428
1429         if (size == 0)
1430                 return EFI_NOT_FOUND;
1431
1432         if (!buffer_size)
1433                 return EFI_INVALID_PARAMETER;
1434
1435         if (*buffer_size < size) {
1436                 *buffer_size = size;
1437                 return EFI_BUFFER_TOO_SMALL;
1438         }
1439
1440         *buffer_size = size;
1441
1442         /* The buffer size is sufficient but there is no buffer */
1443         if (!buffer)
1444                 return EFI_INVALID_PARAMETER;
1445
1446         /* Then fill the array */
1447         list_for_each_entry(efiobj, &efi_obj_list, link) {
1448                 if (!efi_search(search_type, protocol, efiobj))
1449                         *buffer++ = efiobj;
1450         }
1451
1452         return EFI_SUCCESS;
1453 }
1454
1455 /**
1456  * efi_locate_handle_ext() - locate handles implementing a protocol.
1457  * @search_type: selection criterion
1458  * @protocol:    GUID of the protocol
1459  * @search_key:  registration key
1460  * @buffer_size: size of the buffer to receive the handles in bytes
1461  * @buffer:      buffer to receive the relevant handles
1462  *
1463  * This function implements the LocateHandle service.
1464  *
1465  * See the Unified Extensible Firmware Interface (UEFI) specification for
1466  * details.
1467  *
1468  * Return: 0 if the handle implements the protocol
1469  */
1470 static efi_status_t EFIAPI efi_locate_handle_ext(
1471                         enum efi_locate_search_type search_type,
1472                         const efi_guid_t *protocol, void *search_key,
1473                         efi_uintn_t *buffer_size, efi_handle_t *buffer)
1474 {
1475         EFI_ENTRY("%d, %pUl, %p, %p, %p", search_type, protocol, search_key,
1476                   buffer_size, buffer);
1477
1478         return EFI_EXIT(efi_locate_handle(search_type, protocol, search_key,
1479                         buffer_size, buffer));
1480 }
1481
1482 /**
1483  * efi_remove_configuration_table() - collapses configuration table entries,
1484  *                                    removing index i
1485  *
1486  * @i: index of the table entry to be removed
1487  */
1488 static void efi_remove_configuration_table(int i)
1489 {
1490         struct efi_configuration_table *this = &systab.tables[i];
1491         struct efi_configuration_table *next = &systab.tables[i + 1];
1492         struct efi_configuration_table *end = &systab.tables[systab.nr_tables];
1493
1494         memmove(this, next, (ulong)end - (ulong)next);
1495         systab.nr_tables--;
1496 }
1497
1498 /**
1499  * efi_install_configuration_table() - adds, updates, or removes a
1500  *                                     configuration table
1501  * @guid:  GUID of the installed table
1502  * @table: table to be installed
1503  *
1504  * This function is used for internal calls. For the API implementation of the
1505  * InstallConfigurationTable service see efi_install_configuration_table_ext.
1506  *
1507  * Return: status code
1508  */
1509 efi_status_t efi_install_configuration_table(const efi_guid_t *guid,
1510                                              void *table)
1511 {
1512         struct efi_event *evt;
1513         int i;
1514
1515         if (!guid)
1516                 return EFI_INVALID_PARAMETER;
1517
1518         /* Check for GUID override */
1519         for (i = 0; i < systab.nr_tables; i++) {
1520                 if (!guidcmp(guid, &systab.tables[i].guid)) {
1521                         if (table)
1522                                 systab.tables[i].table = table;
1523                         else
1524                                 efi_remove_configuration_table(i);
1525                         goto out;
1526                 }
1527         }
1528
1529         if (!table)
1530                 return EFI_NOT_FOUND;
1531
1532         /* No override, check for overflow */
1533         if (i >= EFI_MAX_CONFIGURATION_TABLES)
1534                 return EFI_OUT_OF_RESOURCES;
1535
1536         /* Add a new entry */
1537         memcpy(&systab.tables[i].guid, guid, sizeof(*guid));
1538         systab.tables[i].table = table;
1539         systab.nr_tables = i + 1;
1540
1541 out:
1542         /* systab.nr_tables may have changed. So we need to update the CRC32 */
1543         efi_update_table_header_crc32(&systab.hdr);
1544
1545         /* Notify that the configuration table was changed */
1546         list_for_each_entry(evt, &efi_events, link) {
1547                 if (evt->group && !guidcmp(evt->group, guid)) {
1548                         efi_signal_event(evt, false);
1549                         break;
1550                 }
1551         }
1552
1553         return EFI_SUCCESS;
1554 }
1555
1556 /**
1557  * efi_install_configuration_table_ex() - Adds, updates, or removes a
1558  *                                        configuration table.
1559  * @guid:  GUID of the installed table
1560  * @table: table to be installed
1561  *
1562  * This function implements the InstallConfigurationTable service.
1563  *
1564  * See the Unified Extensible Firmware Interface (UEFI) specification for
1565  * details.
1566  *
1567  * Return: status code
1568  */
1569 static efi_status_t EFIAPI efi_install_configuration_table_ext(efi_guid_t *guid,
1570                                                                void *table)
1571 {
1572         EFI_ENTRY("%pUl, %p", guid, table);
1573         return EFI_EXIT(efi_install_configuration_table(guid, table));
1574 }
1575
1576 /**
1577  * efi_setup_loaded_image() - initialize a loaded image
1578  *
1579  * Initialize a loaded_image_info and loaded_image_info object with correct
1580  * protocols, boot-device, etc.
1581  *
1582  * In case of an error *handle_ptr and *info_ptr are set to NULL and an error
1583  * code is returned.
1584  *
1585  * @device_path:        device path of the loaded image
1586  * @file_path:          file path of the loaded image
1587  * @handle_ptr:         handle of the loaded image
1588  * @info_ptr:           loaded image protocol
1589  * Return:              status code
1590  */
1591 efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path,
1592                                     struct efi_device_path *file_path,
1593                                     struct efi_loaded_image_obj **handle_ptr,
1594                                     struct efi_loaded_image **info_ptr)
1595 {
1596         efi_status_t ret;
1597         struct efi_loaded_image *info = NULL;
1598         struct efi_loaded_image_obj *obj = NULL;
1599         struct efi_device_path *dp;
1600
1601         /* In case of EFI_OUT_OF_RESOURCES avoid illegal free by caller. */
1602         *handle_ptr = NULL;
1603         *info_ptr = NULL;
1604
1605         info = calloc(1, sizeof(*info));
1606         if (!info)
1607                 return EFI_OUT_OF_RESOURCES;
1608         obj = calloc(1, sizeof(*obj));
1609         if (!obj) {
1610                 free(info);
1611                 return EFI_OUT_OF_RESOURCES;
1612         }
1613         obj->header.type = EFI_OBJECT_TYPE_LOADED_IMAGE;
1614
1615         /* Add internal object to object list */
1616         efi_add_handle(&obj->header);
1617
1618         info->revision =  EFI_LOADED_IMAGE_PROTOCOL_REVISION;
1619         info->file_path = file_path;
1620         info->system_table = &systab;
1621
1622         if (device_path) {
1623                 info->device_handle = efi_dp_find_obj(device_path, NULL);
1624
1625                 dp = efi_dp_append(device_path, file_path);
1626                 if (!dp) {
1627                         ret = EFI_OUT_OF_RESOURCES;
1628                         goto failure;
1629                 }
1630         } else {
1631                 dp = NULL;
1632         }
1633         ret = efi_add_protocol(&obj->header,
1634                                &efi_guid_loaded_image_device_path, dp);
1635         if (ret != EFI_SUCCESS)
1636                 goto failure;
1637
1638         /*
1639          * When asking for the loaded_image interface, just
1640          * return handle which points to loaded_image_info
1641          */
1642         ret = efi_add_protocol(&obj->header,
1643                                &efi_guid_loaded_image, info);
1644         if (ret != EFI_SUCCESS)
1645                 goto failure;
1646
1647         *info_ptr = info;
1648         *handle_ptr = obj;
1649
1650         return ret;
1651 failure:
1652         printf("ERROR: Failure to install protocols for loaded image\n");
1653         efi_delete_handle(&obj->header);
1654         free(info);
1655         return ret;
1656 }
1657
1658 /**
1659  * efi_load_image_from_path() - load an image using a file path
1660  *
1661  * Read a file into a buffer allocated as EFI_BOOT_SERVICES_DATA. It is the
1662  * callers obligation to update the memory type as needed.
1663  *
1664  * @file_path:  the path of the image to load
1665  * @buffer:     buffer containing the loaded image
1666  * @size:       size of the loaded image
1667  * Return:      status code
1668  */
1669 static
1670 efi_status_t efi_load_image_from_path(struct efi_device_path *file_path,
1671                                       void **buffer, efi_uintn_t *size)
1672 {
1673         struct efi_file_info *info = NULL;
1674         struct efi_file_handle *f;
1675         static efi_status_t ret;
1676         u64 addr;
1677         efi_uintn_t bs;
1678
1679         /* In case of failure nothing is returned */
1680         *buffer = NULL;
1681         *size = 0;
1682
1683         /* Open file */
1684         f = efi_file_from_path(file_path);
1685         if (!f)
1686                 return EFI_DEVICE_ERROR;
1687
1688         /* Get file size */
1689         bs = 0;
1690         EFI_CALL(ret = f->getinfo(f, (efi_guid_t *)&efi_file_info_guid,
1691                                   &bs, info));
1692         if (ret != EFI_BUFFER_TOO_SMALL) {
1693                 ret =  EFI_DEVICE_ERROR;
1694                 goto error;
1695         }
1696
1697         info = malloc(bs);
1698         EFI_CALL(ret = f->getinfo(f, (efi_guid_t *)&efi_file_info_guid, &bs,
1699                                   info));
1700         if (ret != EFI_SUCCESS)
1701                 goto error;
1702
1703         /*
1704          * When reading the file we do not yet know if it contains an
1705          * application, a boottime driver, or a runtime driver. So here we
1706          * allocate a buffer as EFI_BOOT_SERVICES_DATA. The caller has to
1707          * update the reservation according to the image type.
1708          */
1709         bs = info->file_size;
1710         ret = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES,
1711                                  EFI_BOOT_SERVICES_DATA,
1712                                  efi_size_in_pages(bs), &addr);
1713         if (ret != EFI_SUCCESS) {
1714                 ret = EFI_OUT_OF_RESOURCES;
1715                 goto error;
1716         }
1717
1718         /* Read file */
1719         EFI_CALL(ret = f->read(f, &bs, (void *)(uintptr_t)addr));
1720         if (ret != EFI_SUCCESS)
1721                 efi_free_pages(addr, efi_size_in_pages(bs));
1722         *buffer = (void *)(uintptr_t)addr;
1723         *size = bs;
1724 error:
1725         EFI_CALL(f->close(f));
1726         free(info);
1727         return ret;
1728 }
1729
1730 /**
1731  * efi_load_image() - load an EFI image into memory
1732  * @boot_policy:   true for request originating from the boot manager
1733  * @parent_image:  the caller's image handle
1734  * @file_path:     the path of the image to load
1735  * @source_buffer: memory location from which the image is installed
1736  * @source_size:   size of the memory area from which the image is installed
1737  * @image_handle:  handle for the newly installed image
1738  *
1739  * This function implements the LoadImage service.
1740  *
1741  * See the Unified Extensible Firmware Interface (UEFI) specification
1742  * for details.
1743  *
1744  * Return: status code
1745  */
1746 efi_status_t EFIAPI efi_load_image(bool boot_policy,
1747                                    efi_handle_t parent_image,
1748                                    struct efi_device_path *file_path,
1749                                    void *source_buffer,
1750                                    efi_uintn_t source_size,
1751                                    efi_handle_t *image_handle)
1752 {
1753         struct efi_device_path *dp, *fp;
1754         struct efi_loaded_image *info = NULL;
1755         struct efi_loaded_image_obj **image_obj =
1756                 (struct efi_loaded_image_obj **)image_handle;
1757         efi_status_t ret;
1758         void *dest_buffer;
1759
1760         EFI_ENTRY("%d, %p, %pD, %p, %zd, %p", boot_policy, parent_image,
1761                   file_path, source_buffer, source_size, image_handle);
1762
1763         if (!image_handle || !efi_search_obj(parent_image)) {
1764                 ret = EFI_INVALID_PARAMETER;
1765                 goto error;
1766         }
1767
1768         if (!source_buffer && !file_path) {
1769                 ret = EFI_NOT_FOUND;
1770                 goto error;
1771         }
1772         /* The parent image handle must refer to a loaded image */
1773         if (!parent_image->type) {
1774                 ret = EFI_INVALID_PARAMETER;
1775                 goto error;
1776         }
1777
1778         if (!source_buffer) {
1779                 ret = efi_load_image_from_path(file_path, &dest_buffer,
1780                                                &source_size);
1781                 if (ret != EFI_SUCCESS)
1782                         goto error;
1783         } else {
1784                 if (!source_size) {
1785                         ret = EFI_LOAD_ERROR;
1786                         goto error;
1787                 }
1788                 dest_buffer = source_buffer;
1789         }
1790         /* split file_path which contains both the device and file parts */
1791         efi_dp_split_file_path(file_path, &dp, &fp);
1792         ret = efi_setup_loaded_image(dp, fp, image_obj, &info);
1793         if (ret == EFI_SUCCESS)
1794                 ret = efi_load_pe(*image_obj, dest_buffer, info);
1795         if (!source_buffer)
1796                 /* Release buffer to which file was loaded */
1797                 efi_free_pages((uintptr_t)dest_buffer,
1798                                efi_size_in_pages(source_size));
1799         if (ret == EFI_SUCCESS) {
1800                 info->system_table = &systab;
1801                 info->parent_handle = parent_image;
1802         } else {
1803                 /* The image is invalid. Release all associated resources. */
1804                 efi_delete_handle(*image_handle);
1805                 *image_handle = NULL;
1806                 free(info);
1807         }
1808 error:
1809         return EFI_EXIT(ret);
1810 }
1811
1812 /**
1813  * efi_exit_caches() - fix up caches for EFI payloads if necessary
1814  */
1815 static void efi_exit_caches(void)
1816 {
1817 #if defined(CONFIG_ARM) && !defined(CONFIG_ARM64)
1818         /*
1819          * Grub on 32bit ARM needs to have caches disabled before jumping into
1820          * a zImage, but does not know of all cache layers. Give it a hand.
1821          */
1822         if (efi_is_direct_boot)
1823                 cleanup_before_linux();
1824 #endif
1825 }
1826
1827 /**
1828  * efi_exit_boot_services() - stop all boot services
1829  * @image_handle: handle of the loaded image
1830  * @map_key:      key of the memory map
1831  *
1832  * This function implements the ExitBootServices service.
1833  *
1834  * See the Unified Extensible Firmware Interface (UEFI) specification
1835  * for details.
1836  *
1837  * All timer events are disabled. For exit boot services events the
1838  * notification function is called. The boot services are disabled in the
1839  * system table.
1840  *
1841  * Return: status code
1842  */
1843 static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle,
1844                                                   efi_uintn_t map_key)
1845 {
1846         struct efi_event *evt;
1847
1848         EFI_ENTRY("%p, %zx", image_handle, map_key);
1849
1850         /* Check that the caller has read the current memory map */
1851         if (map_key != efi_memory_map_key)
1852                 return EFI_INVALID_PARAMETER;
1853
1854         /* Make sure that notification functions are not called anymore */
1855         efi_tpl = TPL_HIGH_LEVEL;
1856
1857         /* Check if ExitBootServices has already been called */
1858         if (!systab.boottime)
1859                 return EFI_EXIT(EFI_SUCCESS);
1860
1861         /* Add related events to the event group */
1862         list_for_each_entry(evt, &efi_events, link) {
1863                 if (evt->type == EVT_SIGNAL_EXIT_BOOT_SERVICES)
1864                         evt->group = &efi_guid_event_group_exit_boot_services;
1865         }
1866         /* Notify that ExitBootServices is invoked. */
1867         list_for_each_entry(evt, &efi_events, link) {
1868                 if (evt->group &&
1869                     !guidcmp(evt->group,
1870                              &efi_guid_event_group_exit_boot_services)) {
1871                         efi_signal_event(evt, false);
1872                         break;
1873                 }
1874         }
1875
1876         /* TODO: Should persist EFI variables here */
1877
1878         board_quiesce_devices();
1879
1880         /* Fix up caches for EFI payloads if necessary */
1881         efi_exit_caches();
1882
1883         /* This stops all lingering devices */
1884         bootm_disable_interrupts();
1885
1886         /* Disable boot time services */
1887         systab.con_in_handle = NULL;
1888         systab.con_in = NULL;
1889         systab.con_out_handle = NULL;
1890         systab.con_out = NULL;
1891         systab.stderr_handle = NULL;
1892         systab.std_err = NULL;
1893         systab.boottime = NULL;
1894
1895         /* Recalculate CRC32 */
1896         efi_update_table_header_crc32(&systab.hdr);
1897
1898         /* Give the payload some time to boot */
1899         efi_set_watchdog(0);
1900         WATCHDOG_RESET();
1901
1902         return EFI_EXIT(EFI_SUCCESS);
1903 }
1904
1905 /**
1906  * efi_get_next_monotonic_count() - get next value of the counter
1907  * @count: returned value of the counter
1908  *
1909  * This function implements the NextMonotonicCount service.
1910  *
1911  * See the Unified Extensible Firmware Interface (UEFI) specification for
1912  * details.
1913  *
1914  * Return: status code
1915  */
1916 static efi_status_t EFIAPI efi_get_next_monotonic_count(uint64_t *count)
1917 {
1918         static uint64_t mono;
1919         efi_status_t ret;
1920
1921         EFI_ENTRY("%p", count);
1922         if (!count) {
1923                 ret = EFI_INVALID_PARAMETER;
1924                 goto out;
1925         }
1926         *count = mono++;
1927         ret = EFI_SUCCESS;
1928 out:
1929         return EFI_EXIT(ret);
1930 }
1931
1932 /**
1933  * efi_stall() - sleep
1934  * @microseconds: period to sleep in microseconds
1935  *
1936  * This function implements the Stall service.
1937  *
1938  * See the Unified Extensible Firmware Interface (UEFI) specification for
1939  * details.
1940  *
1941  * Return:  status code
1942  */
1943 static efi_status_t EFIAPI efi_stall(unsigned long microseconds)
1944 {
1945         EFI_ENTRY("%ld", microseconds);
1946         udelay(microseconds);
1947         return EFI_EXIT(EFI_SUCCESS);
1948 }
1949
1950 /**
1951  * efi_set_watchdog_timer() - reset the watchdog timer
1952  * @timeout:       seconds before reset by watchdog
1953  * @watchdog_code: code to be logged when resetting
1954  * @data_size:     size of buffer in bytes
1955  * @watchdog_data: buffer with data describing the reset reason
1956  *
1957  * This function implements the SetWatchdogTimer service.
1958  *
1959  * See the Unified Extensible Firmware Interface (UEFI) specification for
1960  * details.
1961  *
1962  * Return: status code
1963  */
1964 static efi_status_t EFIAPI efi_set_watchdog_timer(unsigned long timeout,
1965                                                   uint64_t watchdog_code,
1966                                                   unsigned long data_size,
1967                                                   uint16_t *watchdog_data)
1968 {
1969         EFI_ENTRY("%ld, 0x%llx, %ld, %p", timeout, watchdog_code,
1970                   data_size, watchdog_data);
1971         return EFI_EXIT(efi_set_watchdog(timeout));
1972 }
1973
1974 /**
1975  * efi_close_protocol() - close a protocol
1976  * @handle:            handle on which the protocol shall be closed
1977  * @protocol:          GUID of the protocol to close
1978  * @agent_handle:      handle of the driver
1979  * @controller_handle: handle of the controller
1980  *
1981  * This function implements the CloseProtocol service.
1982  *
1983  * See the Unified Extensible Firmware Interface (UEFI) specification for
1984  * details.
1985  *
1986  * Return: status code
1987  */
1988 static efi_status_t EFIAPI efi_close_protocol(efi_handle_t handle,
1989                                               const efi_guid_t *protocol,
1990                                               efi_handle_t agent_handle,
1991                                               efi_handle_t controller_handle)
1992 {
1993         struct efi_handler *handler;
1994         struct efi_open_protocol_info_item *item;
1995         struct efi_open_protocol_info_item *pos;
1996         efi_status_t r;
1997
1998         EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol, agent_handle,
1999                   controller_handle);
2000
2001         if (!efi_search_obj(agent_handle) ||
2002             (controller_handle && !efi_search_obj(controller_handle))) {
2003                 r = EFI_INVALID_PARAMETER;
2004                 goto out;
2005         }
2006         r = efi_search_protocol(handle, protocol, &handler);
2007         if (r != EFI_SUCCESS)
2008                 goto out;
2009
2010         r = EFI_NOT_FOUND;
2011         list_for_each_entry_safe(item, pos, &handler->open_infos, link) {
2012                 if (item->info.agent_handle == agent_handle &&
2013                     item->info.controller_handle == controller_handle) {
2014                         efi_delete_open_info(item);
2015                         r = EFI_SUCCESS;
2016                         break;
2017                 }
2018         }
2019 out:
2020         return EFI_EXIT(r);
2021 }
2022
2023 /**
2024  * efi_open_protocol_information() - provide information about then open status
2025  *                                   of a protocol on a handle
2026  * @handle:       handle for which the information shall be retrieved
2027  * @protocol:     GUID of the protocol
2028  * @entry_buffer: buffer to receive the open protocol information
2029  * @entry_count:  number of entries available in the buffer
2030  *
2031  * This function implements the OpenProtocolInformation service.
2032  *
2033  * See the Unified Extensible Firmware Interface (UEFI) specification for
2034  * details.
2035  *
2036  * Return: status code
2037  */
2038 static efi_status_t EFIAPI efi_open_protocol_information(
2039                         efi_handle_t handle, const efi_guid_t *protocol,
2040                         struct efi_open_protocol_info_entry **entry_buffer,
2041                         efi_uintn_t *entry_count)
2042 {
2043         unsigned long buffer_size;
2044         unsigned long count;
2045         struct efi_handler *handler;
2046         struct efi_open_protocol_info_item *item;
2047         efi_status_t r;
2048
2049         EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol, entry_buffer,
2050                   entry_count);
2051
2052         /* Check parameters */
2053         if (!entry_buffer) {
2054                 r = EFI_INVALID_PARAMETER;
2055                 goto out;
2056         }
2057         r = efi_search_protocol(handle, protocol, &handler);
2058         if (r != EFI_SUCCESS)
2059                 goto out;
2060
2061         /* Count entries */
2062         count = 0;
2063         list_for_each_entry(item, &handler->open_infos, link) {
2064                 if (item->info.open_count)
2065                         ++count;
2066         }
2067         *entry_count = count;
2068         *entry_buffer = NULL;
2069         if (!count) {
2070                 r = EFI_SUCCESS;
2071                 goto out;
2072         }
2073
2074         /* Copy entries */
2075         buffer_size = count * sizeof(struct efi_open_protocol_info_entry);
2076         r = efi_allocate_pool(EFI_BOOT_SERVICES_DATA, buffer_size,
2077                               (void **)entry_buffer);
2078         if (r != EFI_SUCCESS)
2079                 goto out;
2080         list_for_each_entry_reverse(item, &handler->open_infos, link) {
2081                 if (item->info.open_count)
2082                         (*entry_buffer)[--count] = item->info;
2083         }
2084 out:
2085         return EFI_EXIT(r);
2086 }
2087
2088 /**
2089  * efi_protocols_per_handle() - get protocols installed on a handle
2090  * @handle:                handle for which the information is retrieved
2091  * @protocol_buffer:       buffer with protocol GUIDs
2092  * @protocol_buffer_count: number of entries in the buffer
2093  *
2094  * This function implements the ProtocolsPerHandleService.
2095  *
2096  * See the Unified Extensible Firmware Interface (UEFI) specification for
2097  * details.
2098  *
2099  * Return: status code
2100  */
2101 static efi_status_t EFIAPI efi_protocols_per_handle(
2102                         efi_handle_t handle, efi_guid_t ***protocol_buffer,
2103                         efi_uintn_t *protocol_buffer_count)
2104 {
2105         unsigned long buffer_size;
2106         struct efi_object *efiobj;
2107         struct list_head *protocol_handle;
2108         efi_status_t r;
2109
2110         EFI_ENTRY("%p, %p, %p", handle, protocol_buffer,
2111                   protocol_buffer_count);
2112
2113         if (!handle || !protocol_buffer || !protocol_buffer_count)
2114                 return EFI_EXIT(EFI_INVALID_PARAMETER);
2115
2116         *protocol_buffer = NULL;
2117         *protocol_buffer_count = 0;
2118
2119         efiobj = efi_search_obj(handle);
2120         if (!efiobj)
2121                 return EFI_EXIT(EFI_INVALID_PARAMETER);
2122
2123         /* Count protocols */
2124         list_for_each(protocol_handle, &efiobj->protocols) {
2125                 ++*protocol_buffer_count;
2126         }
2127
2128         /* Copy GUIDs */
2129         if (*protocol_buffer_count) {
2130                 size_t j = 0;
2131
2132                 buffer_size = sizeof(efi_guid_t *) * *protocol_buffer_count;
2133                 r = efi_allocate_pool(EFI_BOOT_SERVICES_DATA, buffer_size,
2134                                       (void **)protocol_buffer);
2135                 if (r != EFI_SUCCESS)
2136                         return EFI_EXIT(r);
2137                 list_for_each(protocol_handle, &efiobj->protocols) {
2138                         struct efi_handler *protocol;
2139
2140                         protocol = list_entry(protocol_handle,
2141                                               struct efi_handler, link);
2142                         (*protocol_buffer)[j] = (void *)protocol->guid;
2143                         ++j;
2144                 }
2145         }
2146
2147         return EFI_EXIT(EFI_SUCCESS);
2148 }
2149
2150 /**
2151  * efi_locate_handle_buffer() - locate handles implementing a protocol
2152  * @search_type: selection criterion
2153  * @protocol:    GUID of the protocol
2154  * @search_key:  registration key
2155  * @no_handles:  number of returned handles
2156  * @buffer:      buffer with the returned handles
2157  *
2158  * This function implements the LocateHandleBuffer service.
2159  *
2160  * See the Unified Extensible Firmware Interface (UEFI) specification for
2161  * details.
2162  *
2163  * Return: status code
2164  */
2165 static efi_status_t EFIAPI efi_locate_handle_buffer(
2166                         enum efi_locate_search_type search_type,
2167                         const efi_guid_t *protocol, void *search_key,
2168                         efi_uintn_t *no_handles, efi_handle_t **buffer)
2169 {
2170         efi_status_t r;
2171         efi_uintn_t buffer_size = 0;
2172
2173         EFI_ENTRY("%d, %pUl, %p, %p, %p", search_type, protocol, search_key,
2174                   no_handles, buffer);
2175
2176         if (!no_handles || !buffer) {
2177                 r = EFI_INVALID_PARAMETER;
2178                 goto out;
2179         }
2180         *no_handles = 0;
2181         *buffer = NULL;
2182         r = efi_locate_handle(search_type, protocol, search_key, &buffer_size,
2183                               *buffer);
2184         if (r != EFI_BUFFER_TOO_SMALL)
2185                 goto out;
2186         r = efi_allocate_pool(EFI_BOOT_SERVICES_DATA, buffer_size,
2187                               (void **)buffer);
2188         if (r != EFI_SUCCESS)
2189                 goto out;
2190         r = efi_locate_handle(search_type, protocol, search_key, &buffer_size,
2191                               *buffer);
2192         if (r == EFI_SUCCESS)
2193                 *no_handles = buffer_size / sizeof(efi_handle_t);
2194 out:
2195         return EFI_EXIT(r);
2196 }
2197
2198 /**
2199  * efi_locate_protocol() - find an interface implementing a protocol
2200  * @protocol:           GUID of the protocol
2201  * @registration:       registration key passed to the notification function
2202  * @protocol_interface: interface implementing the protocol
2203  *
2204  * This function implements the LocateProtocol service.
2205  *
2206  * See the Unified Extensible Firmware Interface (UEFI) specification for
2207  * details.
2208  *
2209  * Return: status code
2210  */
2211 static efi_status_t EFIAPI efi_locate_protocol(const efi_guid_t *protocol,
2212                                                void *registration,
2213                                                void **protocol_interface)
2214 {
2215         struct list_head *lhandle;
2216         efi_status_t ret;
2217
2218         EFI_ENTRY("%pUl, %p, %p", protocol, registration, protocol_interface);
2219
2220         if (!protocol || !protocol_interface)
2221                 return EFI_EXIT(EFI_INVALID_PARAMETER);
2222
2223         list_for_each(lhandle, &efi_obj_list) {
2224                 struct efi_object *efiobj;
2225                 struct efi_handler *handler;
2226
2227                 efiobj = list_entry(lhandle, struct efi_object, link);
2228
2229                 ret = efi_search_protocol(efiobj, protocol, &handler);
2230                 if (ret == EFI_SUCCESS) {
2231                         *protocol_interface = handler->protocol_interface;
2232                         return EFI_EXIT(EFI_SUCCESS);
2233                 }
2234         }
2235         *protocol_interface = NULL;
2236
2237         return EFI_EXIT(EFI_NOT_FOUND);
2238 }
2239
2240 /**
2241  * efi_locate_device_path() - Get the device path and handle of an device
2242  *                            implementing a protocol
2243  * @protocol:    GUID of the protocol
2244  * @device_path: device path
2245  * @device:      handle of the device
2246  *
2247  * This function implements the LocateDevicePath service.
2248  *
2249  * See the Unified Extensible Firmware Interface (UEFI) specification for
2250  * details.
2251  *
2252  * Return: status code
2253  */
2254 static efi_status_t EFIAPI efi_locate_device_path(
2255                         const efi_guid_t *protocol,
2256                         struct efi_device_path **device_path,
2257                         efi_handle_t *device)
2258 {
2259         struct efi_device_path *dp;
2260         size_t i;
2261         struct efi_handler *handler;
2262         efi_handle_t *handles;
2263         size_t len, len_dp;
2264         size_t len_best = 0;
2265         efi_uintn_t no_handles;
2266         u8 *remainder;
2267         efi_status_t ret;
2268
2269         EFI_ENTRY("%pUl, %p, %p", protocol, device_path, device);
2270
2271         if (!protocol || !device_path || !*device_path) {
2272                 ret = EFI_INVALID_PARAMETER;
2273                 goto out;
2274         }
2275
2276         /* Find end of device path */
2277         len = efi_dp_instance_size(*device_path);
2278
2279         /* Get all handles implementing the protocol */
2280         ret = EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL, protocol, NULL,
2281                                                 &no_handles, &handles));
2282         if (ret != EFI_SUCCESS)
2283                 goto out;
2284
2285         for (i = 0; i < no_handles; ++i) {
2286                 /* Find the device path protocol */
2287                 ret = efi_search_protocol(handles[i], &efi_guid_device_path,
2288                                           &handler);
2289                 if (ret != EFI_SUCCESS)
2290                         continue;
2291                 dp = (struct efi_device_path *)handler->protocol_interface;
2292                 len_dp = efi_dp_instance_size(dp);
2293                 /*
2294                  * This handle can only be a better fit
2295                  * if its device path length is longer than the best fit and
2296                  * if its device path length is shorter of equal the searched
2297                  * device path.
2298                  */
2299                 if (len_dp <= len_best || len_dp > len)
2300                         continue;
2301                 /* Check if dp is a subpath of device_path */
2302                 if (memcmp(*device_path, dp, len_dp))
2303                         continue;
2304                 if (!device) {
2305                         ret = EFI_INVALID_PARAMETER;
2306                         goto out;
2307                 }
2308                 *device = handles[i];
2309                 len_best = len_dp;
2310         }
2311         if (len_best) {
2312                 remainder = (u8 *)*device_path + len_best;
2313                 *device_path = (struct efi_device_path *)remainder;
2314                 ret = EFI_SUCCESS;
2315         } else {
2316                 ret = EFI_NOT_FOUND;
2317         }
2318 out:
2319         return EFI_EXIT(ret);
2320 }
2321
2322 /**
2323  * efi_install_multiple_protocol_interfaces() - Install multiple protocol
2324  *                                              interfaces
2325  * @handle: handle on which the protocol interfaces shall be installed
2326  * @...:    NULL terminated argument list with pairs of protocol GUIDS and
2327  *          interfaces
2328  *
2329  * This function implements the MultipleProtocolInterfaces service.
2330  *
2331  * See the Unified Extensible Firmware Interface (UEFI) specification for
2332  * details.
2333  *
2334  * Return: status code
2335  */
2336 efi_status_t EFIAPI efi_install_multiple_protocol_interfaces
2337                                 (efi_handle_t *handle, ...)
2338 {
2339         EFI_ENTRY("%p", handle);
2340
2341         efi_va_list argptr;
2342         const efi_guid_t *protocol;
2343         void *protocol_interface;
2344         efi_handle_t old_handle;
2345         efi_status_t r = EFI_SUCCESS;
2346         int i = 0;
2347
2348         if (!handle)
2349                 return EFI_EXIT(EFI_INVALID_PARAMETER);
2350
2351         efi_va_start(argptr, handle);
2352         for (;;) {
2353                 protocol = efi_va_arg(argptr, efi_guid_t*);
2354                 if (!protocol)
2355                         break;
2356                 protocol_interface = efi_va_arg(argptr, void*);
2357                 /* Check that a device path has not been installed before */
2358                 if (!guidcmp(protocol, &efi_guid_device_path)) {
2359                         struct efi_device_path *dp = protocol_interface;
2360
2361                         r = EFI_CALL(efi_locate_device_path(protocol, &dp,
2362                                                             &old_handle));
2363                         if (r == EFI_SUCCESS) {
2364                                 r = EFI_ALREADY_STARTED;
2365                                 break;
2366                         }
2367                 }
2368                 r = EFI_CALL(efi_install_protocol_interface(
2369                                                 handle, protocol,
2370                                                 EFI_NATIVE_INTERFACE,
2371                                                 protocol_interface));
2372                 if (r != EFI_SUCCESS)
2373                         break;
2374                 i++;
2375         }
2376         efi_va_end(argptr);
2377         if (r == EFI_SUCCESS)
2378                 return EFI_EXIT(r);
2379
2380         /* If an error occurred undo all changes. */
2381         efi_va_start(argptr, handle);
2382         for (; i; --i) {
2383                 protocol = efi_va_arg(argptr, efi_guid_t*);
2384                 protocol_interface = efi_va_arg(argptr, void*);
2385                 EFI_CALL(efi_uninstall_protocol_interface(*handle, protocol,
2386                                                           protocol_interface));
2387         }
2388         efi_va_end(argptr);
2389
2390         return EFI_EXIT(r);
2391 }
2392
2393 /**
2394  * efi_uninstall_multiple_protocol_interfaces() - uninstall multiple protocol
2395  *                                                interfaces
2396  * @handle: handle from which the protocol interfaces shall be removed
2397  * @...:    NULL terminated argument list with pairs of protocol GUIDS and
2398  *          interfaces
2399  *
2400  * This function implements the UninstallMultipleProtocolInterfaces service.
2401  *
2402  * See the Unified Extensible Firmware Interface (UEFI) specification for
2403  * details.
2404  *
2405  * Return: status code
2406  */
2407 static efi_status_t EFIAPI efi_uninstall_multiple_protocol_interfaces(
2408                         efi_handle_t handle, ...)
2409 {
2410         EFI_ENTRY("%p", handle);
2411
2412         efi_va_list argptr;
2413         const efi_guid_t *protocol;
2414         void *protocol_interface;
2415         efi_status_t r = EFI_SUCCESS;
2416         size_t i = 0;
2417
2418         if (!handle)
2419                 return EFI_EXIT(EFI_INVALID_PARAMETER);
2420
2421         efi_va_start(argptr, handle);
2422         for (;;) {
2423                 protocol = efi_va_arg(argptr, efi_guid_t*);
2424                 if (!protocol)
2425                         break;
2426                 protocol_interface = efi_va_arg(argptr, void*);
2427                 r = efi_uninstall_protocol(handle, protocol,
2428                                            protocol_interface);
2429                 if (r != EFI_SUCCESS)
2430                         break;
2431                 i++;
2432         }
2433         efi_va_end(argptr);
2434         if (r == EFI_SUCCESS) {
2435                 /* If the last protocol has been removed, delete the handle. */
2436                 if (list_empty(&handle->protocols)) {
2437                         list_del(&handle->link);
2438                         free(handle);
2439                 }
2440                 return EFI_EXIT(r);
2441         }
2442
2443         /* If an error occurred undo all changes. */
2444         efi_va_start(argptr, handle);
2445         for (; i; --i) {
2446                 protocol = efi_va_arg(argptr, efi_guid_t*);
2447                 protocol_interface = efi_va_arg(argptr, void*);
2448                 EFI_CALL(efi_install_protocol_interface(&handle, protocol,
2449                                                         EFI_NATIVE_INTERFACE,
2450                                                         protocol_interface));
2451         }
2452         efi_va_end(argptr);
2453
2454         /* In case of an error always return EFI_INVALID_PARAMETER */
2455         return EFI_EXIT(EFI_INVALID_PARAMETER);
2456 }
2457
2458 /**
2459  * efi_calculate_crc32() - calculate cyclic redundancy code
2460  * @data:      buffer with data
2461  * @data_size: size of buffer in bytes
2462  * @crc32_p:   cyclic redundancy code
2463  *
2464  * This function implements the CalculateCrc32 service.
2465  *
2466  * See the Unified Extensible Firmware Interface (UEFI) specification for
2467  * details.
2468  *
2469  * Return: status code
2470  */
2471 static efi_status_t EFIAPI efi_calculate_crc32(const void *data,
2472                                                efi_uintn_t data_size,
2473                                                u32 *crc32_p)
2474 {
2475         efi_status_t ret = EFI_SUCCESS;
2476
2477         EFI_ENTRY("%p, %zu", data, data_size);
2478         if (!data || !data_size || !crc32_p) {
2479                 ret = EFI_INVALID_PARAMETER;
2480                 goto out;
2481         }
2482         *crc32_p = crc32(0, data, data_size);
2483 out:
2484         return EFI_EXIT(ret);
2485 }
2486
2487 /**
2488  * efi_copy_mem() - copy memory
2489  * @destination: destination of the copy operation
2490  * @source:      source of the copy operation
2491  * @length:      number of bytes to copy
2492  *
2493  * This function implements the CopyMem service.
2494  *
2495  * See the Unified Extensible Firmware Interface (UEFI) specification for
2496  * details.
2497  */
2498 static void EFIAPI efi_copy_mem(void *destination, const void *source,
2499                                 size_t length)
2500 {
2501         EFI_ENTRY("%p, %p, %ld", destination, source, (unsigned long)length);
2502         memmove(destination, source, length);
2503         EFI_EXIT(EFI_SUCCESS);
2504 }
2505
2506 /**
2507  * efi_set_mem() - Fill memory with a byte value.
2508  * @buffer: buffer to fill
2509  * @size:   size of buffer in bytes
2510  * @value:  byte to copy to the buffer
2511  *
2512  * This function implements the SetMem service.
2513  *
2514  * See the Unified Extensible Firmware Interface (UEFI) specification for
2515  * details.
2516  */
2517 static void EFIAPI efi_set_mem(void *buffer, size_t size, uint8_t value)
2518 {
2519         EFI_ENTRY("%p, %ld, 0x%x", buffer, (unsigned long)size, value);
2520         memset(buffer, value, size);
2521         EFI_EXIT(EFI_SUCCESS);
2522 }
2523
2524 /**
2525  * efi_protocol_open() - open protocol interface on a handle
2526  * @handler:            handler of a protocol
2527  * @protocol_interface: interface implementing the protocol
2528  * @agent_handle:       handle of the driver
2529  * @controller_handle:  handle of the controller
2530  * @attributes:         attributes indicating how to open the protocol
2531  *
2532  * Return: status code
2533  */
2534 static efi_status_t efi_protocol_open(
2535                         struct efi_handler *handler,
2536                         void **protocol_interface, void *agent_handle,
2537                         void *controller_handle, uint32_t attributes)
2538 {
2539         struct efi_open_protocol_info_item *item;
2540         struct efi_open_protocol_info_entry *match = NULL;
2541         bool opened_by_driver = false;
2542         bool opened_exclusive = false;
2543
2544         /* If there is no agent, only return the interface */
2545         if (!agent_handle)
2546                 goto out;
2547
2548         /* For TEST_PROTOCOL ignore interface attribute */
2549         if (attributes != EFI_OPEN_PROTOCOL_TEST_PROTOCOL)
2550                 *protocol_interface = NULL;
2551
2552         /*
2553          * Check if the protocol is already opened by a driver with the same
2554          * attributes or opened exclusively
2555          */
2556         list_for_each_entry(item, &handler->open_infos, link) {
2557                 if (item->info.agent_handle == agent_handle) {
2558                         if ((attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) &&
2559                             (item->info.attributes == attributes))
2560                                 return EFI_ALREADY_STARTED;
2561                 }
2562                 if (item->info.attributes & EFI_OPEN_PROTOCOL_EXCLUSIVE)
2563                         opened_exclusive = true;
2564         }
2565
2566         /* Only one controller can open the protocol exclusively */
2567         if (opened_exclusive && attributes &
2568             (EFI_OPEN_PROTOCOL_EXCLUSIVE | EFI_OPEN_PROTOCOL_BY_DRIVER))
2569                 return EFI_ACCESS_DENIED;
2570
2571         /* Prepare exclusive opening */
2572         if (attributes & EFI_OPEN_PROTOCOL_EXCLUSIVE) {
2573                 /* Try to disconnect controllers */
2574                 list_for_each_entry(item, &handler->open_infos, link) {
2575                         if (item->info.attributes ==
2576                                         EFI_OPEN_PROTOCOL_BY_DRIVER)
2577                                 EFI_CALL(efi_disconnect_controller(
2578                                                 item->info.controller_handle,
2579                                                 item->info.agent_handle,
2580                                                 NULL));
2581                 }
2582                 opened_by_driver = false;
2583                 /* Check if all controllers are disconnected */
2584                 list_for_each_entry(item, &handler->open_infos, link) {
2585                         if (item->info.attributes & EFI_OPEN_PROTOCOL_BY_DRIVER)
2586                                 opened_by_driver = true;
2587                 }
2588                 /* Only one controller can be connected */
2589                 if (opened_by_driver)
2590                         return EFI_ACCESS_DENIED;
2591         }
2592
2593         /* Find existing entry */
2594         list_for_each_entry(item, &handler->open_infos, link) {
2595                 if (item->info.agent_handle == agent_handle &&
2596                     item->info.controller_handle == controller_handle)
2597                         match = &item->info;
2598         }
2599         /* None found, create one */
2600         if (!match) {
2601                 match = efi_create_open_info(handler);
2602                 if (!match)
2603                         return EFI_OUT_OF_RESOURCES;
2604         }
2605
2606         match->agent_handle = agent_handle;
2607         match->controller_handle = controller_handle;
2608         match->attributes = attributes;
2609         match->open_count++;
2610
2611 out:
2612         /* For TEST_PROTOCOL ignore interface attribute. */
2613         if (attributes != EFI_OPEN_PROTOCOL_TEST_PROTOCOL)
2614                 *protocol_interface = handler->protocol_interface;
2615
2616         return EFI_SUCCESS;
2617 }
2618
2619 /**
2620  * efi_open_protocol() - open protocol interface on a handle
2621  * @handle:             handle on which the protocol shall be opened
2622  * @protocol:           GUID of the protocol
2623  * @protocol_interface: interface implementing the protocol
2624  * @agent_handle:       handle of the driver
2625  * @controller_handle:  handle of the controller
2626  * @attributes:         attributes indicating how to open the protocol
2627  *
2628  * This function implements the OpenProtocol interface.
2629  *
2630  * See the Unified Extensible Firmware Interface (UEFI) specification for
2631  * details.
2632  *
2633  * Return: status code
2634  */
2635 static efi_status_t EFIAPI efi_open_protocol
2636                         (efi_handle_t handle, const efi_guid_t *protocol,
2637                          void **protocol_interface, efi_handle_t agent_handle,
2638                          efi_handle_t controller_handle, uint32_t attributes)
2639 {
2640         struct efi_handler *handler;
2641         efi_status_t r = EFI_INVALID_PARAMETER;
2642
2643         EFI_ENTRY("%p, %pUl, %p, %p, %p, 0x%x", handle, protocol,
2644                   protocol_interface, agent_handle, controller_handle,
2645                   attributes);
2646
2647         if (!handle || !protocol ||
2648             (!protocol_interface && attributes !=
2649              EFI_OPEN_PROTOCOL_TEST_PROTOCOL)) {
2650                 goto out;
2651         }
2652
2653         switch (attributes) {
2654         case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL:
2655         case EFI_OPEN_PROTOCOL_GET_PROTOCOL:
2656         case EFI_OPEN_PROTOCOL_TEST_PROTOCOL:
2657                 break;
2658         case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER:
2659                 if (controller_handle == handle)
2660                         goto out;
2661                 /* fall-through */
2662         case EFI_OPEN_PROTOCOL_BY_DRIVER:
2663         case EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE:
2664                 /* Check that the controller handle is valid */
2665                 if (!efi_search_obj(controller_handle))
2666                         goto out;
2667                 /* fall-through */
2668         case EFI_OPEN_PROTOCOL_EXCLUSIVE:
2669                 /* Check that the agent handle is valid */
2670                 if (!efi_search_obj(agent_handle))
2671                         goto out;
2672                 break;
2673         default:
2674                 goto out;
2675         }
2676
2677         r = efi_search_protocol(handle, protocol, &handler);
2678         switch (r) {
2679         case EFI_SUCCESS:
2680                 break;
2681         case EFI_NOT_FOUND:
2682                 r = EFI_UNSUPPORTED;
2683                 goto out;
2684         default:
2685                 goto out;
2686         }
2687
2688         r = efi_protocol_open(handler, protocol_interface, agent_handle,
2689                               controller_handle, attributes);
2690 out:
2691         return EFI_EXIT(r);
2692 }
2693
2694 /**
2695  * efi_start_image() - call the entry point of an image
2696  * @image_handle:   handle of the image
2697  * @exit_data_size: size of the buffer
2698  * @exit_data:      buffer to receive the exit data of the called image
2699  *
2700  * This function implements the StartImage service.
2701  *
2702  * See the Unified Extensible Firmware Interface (UEFI) specification for
2703  * details.
2704  *
2705  * Return: status code
2706  */
2707 efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle,
2708                                     efi_uintn_t *exit_data_size,
2709                                     u16 **exit_data)
2710 {
2711         struct efi_loaded_image_obj *image_obj =
2712                 (struct efi_loaded_image_obj *)image_handle;
2713         efi_status_t ret;
2714         void *info;
2715         efi_handle_t parent_image = current_image;
2716
2717         EFI_ENTRY("%p, %p, %p", image_handle, exit_data_size, exit_data);
2718
2719         /* Check parameters */
2720         ret = EFI_CALL(efi_open_protocol(image_handle, &efi_guid_loaded_image,
2721                                          &info, NULL, NULL,
2722                                          EFI_OPEN_PROTOCOL_GET_PROTOCOL));
2723         if (ret != EFI_SUCCESS)
2724                 return EFI_EXIT(EFI_INVALID_PARAMETER);
2725
2726         efi_is_direct_boot = false;
2727
2728         image_obj->exit_data_size = exit_data_size;
2729         image_obj->exit_data = exit_data;
2730
2731         /* call the image! */
2732         if (setjmp(&image_obj->exit_jmp)) {
2733                 /*
2734                  * We called the entry point of the child image with EFI_CALL
2735                  * in the lines below. The child image called the Exit() boot
2736                  * service efi_exit() which executed the long jump that brought
2737                  * us to the current line. This implies that the second half
2738                  * of the EFI_CALL macro has not been executed.
2739                  */
2740 #ifdef CONFIG_ARM
2741                 /*
2742                  * efi_exit() called efi_restore_gd(). We have to undo this
2743                  * otherwise __efi_entry_check() will put the wrong value into
2744                  * app_gd.
2745                  */
2746                 gd = app_gd;
2747 #endif
2748                 /*
2749                  * To get ready to call EFI_EXIT below we have to execute the
2750                  * missed out steps of EFI_CALL.
2751                  */
2752                 assert(__efi_entry_check());
2753                 EFI_PRINT("%lu returned by started image\n",
2754                           (unsigned long)((uintptr_t)image_obj->exit_status &
2755                           ~EFI_ERROR_MASK));
2756                 current_image = parent_image;
2757                 return EFI_EXIT(image_obj->exit_status);
2758         }
2759
2760         current_image = image_handle;
2761         image_obj->header.type = EFI_OBJECT_TYPE_STARTED_IMAGE;
2762         EFI_PRINT("Jumping into 0x%p\n", image_obj->entry);
2763         ret = EFI_CALL(image_obj->entry(image_handle, &systab));
2764
2765         /*
2766          * Usually UEFI applications call Exit() instead of returning.
2767          * But because the world doesn't consist of ponies and unicorns,
2768          * we're happy to emulate that behavior on behalf of a payload
2769          * that forgot.
2770          */
2771         return EFI_CALL(systab.boottime->exit(image_handle, ret, 0, NULL));
2772 }
2773
2774 /**
2775  * efi_delete_image() - delete loaded image from memory)
2776  *
2777  * @image_obj:                  handle of the loaded image
2778  * @loaded_image_protocol:      loaded image protocol
2779  */
2780 static void efi_delete_image(struct efi_loaded_image_obj *image_obj,
2781                              struct efi_loaded_image *loaded_image_protocol)
2782 {
2783         efi_free_pages((uintptr_t)loaded_image_protocol->image_base,
2784                        efi_size_in_pages(loaded_image_protocol->image_size));
2785         efi_delete_handle(&image_obj->header);
2786 }
2787
2788 /**
2789  * efi_unload_image() - unload an EFI image
2790  * @image_handle: handle of the image to be unloaded
2791  *
2792  * This function implements the UnloadImage service.
2793  *
2794  * See the Unified Extensible Firmware Interface (UEFI) specification for
2795  * details.
2796  *
2797  * Return: status code
2798  */
2799 efi_status_t EFIAPI efi_unload_image(efi_handle_t image_handle)
2800 {
2801         efi_status_t ret = EFI_SUCCESS;
2802         struct efi_object *efiobj;
2803         struct efi_loaded_image *loaded_image_protocol;
2804
2805         EFI_ENTRY("%p", image_handle);
2806
2807         efiobj = efi_search_obj(image_handle);
2808         if (!efiobj) {
2809                 ret = EFI_INVALID_PARAMETER;
2810                 goto out;
2811         }
2812         /* Find the loaded image protocol */
2813         ret = EFI_CALL(efi_open_protocol(image_handle, &efi_guid_loaded_image,
2814                                          (void **)&loaded_image_protocol,
2815                                          NULL, NULL,
2816                                          EFI_OPEN_PROTOCOL_GET_PROTOCOL));
2817         if (ret != EFI_SUCCESS) {
2818                 ret = EFI_INVALID_PARAMETER;
2819                 goto out;
2820         }
2821         switch (efiobj->type) {
2822         case EFI_OBJECT_TYPE_STARTED_IMAGE:
2823                 /* Call the unload function */
2824                 if (!loaded_image_protocol->unload) {
2825                         ret = EFI_UNSUPPORTED;
2826                         goto out;
2827                 }
2828                 ret = EFI_CALL(loaded_image_protocol->unload(image_handle));
2829                 if (ret != EFI_SUCCESS)
2830                         goto out;
2831                 break;
2832         case EFI_OBJECT_TYPE_LOADED_IMAGE:
2833                 break;
2834         default:
2835                 ret = EFI_INVALID_PARAMETER;
2836                 goto out;
2837         }
2838         efi_delete_image((struct efi_loaded_image_obj *)efiobj,
2839                          loaded_image_protocol);
2840 out:
2841         return EFI_EXIT(ret);
2842 }
2843
2844 /**
2845  * efi_update_exit_data() - fill exit data parameters of StartImage()
2846  *
2847  * @image_obj           image handle
2848  * @exit_data_size      size of the exit data buffer
2849  * @exit_data           buffer with data returned by UEFI payload
2850  * Return:              status code
2851  */
2852 static efi_status_t efi_update_exit_data(struct efi_loaded_image_obj *image_obj,
2853                                          efi_uintn_t exit_data_size,
2854                                          u16 *exit_data)
2855 {
2856         efi_status_t ret;
2857
2858         /*
2859          * If exit_data is not provided to StartImage(), exit_data_size must be
2860          * ignored.
2861          */
2862         if (!image_obj->exit_data)
2863                 return EFI_SUCCESS;
2864         if (image_obj->exit_data_size)
2865                 *image_obj->exit_data_size = exit_data_size;
2866         if (exit_data_size && exit_data) {
2867                 ret = efi_allocate_pool(EFI_BOOT_SERVICES_DATA,
2868                                         exit_data_size,
2869                                         (void **)image_obj->exit_data);
2870                 if (ret != EFI_SUCCESS)
2871                         return ret;
2872                 memcpy(*image_obj->exit_data, exit_data, exit_data_size);
2873         } else {
2874                 image_obj->exit_data = NULL;
2875         }
2876         return EFI_SUCCESS;
2877 }
2878
2879 /**
2880  * efi_exit() - leave an EFI application or driver
2881  * @image_handle:   handle of the application or driver that is exiting
2882  * @exit_status:    status code
2883  * @exit_data_size: size of the buffer in bytes
2884  * @exit_data:      buffer with data describing an error
2885  *
2886  * This function implements the Exit service.
2887  *
2888  * See the Unified Extensible Firmware Interface (UEFI) specification for
2889  * details.
2890  *
2891  * Return: status code
2892  */
2893 static efi_status_t EFIAPI efi_exit(efi_handle_t image_handle,
2894                                     efi_status_t exit_status,
2895                                     efi_uintn_t exit_data_size,
2896                                     u16 *exit_data)
2897 {
2898         /*
2899          * TODO: We should call the unload procedure of the loaded
2900          *       image protocol.
2901          */
2902         efi_status_t ret;
2903         struct efi_loaded_image *loaded_image_protocol;
2904         struct efi_loaded_image_obj *image_obj =
2905                 (struct efi_loaded_image_obj *)image_handle;
2906
2907         EFI_ENTRY("%p, %ld, %zu, %p", image_handle, exit_status,
2908                   exit_data_size, exit_data);
2909
2910         /* Check parameters */
2911         ret = EFI_CALL(efi_open_protocol(image_handle, &efi_guid_loaded_image,
2912                                          (void **)&loaded_image_protocol,
2913                                          NULL, NULL,
2914                                          EFI_OPEN_PROTOCOL_GET_PROTOCOL));
2915         if (ret != EFI_SUCCESS) {
2916                 ret = EFI_INVALID_PARAMETER;
2917                 goto out;
2918         }
2919
2920         /* Unloading of unstarted images */
2921         switch (image_obj->header.type) {
2922         case EFI_OBJECT_TYPE_STARTED_IMAGE:
2923                 break;
2924         case EFI_OBJECT_TYPE_LOADED_IMAGE:
2925                 efi_delete_image(image_obj, loaded_image_protocol);
2926                 ret = EFI_SUCCESS;
2927                 goto out;
2928         default:
2929                 /* Handle does not refer to loaded image */
2930                 ret = EFI_INVALID_PARAMETER;
2931                 goto out;
2932         }
2933         /* A started image can only be unloaded it is the last one started. */
2934         if (image_handle != current_image) {
2935                 ret = EFI_INVALID_PARAMETER;
2936                 goto out;
2937         }
2938
2939         /* Exit data is only foreseen in case of failure. */
2940         if (exit_status != EFI_SUCCESS) {
2941                 ret = efi_update_exit_data(image_obj, exit_data_size,
2942                                            exit_data);
2943                 /* Exiting has priority. Don't return error to caller. */
2944                 if (ret != EFI_SUCCESS)
2945                         EFI_PRINT("%s: out of memory\n", __func__);
2946         }
2947         if (image_obj->image_type == IMAGE_SUBSYSTEM_EFI_APPLICATION ||
2948             exit_status != EFI_SUCCESS)
2949                 efi_delete_image(image_obj, loaded_image_protocol);
2950
2951         /* Make sure entry/exit counts for EFI world cross-overs match */
2952         EFI_EXIT(exit_status);
2953
2954         /*
2955          * But longjmp out with the U-Boot gd, not the application's, as
2956          * the other end is a setjmp call inside EFI context.
2957          */
2958         efi_restore_gd();
2959
2960         image_obj->exit_status = exit_status;
2961         longjmp(&image_obj->exit_jmp, 1);
2962
2963         panic("EFI application exited");
2964 out:
2965         return EFI_EXIT(ret);
2966 }
2967
2968 /**
2969  * efi_handle_protocol() - get interface of a protocol on a handle
2970  * @handle:             handle on which the protocol shall be opened
2971  * @protocol:           GUID of the protocol
2972  * @protocol_interface: interface implementing the protocol
2973  *
2974  * This function implements the HandleProtocol service.
2975  *
2976  * See the Unified Extensible Firmware Interface (UEFI) specification for
2977  * details.
2978  *
2979  * Return: status code
2980  */
2981 static efi_status_t EFIAPI efi_handle_protocol(efi_handle_t handle,
2982                                                const efi_guid_t *protocol,
2983                                                void **protocol_interface)
2984 {
2985         return efi_open_protocol(handle, protocol, protocol_interface, NULL,
2986                                  NULL, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
2987 }
2988
2989 /**
2990  * efi_bind_controller() - bind a single driver to a controller
2991  * @controller_handle:   controller handle
2992  * @driver_image_handle: driver handle
2993  * @remain_device_path:  remaining path
2994  *
2995  * Return: status code
2996  */
2997 static efi_status_t efi_bind_controller(
2998                         efi_handle_t controller_handle,
2999                         efi_handle_t driver_image_handle,
3000                         struct efi_device_path *remain_device_path)
3001 {
3002         struct efi_driver_binding_protocol *binding_protocol;
3003         efi_status_t r;
3004
3005         r = EFI_CALL(efi_open_protocol(driver_image_handle,
3006                                        &efi_guid_driver_binding_protocol,
3007                                        (void **)&binding_protocol,
3008                                        driver_image_handle, NULL,
3009                                        EFI_OPEN_PROTOCOL_GET_PROTOCOL));
3010         if (r != EFI_SUCCESS)
3011                 return r;
3012         r = EFI_CALL(binding_protocol->supported(binding_protocol,
3013                                                  controller_handle,
3014                                                  remain_device_path));
3015         if (r == EFI_SUCCESS)
3016                 r = EFI_CALL(binding_protocol->start(binding_protocol,
3017                                                      controller_handle,
3018                                                      remain_device_path));
3019         EFI_CALL(efi_close_protocol(driver_image_handle,
3020                                     &efi_guid_driver_binding_protocol,
3021                                     driver_image_handle, NULL));
3022         return r;
3023 }
3024
3025 /**
3026  * efi_connect_single_controller() - connect a single driver to a controller
3027  * @controller_handle:   controller
3028  * @driver_image_handle: driver
3029  * @remain_device_path:  remaining path
3030  *
3031  * Return: status code
3032  */
3033 static efi_status_t efi_connect_single_controller(
3034                         efi_handle_t controller_handle,
3035                         efi_handle_t *driver_image_handle,
3036                         struct efi_device_path *remain_device_path)
3037 {
3038         efi_handle_t *buffer;
3039         size_t count;
3040         size_t i;
3041         efi_status_t r;
3042         size_t connected = 0;
3043
3044         /* Get buffer with all handles with driver binding protocol */
3045         r = EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL,
3046                                               &efi_guid_driver_binding_protocol,
3047                                               NULL, &count, &buffer));
3048         if (r != EFI_SUCCESS)
3049                 return r;
3050
3051         /*  Context Override */
3052         if (driver_image_handle) {
3053                 for (; *driver_image_handle; ++driver_image_handle) {
3054                         for (i = 0; i < count; ++i) {
3055                                 if (buffer[i] == *driver_image_handle) {
3056                                         buffer[i] = NULL;
3057                                         r = efi_bind_controller(
3058                                                         controller_handle,
3059                                                         *driver_image_handle,
3060                                                         remain_device_path);
3061                                         /*
3062                                          * For drivers that do not support the
3063                                          * controller or are already connected
3064                                          * we receive an error code here.
3065                                          */
3066                                         if (r == EFI_SUCCESS)
3067                                                 ++connected;
3068                                 }
3069                         }
3070                 }
3071         }
3072
3073         /*
3074          * TODO: Some overrides are not yet implemented:
3075          * - Platform Driver Override
3076          * - Driver Family Override Search
3077          * - Bus Specific Driver Override
3078          */
3079
3080         /* Driver Binding Search */
3081         for (i = 0; i < count; ++i) {
3082                 if (buffer[i]) {
3083                         r = efi_bind_controller(controller_handle,
3084                                                 buffer[i],
3085                                                 remain_device_path);
3086                         if (r == EFI_SUCCESS)
3087                                 ++connected;
3088                 }
3089         }
3090
3091         efi_free_pool(buffer);
3092         if (!connected)
3093                 return EFI_NOT_FOUND;
3094         return EFI_SUCCESS;
3095 }
3096
3097 /**
3098  * efi_connect_controller() - connect a controller to a driver
3099  * @controller_handle:   handle of the controller
3100  * @driver_image_handle: handle of the driver
3101  * @remain_device_path:  device path of a child controller
3102  * @recursive:           true to connect all child controllers
3103  *
3104  * This function implements the ConnectController service.
3105  *
3106  * See the Unified Extensible Firmware Interface (UEFI) specification for
3107  * details.
3108  *
3109  * First all driver binding protocol handles are tried for binding drivers.
3110  * Afterwards all handles that have opened a protocol of the controller
3111  * with EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER are connected to drivers.
3112  *
3113  * Return: status code
3114  */
3115 static efi_status_t EFIAPI efi_connect_controller(
3116                         efi_handle_t controller_handle,
3117                         efi_handle_t *driver_image_handle,
3118                         struct efi_device_path *remain_device_path,
3119                         bool recursive)
3120 {
3121         efi_status_t r;
3122         efi_status_t ret = EFI_NOT_FOUND;
3123         struct efi_object *efiobj;
3124
3125         EFI_ENTRY("%p, %p, %pD, %d", controller_handle, driver_image_handle,
3126                   remain_device_path, recursive);
3127
3128         efiobj = efi_search_obj(controller_handle);
3129         if (!efiobj) {
3130                 ret = EFI_INVALID_PARAMETER;
3131                 goto out;
3132         }
3133
3134         r = efi_connect_single_controller(controller_handle,
3135                                           driver_image_handle,
3136                                           remain_device_path);
3137         if (r == EFI_SUCCESS)
3138                 ret = EFI_SUCCESS;
3139         if (recursive) {
3140                 struct efi_handler *handler;
3141                 struct efi_open_protocol_info_item *item;
3142
3143                 list_for_each_entry(handler, &efiobj->protocols, link) {
3144                         list_for_each_entry(item, &handler->open_infos, link) {
3145                                 if (item->info.attributes &
3146                                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) {
3147                                         r = EFI_CALL(efi_connect_controller(
3148                                                 item->info.controller_handle,
3149                                                 driver_image_handle,
3150                                                 remain_device_path,
3151                                                 recursive));
3152                                         if (r == EFI_SUCCESS)
3153                                                 ret = EFI_SUCCESS;
3154                                 }
3155                         }
3156                 }
3157         }
3158         /*  Check for child controller specified by end node */
3159         if (ret != EFI_SUCCESS && remain_device_path &&
3160             remain_device_path->type == DEVICE_PATH_TYPE_END)
3161                 ret = EFI_SUCCESS;
3162 out:
3163         return EFI_EXIT(ret);
3164 }
3165
3166 /**
3167  * efi_reinstall_protocol_interface() - reinstall protocol interface
3168  * @handle:        handle on which the protocol shall be reinstalled
3169  * @protocol:      GUID of the protocol to be installed
3170  * @old_interface: interface to be removed
3171  * @new_interface: interface to be installed
3172  *
3173  * This function implements the ReinstallProtocolInterface service.
3174  *
3175  * See the Unified Extensible Firmware Interface (UEFI) specification for
3176  * details.
3177  *
3178  * The old interface is uninstalled. The new interface is installed.
3179  * Drivers are connected.
3180  *
3181  * Return: status code
3182  */
3183 static efi_status_t EFIAPI efi_reinstall_protocol_interface(
3184                         efi_handle_t handle, const efi_guid_t *protocol,
3185                         void *old_interface, void *new_interface)
3186 {
3187         efi_status_t ret;
3188
3189         EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol, old_interface,
3190                   new_interface);
3191
3192         /* Uninstall protocol but do not delete handle */
3193         ret = efi_uninstall_protocol(handle, protocol, old_interface);
3194         if (ret != EFI_SUCCESS)
3195                 goto out;
3196
3197         /* Install the new protocol */
3198         ret = efi_add_protocol(handle, protocol, new_interface);
3199         /*
3200          * The UEFI spec does not specify what should happen to the handle
3201          * if in case of an error no protocol interface remains on the handle.
3202          * So let's do nothing here.
3203          */
3204         if (ret != EFI_SUCCESS)
3205                 goto out;
3206         /*
3207          * The returned status code has to be ignored.
3208          * Do not create an error if no suitable driver for the handle exists.
3209          */
3210         EFI_CALL(efi_connect_controller(handle, NULL, NULL, true));
3211 out:
3212         return EFI_EXIT(ret);
3213 }
3214
3215 /**
3216  * efi_get_child_controllers() - get all child controllers associated to a driver
3217  * @efiobj:              handle of the controller
3218  * @driver_handle:       handle of the driver
3219  * @number_of_children:  number of child controllers
3220  * @child_handle_buffer: handles of the the child controllers
3221  *
3222  * The allocated buffer has to be freed with free().
3223  *
3224  * Return: status code
3225  */
3226 static efi_status_t efi_get_child_controllers(
3227                                 struct efi_object *efiobj,
3228                                 efi_handle_t driver_handle,
3229                                 efi_uintn_t *number_of_children,
3230                                 efi_handle_t **child_handle_buffer)
3231 {
3232         struct efi_handler *handler;
3233         struct efi_open_protocol_info_item *item;
3234         efi_uintn_t count = 0, i;
3235         bool duplicate;
3236
3237         /* Count all child controller associations */
3238         list_for_each_entry(handler, &efiobj->protocols, link) {
3239                 list_for_each_entry(item, &handler->open_infos, link) {
3240                         if (item->info.agent_handle == driver_handle &&
3241                             item->info.attributes &
3242                             EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER)
3243                                 ++count;
3244                 }
3245         }
3246         /*
3247          * Create buffer. In case of duplicate child controller assignments
3248          * the buffer will be too large. But that does not harm.
3249          */
3250         *number_of_children = 0;
3251         *child_handle_buffer = calloc(count, sizeof(efi_handle_t));
3252         if (!*child_handle_buffer)
3253                 return EFI_OUT_OF_RESOURCES;
3254         /* Copy unique child handles */
3255         list_for_each_entry(handler, &efiobj->protocols, link) {
3256                 list_for_each_entry(item, &handler->open_infos, link) {
3257                         if (item->info.agent_handle == driver_handle &&
3258                             item->info.attributes &
3259                             EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) {
3260                                 /* Check this is a new child controller */
3261                                 duplicate = false;
3262                                 for (i = 0; i < *number_of_children; ++i) {
3263                                         if ((*child_handle_buffer)[i] ==
3264                                             item->info.controller_handle)
3265                                                 duplicate = true;
3266                                 }
3267                                 /* Copy handle to buffer */
3268                                 if (!duplicate) {
3269                                         i = (*number_of_children)++;
3270                                         (*child_handle_buffer)[i] =
3271                                                 item->info.controller_handle;
3272                                 }
3273                         }
3274                 }
3275         }
3276         return EFI_SUCCESS;
3277 }
3278
3279 /**
3280  * efi_disconnect_controller() - disconnect a controller from a driver
3281  * @controller_handle:   handle of the controller
3282  * @driver_image_handle: handle of the driver
3283  * @child_handle:        handle of the child to destroy
3284  *
3285  * This function implements the DisconnectController service.
3286  *
3287  * See the Unified Extensible Firmware Interface (UEFI) specification for
3288  * details.
3289  *
3290  * Return: status code
3291  */
3292 static efi_status_t EFIAPI efi_disconnect_controller(
3293                                 efi_handle_t controller_handle,
3294                                 efi_handle_t driver_image_handle,
3295                                 efi_handle_t child_handle)
3296 {
3297         struct efi_driver_binding_protocol *binding_protocol;
3298         efi_handle_t *child_handle_buffer = NULL;
3299         size_t number_of_children = 0;
3300         efi_status_t r;
3301         size_t stop_count = 0;
3302         struct efi_object *efiobj;
3303
3304         EFI_ENTRY("%p, %p, %p", controller_handle, driver_image_handle,
3305                   child_handle);
3306
3307         efiobj = efi_search_obj(controller_handle);
3308         if (!efiobj) {
3309                 r = EFI_INVALID_PARAMETER;
3310                 goto out;
3311         }
3312
3313         if (child_handle && !efi_search_obj(child_handle)) {
3314                 r = EFI_INVALID_PARAMETER;
3315                 goto out;
3316         }
3317
3318         /* If no driver handle is supplied, disconnect all drivers */
3319         if (!driver_image_handle) {
3320                 r = efi_disconnect_all_drivers(efiobj, NULL, child_handle);
3321                 goto out;
3322         }
3323
3324         /* Create list of child handles */
3325         if (child_handle) {
3326                 number_of_children = 1;
3327                 child_handle_buffer = &child_handle;
3328         } else {
3329                 efi_get_child_controllers(efiobj,
3330                                           driver_image_handle,
3331                                           &number_of_children,
3332                                           &child_handle_buffer);
3333         }
3334
3335         /* Get the driver binding protocol */
3336         r = EFI_CALL(efi_open_protocol(driver_image_handle,
3337                                        &efi_guid_driver_binding_protocol,
3338                                        (void **)&binding_protocol,
3339                                        driver_image_handle, NULL,
3340                                        EFI_OPEN_PROTOCOL_GET_PROTOCOL));
3341         if (r != EFI_SUCCESS)
3342                 goto out;
3343         /* Remove the children */
3344         if (number_of_children) {
3345                 r = EFI_CALL(binding_protocol->stop(binding_protocol,
3346                                                     controller_handle,
3347                                                     number_of_children,
3348                                                     child_handle_buffer));
3349                 if (r == EFI_SUCCESS)
3350                         ++stop_count;
3351         }
3352         /* Remove the driver */
3353         if (!child_handle)
3354                 r = EFI_CALL(binding_protocol->stop(binding_protocol,
3355                                                     controller_handle,
3356                                                     0, NULL));
3357         if (r == EFI_SUCCESS)
3358                 ++stop_count;
3359         EFI_CALL(efi_close_protocol(driver_image_handle,
3360                                     &efi_guid_driver_binding_protocol,
3361                                     driver_image_handle, NULL));
3362
3363         if (stop_count)
3364                 r = EFI_SUCCESS;
3365         else
3366                 r = EFI_NOT_FOUND;
3367 out:
3368         if (!child_handle)
3369                 free(child_handle_buffer);
3370         return EFI_EXIT(r);
3371 }
3372
3373 static struct efi_boot_services efi_boot_services = {
3374         .hdr = {
3375                 .signature = EFI_BOOT_SERVICES_SIGNATURE,
3376                 .revision = EFI_SPECIFICATION_VERSION,
3377                 .headersize = sizeof(struct efi_boot_services),
3378         },
3379         .raise_tpl = efi_raise_tpl,
3380         .restore_tpl = efi_restore_tpl,
3381         .allocate_pages = efi_allocate_pages_ext,
3382         .free_pages = efi_free_pages_ext,
3383         .get_memory_map = efi_get_memory_map_ext,
3384         .allocate_pool = efi_allocate_pool_ext,
3385         .free_pool = efi_free_pool_ext,
3386         .create_event = efi_create_event_ext,
3387         .set_timer = efi_set_timer_ext,
3388         .wait_for_event = efi_wait_for_event,
3389         .signal_event = efi_signal_event_ext,
3390         .close_event = efi_close_event,
3391         .check_event = efi_check_event,
3392         .install_protocol_interface = efi_install_protocol_interface,
3393         .reinstall_protocol_interface = efi_reinstall_protocol_interface,
3394         .uninstall_protocol_interface = efi_uninstall_protocol_interface,
3395         .handle_protocol = efi_handle_protocol,
3396         .reserved = NULL,
3397         .register_protocol_notify = efi_register_protocol_notify,
3398         .locate_handle = efi_locate_handle_ext,
3399         .locate_device_path = efi_locate_device_path,
3400         .install_configuration_table = efi_install_configuration_table_ext,
3401         .load_image = efi_load_image,
3402         .start_image = efi_start_image,
3403         .exit = efi_exit,
3404         .unload_image = efi_unload_image,
3405         .exit_boot_services = efi_exit_boot_services,
3406         .get_next_monotonic_count = efi_get_next_monotonic_count,
3407         .stall = efi_stall,
3408         .set_watchdog_timer = efi_set_watchdog_timer,
3409         .connect_controller = efi_connect_controller,
3410         .disconnect_controller = efi_disconnect_controller,
3411         .open_protocol = efi_open_protocol,
3412         .close_protocol = efi_close_protocol,
3413         .open_protocol_information = efi_open_protocol_information,
3414         .protocols_per_handle = efi_protocols_per_handle,
3415         .locate_handle_buffer = efi_locate_handle_buffer,
3416         .locate_protocol = efi_locate_protocol,
3417         .install_multiple_protocol_interfaces =
3418                         efi_install_multiple_protocol_interfaces,
3419         .uninstall_multiple_protocol_interfaces =
3420                         efi_uninstall_multiple_protocol_interfaces,
3421         .calculate_crc32 = efi_calculate_crc32,
3422         .copy_mem = efi_copy_mem,
3423         .set_mem = efi_set_mem,
3424         .create_event_ex = efi_create_event_ex,
3425 };
3426
3427 static u16 __efi_runtime_data firmware_vendor[] = L"Das U-Boot";
3428
3429 struct efi_system_table __efi_runtime_data systab = {
3430         .hdr = {
3431                 .signature = EFI_SYSTEM_TABLE_SIGNATURE,
3432                 .revision = EFI_SPECIFICATION_VERSION,
3433                 .headersize = sizeof(struct efi_system_table),
3434         },
3435         .fw_vendor = firmware_vendor,
3436         .fw_revision = FW_VERSION << 16 | FW_PATCHLEVEL << 8,
3437         .con_in = (void *)&efi_con_in,
3438         .con_out = (void *)&efi_con_out,
3439         .std_err = (void *)&efi_con_out,
3440         .runtime = (void *)&efi_runtime_services,
3441         .boottime = (void *)&efi_boot_services,
3442         .nr_tables = 0,
3443         .tables = NULL,
3444 };
3445
3446 /**
3447  * efi_initialize_system_table() - Initialize system table
3448  *
3449  * Return:      status code
3450  */
3451 efi_status_t efi_initialize_system_table(void)
3452 {
3453         efi_status_t ret;
3454
3455         /* Allocate configuration table array */
3456         ret = efi_allocate_pool(EFI_RUNTIME_SERVICES_DATA,
3457                                 EFI_MAX_CONFIGURATION_TABLES *
3458                                 sizeof(struct efi_configuration_table),
3459                                 (void **)&systab.tables);
3460
3461         /* Set CRC32 field in table headers */
3462         efi_update_table_header_crc32(&systab.hdr);
3463         efi_update_table_header_crc32(&efi_runtime_services.hdr);
3464         efi_update_table_header_crc32(&efi_boot_services.hdr);
3465
3466         return ret;
3467 }