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

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