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