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