MdeModulePkg/Core/Dxe/DxeMain.h

   1 /*++
   2
   3 Copyright (c) 2006 - 2007, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   DxeMain.h
  15
  16 Abstract:
  17
  18 Revision History
  19
  20 --*/
  21
  22 #ifndef _DXE_MAIN_H_
  23 #define _DXE_MAIN_H_
  24
  25
  26 //
  27 // The package level header files this module uses
  28 //
  29 #include <PiDxe.h>
  30 #include <FrameworkPei.h>
  31 //
  32 // The protocols, PPI and GUID defintions for this module
  33 //
  34 #include <Protocol/LoadedImage.h>
  35 #include <Protocol/GuidedSectionExtraction.h>
  36 #include <Protocol/SectionExtraction.h>
  37 #include <Guid/DebugImageInfoTable.h>
  38 #include <Protocol/DevicePath.h>
  39 #include <Protocol/Runtime.h>
  40 #include <Protocol/LoadFile.h>
  41 #include <Protocol/DriverBinding.h>
  42 #include <Protocol/VariableWrite.h>
  43 #include <Protocol/PlatformDriverOverride.h>
  44 #include <Protocol/Variable.h>
  45 #include <Guid/MemoryTypeInformation.h>
  46 #include <Guid/FirmwareFileSystem2.h>
  47 #include <Guid/HobList.h>
  48 #include <Protocol/Timer.h>
  49 #include <Protocol/SimpleFileSystem.h>
  50 #include <Protocol/Bds.h>
  51 #include <Guid/FileInfo.h>
  52 #include <Protocol/RealTimeClock.h>
  53 #include <Guid/Apriori.h>
  54 #include <Protocol/WatchdogTimer.h>
  55 #include <Protocol/FirmwareVolume.h>
  56 #include <Protocol/MonotonicCounter.h>
  57 #include <Guid/DxeServices.h>
  58 #include <Guid/MemoryAllocationHob.h>
  59 #include <Protocol/StatusCode.h>
  60 #include <Protocol/CustomizedDecompress.h>
  61 #include <Protocol/Decompress.h>
  62 #include <Protocol/LoadPe32Image.h>
  63 #include <Protocol/FirmwareVolumeDispatch.h>
  64 #include <Protocol/Security.h>
  65 #include <Protocol/Ebc.h>
  66 #include <Guid/EventLegacyBios.h>
  67 #include <Protocol/Reset.h>
  68 #include <Protocol/EdkDecompress.h>
  69 #include <Protocol/Cpu.h>
  70 #include <Guid/EventGroup.h>
  71 #include <Protocol/Metronome.h>
  72 #include <Protocol/FirmwareVolumeBlock.h>
  73 #include <Protocol/Capsule.h>
  74 #include <Protocol/BusSpecificDriverOverride.h>
  75 #include <Protocol/Performance.h>
  76 #include <Guid/StatusCodeDataTypeId.h>
  77 //
  78 // The Library classes this module consumes
  79 //
  80 #include <Library/DxeCoreEntryPoint.h>
  81 #include <Library/DebugLib.h>
  82 #include <Library/UefiLib.h>
  83 #include <Library/BaseLib.h>
  84 #include <Library/HobLib.h>
  85 #include <Library/PerformanceLib.h>
  86 #include <Library/UefiDecompressLib.h>
  87 #include <Library/CustomDecompressLib.h>
  88 #include <Library/PeCoffLoaderLib.h>
  89 #include <Library/CacheMaintenanceLib.h>
  90 #include <Library/BaseMemoryLib.h>
  91
  92 #include "DebugImageInfo.h"
  93 #include "Library.h"
  94 #include "FwVolBlock.h"
  95 #include "FwVolDriver.h"
  96 #include "gcd.h"
  97 #include "imem.h"
  98 #include "Image.h"
  99 #include "Exec.h"
 100 #include "hand.h"
 101
 102
 103 //
 104 // Modifier for EFI DXE Services
 105 //
 106 #define EFI_DXESERVICE
 107
 108 //
 109 // attributes for reserved memory before it is promoted to system memory
 110 //
 111 #define EFI_MEMORY_PRESENT      0x0100000000000000ULL
 112 #define EFI_MEMORY_INITIALIZED  0x0200000000000000ULL
 113 #define EFI_MEMORY_TESTED       0x0400000000000000ULL
 114
 115 //
 116 // range for memory mapped port I/O on IPF
 117 //
 118 #define EFI_MEMORY_PORT_IO  0x4000000000000000ULL
 119
 120
 121 ///
 122 /// EFI_DEP_REPLACE_TRUE - Used to dynamically patch the dependecy expression
 123 ///                        to save time.  A EFI_DEP_PUSH is evauated one an
 124 ///                        replaced with EFI_DEP_REPLACE_TRUE
 125 ///
 126 #define EFI_DEP_REPLACE_TRUE  0xff
 127
 128 ///
 129 /// Define the initial size of the dependency expression evaluation stack
 130 ///
 131 #define DEPEX_STACK_SIZE_INCREMENT  0x1000
 132
 133 typedef struct {
 134   EFI_GUID                    *ProtocolGuid;
 135   VOID                        **Protocol;
 136   EFI_EVENT                   Event;
 137   VOID                        *Registration;
 138   BOOLEAN                     Present;
 139 } ARCHITECTURAL_PROTOCOL_ENTRY;
 140
 141
 142 //
 143 // DXE Dispatcher Data structures
 144 //
 145
 146 #define KNOWN_HANDLE_SIGNATURE  EFI_SIGNATURE_32('k','n','o','w')
 147 typedef struct {
 148   UINTN           Signature;
 149   LIST_ENTRY      Link;         // mFvHandleList
 150   EFI_HANDLE      Handle;
 151 } KNOWN_HANDLE;
 152
 153
 154 #define EFI_CORE_DRIVER_ENTRY_SIGNATURE EFI_SIGNATURE_32('d','r','v','r')
 155 typedef struct {
 156   UINTN                           Signature;
 157   LIST_ENTRY                      Link;             // mDriverList
 158
 159   LIST_ENTRY                      ScheduledLink;    // mScheduledQueue
 160
 161   EFI_HANDLE                      FvHandle;
 162   EFI_GUID                        FileName;
 163   EFI_DEVICE_PATH_PROTOCOL        *FvFileDevicePath;
 164   EFI_FIRMWARE_VOLUME_PROTOCOL    *Fv;
 165
 166   VOID                            *Depex;
 167   UINTN                           DepexSize;
 168
 169   BOOLEAN                         Before;
 170   BOOLEAN                         After;
 171   EFI_GUID                        BeforeAfterGuid;
 172
 173   BOOLEAN                         Dependent;
 174   BOOLEAN                         Unrequested;
 175   BOOLEAN                         Scheduled;
 176   BOOLEAN                         Untrusted;
 177   BOOLEAN                         Initialized;
 178   BOOLEAN                         DepexProtocolError;
 179
 180   EFI_HANDLE                      ImageHandle;
 181
 182 } EFI_CORE_DRIVER_ENTRY;
 183
 184 //
 185 //The data structure of GCD memory map entry
 186 //
 187 #define EFI_GCD_MAP_SIGNATURE  EFI_SIGNATURE_32('g','c','d','m')
 188 typedef struct {
 189   UINTN                 Signature;
 190   LIST_ENTRY            Link;
 191   EFI_PHYSICAL_ADDRESS  BaseAddress;
 192   UINT64                EndAddress;
 193   UINT64                Capabilities;
 194   UINT64                Attributes;
 195   EFI_GCD_MEMORY_TYPE   GcdMemoryType;
 196   EFI_GCD_IO_TYPE       GcdIoType;
 197   EFI_HANDLE            ImageHandle;
 198   EFI_HANDLE            DeviceHandle;
 199 } EFI_GCD_MAP_ENTRY;
 200
 201 //
 202 // DXE Core Global Variables
 203 //
 204 extern EFI_SYSTEM_TABLE                         *gDxeCoreST;
 205 extern EFI_BOOT_SERVICES                        *gDxeCoreBS;
 206 extern EFI_RUNTIME_SERVICES                     *gDxeCoreRT;
 207 extern EFI_DXE_SERVICES                         *gDxeCoreDS;
 208 extern EFI_HANDLE                               gDxeCoreImageHandle;
 209
 210 extern EFI_DECOMPRESS_PROTOCOL                  gEfiDecompress;
 211 extern EFI_PEI_PE_COFF_LOADER_PROTOCOL          *gEfiPeiPeCoffLoader;
 212
 213 extern EFI_RUNTIME_ARCH_PROTOCOL                *gRuntime;
 214 extern EFI_CPU_ARCH_PROTOCOL                    *gCpu;
 215 extern EFI_WATCHDOG_TIMER_ARCH_PROTOCOL         *gWatchdogTimer;
 216 extern EFI_METRONOME_ARCH_PROTOCOL              *gMetronome;
 217 extern EFI_TIMER_ARCH_PROTOCOL                  *gTimer;
 218 extern EFI_SECURITY_ARCH_PROTOCOL               *gSecurity;
 219 extern EFI_BDS_ARCH_PROTOCOL                    *gBds;
 220 extern EFI_STATUS_CODE_PROTOCOL                 *gStatusCode;
 221
 222 extern EFI_TPL                                  gEfiCurrentTpl;
 223
 224 extern EFI_GUID                                 *gDxeCoreFileName;
 225 extern EFI_LOADED_IMAGE_PROTOCOL                *gDxeCoreLoadedImage;
 226
 227 extern EFI_MEMORY_TYPE_INFORMATION              gMemoryTypeInformation[EfiMaxMemoryType + 1];
 228
 229 extern BOOLEAN                                  gDispatcherRunning;
 230 extern EFI_RUNTIME_ARCH_PROTOCOL                gRuntimeTemplate;
 231
 232 //
 233 // Service Initialization Functions
 234 //
 235
 236
 237 VOID
 238 CoreInitializePool (
 239   VOID
 240   )
 241 /*++
 242
 243 Routine Description:
 244
 245   Called to initialize the pool.
 246
 247 Arguments:
 248
 249   None
 250
 251 Returns:
 252
 253   None
 254
 255 --*/
 256 ;
 257
 258 VOID
 259 CoreAddMemoryDescriptor (
 260   IN EFI_MEMORY_TYPE       Type,
 261   IN EFI_PHYSICAL_ADDRESS  Start,
 262   IN UINT64                NumberOfPages,
 263   IN UINT64                Attribute
 264   )
 265 /*++
 266
 267 Routine Description:
 268
 269   Called to initialize the memory map and add descriptors to
 270   the current descriptor list.
 271
 272        The first descriptor that is added must be general usable
 273   memory as the addition allocates heap.
 274
 275 Arguments:
 276
 277   Type          - The type of memory to add
 278
 279   Start         - The starting address in the memory range
 280                   Must be page aligned
 281
 282   NumberOfPages - The number of pages in the range
 283
 284   Attribute     - Attributes of the memory to add
 285
 286 Returns:
 287
 288   None.  The range is added to the memory map
 289
 290 --*/
 291 ;
 292
 293 VOID
 294 CoreReleaseGcdMemoryLock (
 295   VOID
 296   )
 297 /*++
 298
 299 Routine Description:
 300     Release memory lock on mGcdMemorySpaceLock
 301
 302 Arguments:
 303     None
 304
 305 Returns:
 306     None
 307
 308 --*/
 309 ;
 310
 311 VOID
 312 CoreAcquireGcdMemoryLock (
 313   VOID
 314   )
 315 /*++
 316
 317 Routine Description:
 318     Acquire memory lock on mGcdMemorySpaceLock
 319
 320 Arguments:
 321     None
 322
 323 Returns:
 324     None
 325
 326 --*/
 327 ;
 328
 329 EFI_STATUS
 330 CoreInitializeMemoryServices (
 331   IN VOID                  **HobStart,
 332   IN EFI_PHYSICAL_ADDRESS  *MemoryBaseAddress,
 333   IN UINT64                *MemoryLength
 334   )
 335 /*++
 336
 337 Routine Description:
 338
 339   External function. Initializes the GCD and memory services based on the memory
 340   descriptor HOBs.  This function is responsible for priming the GCD map and the
 341   memory map, so memory allocations and resource allocations can be made.  The first
 342   part of this function can not depend on any memory services until at least one
 343   memory descriptor is provided to the memory services.  Then the memory services
 344   can be used to intialize the GCD map.
 345
 346 Arguments:
 347
 348   HobStart - The start address of the HOB.
 349
 350   MemoryBaseAddress   - Start address of memory region found to init DXE core.
 351
 352   MemoryLength        - Length of memory region found to init DXE core.
 353
 354 Returns:
 355
 356   EFI_SUCCESS         - Memory services successfully initialized.
 357
 358 --*/
 359 ;
 360
 361
 362 EFI_STATUS
 363 CoreInitializeGcdServices (
 364   IN VOID                  **HobStart,
 365   IN EFI_PHYSICAL_ADDRESS  MemoryBaseAddress,
 366   IN UINT64                MemoryLength
 367   )
 368 /*++
 369
 370 Routine Description:
 371
 372   External function. Initializes the GCD and memory services based on the memory
 373   descriptor HOBs.  This function is responsible for priming the GCD map and the
 374   memory map, so memory allocations and resource allocations can be made.  The first
 375   part of this function can not depend on any memory services until at least one
 376   memory descriptor is provided to the memory services.  Then the memory services
 377   can be used to intialize the GCD map.
 378
 379 Arguments:
 380
 381   HobStart - The start address of the HOB
 382
 383   MemoryBaseAddress   - Start address of memory region found to init DXE core.
 384
 385   MemoryLength        - Length of memory region found to init DXE core.
 386
 387
 388 Returns:
 389
 390   EFI_SUCCESS         - GCD services successfully initialized.
 391
 392 --*/
 393 ;
 394
 395 EFI_STATUS
 396 CoreInitializeEventServices (
 397   VOID
 398   )
 399 /*++
 400
 401 Routine Description:
 402
 403   Initializes "event" support and populates parts of the System and Runtime Table.
 404
 405 Arguments:
 406
 407   None
 408
 409 Returns:
 410
 411   EFI_SUCCESS - Always return success
 412
 413 --*/
 414 ;
 415
 416 EFI_STATUS
 417 CoreInitializeImageServices (
 418   IN  VOID *HobStart
 419   )
 420 /*++
 421
 422 Routine Description:
 423
 424   Add the Image Services to EFI Boot Services Table and install the protocol
 425   interfaces for this image.
 426
 427 Arguments:
 428
 429   HobStart        - The HOB to initialize
 430
 431 Returns:
 432
 433   Status code.
 434
 435 --*/
 436 ;
 437
 438 VOID
 439 CoreNotifyOnArchProtocolInstallation (
 440   VOID
 441   )
 442 /*++
 443
 444 Routine Description:
 445   Creates an event that is fired everytime a Protocol of a specific type is installed
 446
 447 Arguments:
 448   NONE
 449
 450 Returns:
 451   NONE
 452
 453 --*/
 454 ;
 455
 456 EFI_STATUS
 457 CoreAllEfiServicesAvailable (
 458   VOID
 459   )
 460 /*++
 461
 462 Routine Description:
 463   Return TRUE if all AP services are availible.
 464
 465 Arguments:
 466   NONE
 467
 468 Returns:
 469   EFI_SUCCESS   - All AP services are available
 470   EFI_NOT_FOUND - At least one AP service is not available
 471
 472 --*/
 473 ;
 474
 475 VOID
 476 CalculateEfiHdrCrc (
 477   IN  OUT EFI_TABLE_HEADER    *Hdr
 478   )
 479 /*++
 480
 481 Routine Description:
 482
 483   Calcualte the 32-bit CRC in a EFI table using the service provided by the
 484   gRuntime service.
 485
 486 Arguments:
 487
 488   Hdr  - Pointer to an EFI standard header
 489
 490 Returns:
 491
 492   None
 493
 494 --*/
 495 ;
 496
 497 VOID
 498 EFIAPI
 499 CoreTimerTick (
 500   IN UINT64     Duration
 501   )
 502 /*++
 503
 504 Routine Description:
 505
 506   Called by the platform code to process a tick.
 507
 508 Arguments:
 509
 510   Duration    - The number of 100ns elasped since the last call to TimerTick
 511
 512 Returns:
 513
 514   None
 515
 516 --*/
 517 ;
 518
 519 VOID
 520 CoreInitializeDispatcher (
 521   VOID
 522   )
 523 /*++
 524
 525 Routine Description:
 526
 527   Initialize the dispatcher. Initialize the notification function that runs when
 528   a FV protocol is added to the system.
 529
 530 Arguments:
 531
 532   NONE
 533
 534 Returns:
 535
 536   NONE
 537
 538 --*/
 539 ;
 540
 541 BOOLEAN
 542 CoreIsSchedulable (
 543   IN  EFI_CORE_DRIVER_ENTRY   *DriverEntry
 544   )
 545 /*++
 546
 547 Routine Description:
 548
 549   This is the POSTFIX version of the dependency evaluator.  This code does
 550   not need to handle Before or After, as it is not valid to call this
 551   routine in this case. The SOR is just ignored and is a nop in the grammer.
 552
 553   POSTFIX means all the math is done on top of the stack.
 554
 555 Arguments:
 556
 557   DriverEntry - DriverEntry element to update
 558
 559 Returns:
 560
 561   TRUE - If driver is ready to run.
 562
 563   FALSE - If driver is not ready to run or some fatal error was found.
 564
 565 --*/
 566 ;
 567
 568 EFI_STATUS
 569 CorePreProcessDepex (
 570   IN  EFI_CORE_DRIVER_ENTRY   *DriverEntry
 571   )
 572 /*++
 573
 574 Routine Description:
 575
 576   Preprocess dependency expression and update DriverEntry to reflect the
 577   state of  Before, After, and SOR dependencies. If DriverEntry->Before
 578   or DriverEntry->After is set it will never be cleared. If SOR is set
 579   it will be cleared by CoreSchedule(), and then the driver can be
 580   dispatched.
 581
 582 Arguments:
 583
 584   DriverEntry - DriverEntry element to update
 585
 586 Returns:
 587
 588   EFI_SUCCESS - It always works.
 589
 590 --*/
 591 ;
 592
 593
 594 EFI_STATUS
 595 EFIAPI
 596 CoreExitBootServices (
 597   IN EFI_HANDLE   ImageHandle,
 598   IN UINTN        MapKey
 599   )
 600 /*++
 601
 602 Routine Description:
 603
 604   EFI 1.0 API to terminate Boot Services
 605
 606 Arguments:
 607
 608   ImageHandle - Handle that represents the identity of the calling image
 609
 610   MapKey      -Key to the latest memory map.
 611
 612 Returns:
 613
 614   EFI_SUCCESS - Boot Services terminated
 615   EFI_INVALID_PARAMETER - MapKey is incorrect.
 616
 617 --*/
 618 ;
 619
 620 EFI_STATUS
 621 CoreTerminateMemoryMap (
 622   IN UINTN        MapKey
 623   )
 624 /*++
 625
 626 Routine Description:
 627
 628   Make sure the memory map is following all the construction rules,
 629   it is the last time to check memory map error before exit boot services.
 630
 631 Arguments:
 632
 633   MapKey        - Memory map key
 634
 635 Returns:
 636
 637   EFI_INVALID_PARAMETER       - Memory map not consistent with construction rules.
 638
 639   EFI_SUCCESS                 - Valid memory map.
 640
 641 --*/
 642 ;
 643
 644 VOID
 645 CoreNotifySignalList (
 646   IN EFI_GUID     *EventGroup
 647   )
 648 /*++
 649
 650 Routine Description:
 651
 652   Signals all events on the requested list
 653
 654 Arguments:
 655
 656   SignalType      - The list to signal
 657
 658 Returns:
 659
 660   None
 661
 662 --*/
 663 ;
 664
 665
 666 EFI_STATUS
 667 EFIAPI
 668 CoreInstallConfigurationTable (
 669   IN EFI_GUID         *Guid,
 670   IN VOID             *Table
 671   )
 672 /*++
 673
 674 Routine Description:
 675
 676   Boot Service called to add, modify, or remove a system configuration table from
 677   the EFI System Table.
 678
 679 Arguments:
 680
 681   Guid:   Pointer to the GUID for the entry to add, update, or remove
 682   Table:  Pointer to the configuration table for the entry to add, update, or
 683           remove, may be NULL.
 684
 685 Returns:
 686
 687   EFI_SUCCESS               Guid, Table pair added, updated, or removed.
 688   EFI_INVALID_PARAMETER     Input GUID not valid.
 689   EFI_NOT_FOUND             Attempted to delete non-existant entry
 690   EFI_OUT_OF_RESOURCES      Not enough memory available
 691
 692 --*/
 693 ;
 694
 695
 696 EFI_TPL
 697 EFIAPI
 698 CoreRaiseTpl (
 699   IN EFI_TPL  NewTpl
 700   )
 701 /*++
 702
 703 Routine Description:
 704
 705   Raise the task priority level to the new level.
 706   High level is implemented by disabling processor interrupts.
 707
 708 Arguments:
 709
 710   NewTpl  - New task priority level
 711
 712 Returns:
 713
 714   The previous task priority level
 715
 716 --*/
 717 ;
 718
 719
 720 VOID
 721 EFIAPI
 722 CoreRestoreTpl (
 723   IN EFI_TPL  NewTpl
 724   )
 725 /*++
 726
 727 Routine Description:
 728
 729   Lowers the task priority to the previous value.   If the new
 730   priority unmasks events at a higher priority, they are dispatched.
 731
 732 Arguments:
 733
 734   NewTpl  - New, lower, task priority
 735
 736 Returns:
 737
 738   None
 739
 740 --*/
 741 ;
 742
 743
 744 EFI_STATUS
 745 EFIAPI
 746 CoreStall (
 747   IN UINTN            Microseconds
 748   )
 749 /*++
 750
 751 Routine Description:
 752
 753   Introduces a fine-grained stall.
 754
 755 Arguments:
 756
 757   Microseconds      The number of microseconds to stall execution
 758
 759 Returns:
 760
 761   EFI_SUCCESS            - Execution was stalled for at least the requested amount
 762                            of microseconds.
 763
 764   EFI_NOT_AVAILABLE_YET  - gMetronome is not available yet
 765
 766 --*/
 767 ;
 768
 769
 770 EFI_STATUS
 771 EFIAPI
 772 CoreSetWatchdogTimer (
 773   IN UINTN            Timeout,
 774   IN UINT64           WatchdogCode,
 775   IN UINTN            DataSize,
 776   IN CHAR16           *WatchdogData   OPTIONAL
 777   )
 778 /*++
 779
 780 Routine Description:
 781
 782   Sets the system's watchdog timer.
 783
 784 Arguments:
 785
 786   Timeout         The number of seconds.  Zero disables the timer.
 787
 788   ///////following  three parameters are left for platform specific using
 789
 790   WatchdogCode    The numberic code to log.  0x0 to 0xffff are firmware
 791   DataSize        Size of the optional data
 792   WatchdogData    Optional Null terminated unicode string followed by binary
 793                   data.
 794
 795 Returns:
 796
 797   EFI_SUCCESS               Timeout has been set
 798   EFI_NOT_AVAILABLE_YET     WatchdogTimer is not available yet
 799   EFI_UNSUPPORTED           System does not have a timer (currently not used)
 800   EFI_DEVICE_ERROR          Could not complete due to hardware error
 801
 802 --*/
 803 ;
 804
 805
 806 EFI_STATUS
 807 EFIAPI
 808 CoreInstallProtocolInterface (
 809   IN OUT EFI_HANDLE     *UserHandle,
 810   IN EFI_GUID           *Protocol,
 811   IN EFI_INTERFACE_TYPE InterfaceType,
 812   IN VOID               *Interface
 813   )
 814 /*++
 815
 816 Routine Description:
 817
 818   Wrapper function to CoreInstallProtocolInterfaceNotify.  This is the public API which
 819   Calls the private one which contains a BOOLEAN parameter for notifications
 820
 821 Arguments:
 822
 823   UserHandle     - The handle to install the protocol handler on,
 824                     or NULL if a new handle is to be allocated
 825
 826   Protocol       - The protocol to add to the handle
 827
 828   InterfaceType  - Indicates whether Interface is supplied in native form.
 829
 830   Interface      - The interface for the protocol being added
 831
 832 Returns:
 833
 834   Status code
 835
 836 --*/
 837 ;
 838
 839 EFI_STATUS
 840 CoreInstallProtocolInterfaceNotify (
 841   IN OUT EFI_HANDLE     *UserHandle,
 842   IN EFI_GUID           *Protocol,
 843   IN EFI_INTERFACE_TYPE InterfaceType,
 844   IN VOID               *Interface,
 845   IN BOOLEAN            Notify
 846   )
 847 /*++
 848
 849 Routine Description:
 850
 851   Installs a protocol interface into the boot services environment.
 852
 853 Arguments:
 854
 855   UserHandle     - The handle to install the protocol handler on,
 856                    or NULL if a new handle is to be allocated
 857
 858   Protocol       - The protocol to add to the handle
 859
 860   InterfaceType  - Indicates whether Interface is supplied in native form.
 861
 862   Interface      - The interface for the protocol being added
 863
 864   Notify         - Whether to notify the notification list for this protocol
 865
 866 Returns:
 867
 868   EFI_INVALID_PARAMETER     - Invalid parameter
 869
 870   EFI_OUT_OF_RESOURCES       - No enough buffer to allocate
 871
 872   EFI_SUCCESS               - Protocol interface successfully installed
 873
 874 --*/
 875 ;
 876
 877
 878 EFI_STATUS
 879 EFIAPI
 880 CoreInstallMultipleProtocolInterfaces (
 881   IN OUT EFI_HANDLE           *Handle,
 882   ...
 883   )
 884 /*++
 885
 886 Routine Description:
 887
 888   Installs a list of protocol interface into the boot services environment.
 889   This function calls InstallProtocolInterface() in a loop. If any error
 890   occures all the protocols added by this function are removed. This is
 891   basically a lib function to save space.
 892
 893 Arguments:
 894
 895   Handle      - The handle to install the protocol handlers on,
 896                 or NULL if a new handle is to be allocated
 897   ...         - EFI_GUID followed by protocol instance. A NULL terminates the
 898                 list. The pairs are the arguments to InstallProtocolInterface().
 899                 All the protocols are added to Handle.
 900
 901 Returns:
 902
 903   EFI_INVALID_PARAMETER       - Handle is NULL.
 904
 905   EFI_SUCCESS                 - Protocol interfaces successfully installed.
 906
 907 --*/
 908 ;
 909
 910
 911 EFI_STATUS
 912 EFIAPI
 913 CoreUninstallMultipleProtocolInterfaces (
 914   IN EFI_HANDLE           Handle,
 915   ...
 916   )
 917 /*++
 918
 919 Routine Description:
 920
 921   Uninstalls a list of protocol interface in the boot services environment.
 922   This function calls UnisatllProtocolInterface() in a loop. This is
 923   basically a lib function to save space.
 924
 925 Arguments:
 926
 927   Handle      - The handle to uninstall the protocol
 928
 929   ...         - EFI_GUID followed by protocol instance. A NULL terminates the
 930                 list. The pairs are the arguments to UninstallProtocolInterface().
 931                 All the protocols are added to Handle.
 932
 933 Returns:
 934
 935   Status code
 936
 937 --*/
 938 ;
 939
 940
 941 EFI_STATUS
 942 EFIAPI
 943 CoreReinstallProtocolInterface (
 944   IN EFI_HANDLE     UserHandle,
 945   IN EFI_GUID       *Protocol,
 946   IN VOID           *OldInterface,
 947   IN VOID           *NewInterface
 948   )
 949 /*++
 950
 951 Routine Description:
 952
 953   Reinstall a protocol interface on a device handle.  The OldInterface for Protocol is replaced by the NewInterface.
 954
 955 Arguments:
 956
 957   UserHandle    - Handle on which the interface is to be reinstalled
 958   Protocol      - The numeric ID of the interface
 959   OldInterface  - A pointer to the old interface
 960   NewInterface  - A pointer to the new interface
 961
 962
 963 Returns:
 964
 965   Status code.
 966
 967   On EFI_SUCCESS            The protocol interface was installed
 968   On EFI_NOT_FOUND          The OldInterface on the handle was not found
 969   On EFI_INVALID_PARAMETER  One of the parameters has an invalid value
 970
 971 --*/
 972 ;
 973
 974
 975 EFI_STATUS
 976 EFIAPI
 977 CoreUninstallProtocolInterface (
 978   IN EFI_HANDLE       UserHandle,
 979   IN EFI_GUID         *Protocol,
 980   IN VOID             *Interface
 981   )
 982 /*++
 983
 984 Routine Description:
 985
 986   Uninstalls all instances of a protocol:interfacer from a handle.
 987   If the last protocol interface is remove from the handle, the
 988   handle is freed.
 989
 990 Arguments:
 991
 992   UserHandle      - The handle to remove the protocol handler from
 993
 994   Protocol        - The protocol, of protocol:interface, to remove
 995
 996   Interface       - The interface, of protocol:interface, to remove
 997
 998 Returns:
 999
1000   EFI_INVALID_PARAMETER       - Protocol is NULL.
1001
1002   EFI_SUCCESS                 - Protocol interface successfully uninstalled.
1003
1004 --*/
1005 ;
1006
1007
1008 EFI_STATUS
1009 EFIAPI
1010 CoreHandleProtocol (
1011   IN  EFI_HANDLE       UserHandle,
1012   IN  EFI_GUID         *Protocol,
1013   OUT VOID             **Interface
1014   )
1015 /*++
1016
1017 Routine Description:
1018
1019   Queries a handle to determine if it supports a specified protocol.
1020
1021 Arguments:
1022
1023   UserHandle  - The handle being queried.
1024
1025   Protocol    - The published unique identifier of the protocol.
1026
1027   Interface   - Supplies the address where a pointer to the corresponding Protocol
1028                Interface is returned.
1029
1030 Returns:
1031
1032   The requested protocol interface for the handle
1033
1034 --*/
1035 ;
1036
1037
1038 EFI_STATUS
1039 EFIAPI
1040 CoreOpenProtocol (
1041   IN  EFI_HANDLE                UserHandle,
1042   IN  EFI_GUID                  *Protocol,
1043   OUT VOID                      **Interface OPTIONAL,
1044   IN  EFI_HANDLE                ImageHandle,
1045   IN  EFI_HANDLE                ControllerHandle,
1046   IN  UINT32                    Attributes
1047   )
1048 /*++
1049
1050 Routine Description:
1051
1052   Locates the installed protocol handler for the handle, and
1053   invokes it to obtain the protocol interface. Usage information
1054   is registered in the protocol data base.
1055
1056 Arguments:
1057
1058   UserHandle        - The handle to obtain the protocol interface on
1059
1060   Protocol          - The ID of the protocol
1061
1062   Interface         - The location to return the protocol interface
1063
1064   ImageHandle       - The handle of the Image that is opening the protocol interface
1065                     specified by Protocol and Interface.
1066
1067   ControllerHandle  - The controller handle that is requiring this interface.
1068
1069   Attributes     - The open mode of the protocol interface specified by Handle
1070                     and Protocol.
1071
1072 Returns:
1073
1074   EFI_INVALID_PARAMETER       - Protocol is NULL.
1075
1076   EFI_SUCCESS                 - Get the protocol interface.
1077
1078 --*/
1079 ;
1080
1081
1082 EFI_STATUS
1083 EFIAPI
1084 CoreOpenProtocolInformation (
1085   IN  EFI_HANDLE                          UserHandle,
1086   IN  EFI_GUID                            *Protocol,
1087   OUT EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer,
1088   OUT UINTN                               *EntryCount
1089   )
1090 /*++
1091
1092 Routine Description:
1093
1094   Return information about Opened protocols in the system
1095
1096 Arguments:
1097
1098   UserHandle  - The handle to close the protocol interface on
1099
1100   Protocol    - The ID of the protocol
1101
1102   EntryBuffer - A pointer to a buffer of open protocol information in the form of
1103                 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY structures.
1104
1105   EntryCount  - Number of EntryBuffer entries
1106
1107 Returns:
1108
1109
1110 --*/
1111 ;
1112
1113
1114 EFI_STATUS
1115 EFIAPI
1116 CoreCloseProtocol (
1117   IN  EFI_HANDLE                UserHandle,
1118   IN  EFI_GUID                  *Protocol,
1119   IN  EFI_HANDLE                ImageHandle,
1120   IN  EFI_HANDLE                ControllerHandle
1121   )
1122 /*++
1123
1124 Routine Description:
1125
1126   Close Protocol
1127
1128 Arguments:
1129
1130   UserHandle       - The handle to close the protocol interface on
1131
1132   Protocol         - The ID of the protocol
1133
1134   ImageHandle      - The user of the protocol to close
1135
1136   ControllerHandle - The user of the protocol to close
1137
1138 Returns:
1139
1140   EFI_INVALID_PARAMETER     - Protocol is NULL.
1141
1142 --*/
1143 ;
1144
1145
1146 EFI_STATUS
1147 EFIAPI
1148 CoreProtocolsPerHandle (
1149   IN  EFI_HANDLE       UserHandle,
1150   OUT EFI_GUID         ***ProtocolBuffer,
1151   OUT UINTN            *ProtocolBufferCount
1152   )
1153 /*++
1154
1155 Routine Description:
1156
1157   Retrieves the list of protocol interface GUIDs that are installed on a handle in a buffer allocated
1158  from pool.
1159
1160 Arguments:
1161
1162   UserHandle           - The handle from which to retrieve the list of protocol interface
1163                           GUIDs.
1164
1165   ProtocolBuffer       - A pointer to the list of protocol interface GUID pointers that are
1166                           installed on Handle.
1167
1168   ProtocolBufferCount  - A pointer to the number of GUID pointers present in
1169                           ProtocolBuffer.
1170
1171 Returns:
1172   EFI_SUCCESS   -  The list of protocol interface GUIDs installed on Handle was returned in
1173                    ProtocolBuffer. The number of protocol interface GUIDs was
1174                    returned in ProtocolBufferCount.
1175   EFI_INVALID_PARAMETER   -  Handle is NULL.
1176   EFI_INVALID_PARAMETER   -  Handle is not a valid EFI_HANDLE.
1177   EFI_INVALID_PARAMETER   -  ProtocolBuffer is NULL.
1178   EFI_INVALID_PARAMETER   -  ProtocolBufferCount is NULL.
1179   EFI_OUT_OF_RESOURCES    -  There is not enough pool memory to store the results.
1180
1181 --*/
1182 ;
1183
1184
1185 EFI_STATUS
1186 EFIAPI
1187 CoreRegisterProtocolNotify (
1188   IN  EFI_GUID       *Protocol,
1189   IN  EFI_EVENT      Event,
1190   OUT VOID           **Registration
1191   )
1192 /*++
1193
1194 Routine Description:
1195
1196   Add a new protocol notification record for the request protocol.
1197
1198 Arguments:
1199
1200   Protocol      - The requested protocol to add the notify registration
1201
1202   Event         - The event to signal
1203
1204   Registration  - Returns the registration record
1205
1206
1207 Returns:
1208
1209   EFI_INVALID_PARAMETER       - Invalid parameter
1210
1211   EFI_SUCCESS                 - Successfully returned the registration record that has been added
1212
1213 --*/
1214 ;
1215
1216
1217 EFI_STATUS
1218 EFIAPI
1219 CoreLocateHandle (
1220   IN     EFI_LOCATE_SEARCH_TYPE         SearchType,
1221   IN     EFI_GUID                       *Protocol OPTIONAL,
1222   IN     VOID                           *SearchKey OPTIONAL,
1223   IN OUT UINTN                          *BufferSize,
1224   OUT    EFI_HANDLE                     *Buffer
1225   )
1226 /*++
1227
1228 Routine Description:
1229
1230   Locates the requested handle(s) and returns them in Buffer.
1231
1232 Arguments:
1233
1234   SearchType  - The type of search to perform to locate the handles
1235
1236   Protocol    - The protocol to search for
1237
1238   SearchKey   - Dependant on SearchType
1239
1240   BufferSize  - On input the size of Buffer.  On output the
1241                 size of data returned.
1242
1243   Buffer      - The buffer to return the results in
1244
1245
1246 Returns:
1247
1248   EFI_BUFFER_TOO_SMALL      - Buffer too small, required buffer size is returned in BufferSize.
1249
1250   EFI_INVALID_PARAMETER     - Invalid parameter
1251
1252   EFI_SUCCESS               - Successfully found the requested handle(s) and returns them in Buffer.
1253
1254 --*/
1255 ;
1256
1257
1258 EFI_STATUS
1259 EFIAPI
1260 CoreLocateDevicePath (
1261   IN     EFI_GUID                       *Protocol,
1262   IN OUT EFI_DEVICE_PATH_PROTOCOL       **FilePath,
1263   OUT    EFI_HANDLE                     *Device
1264   )
1265 /*++
1266
1267 Routine Description:
1268
1269   Locates the handle to a device on the device path that supports the specified protocol.
1270
1271 Arguments:
1272
1273   Protocol    - The protocol to search for.
1274   FilePath    - On input, a pointer to a pointer to the device path. On output, the device
1275                   path pointer is modified to point to the remaining part of the devicepath.
1276   Device      - A pointer to the returned device handle.
1277
1278 Returns:
1279
1280   EFI_SUCCESS           - The resulting handle was returned.
1281   EFI_NOT_FOUND         - No handles matched the search.
1282   EFI_INVALID_PARAMETER - One of the parameters has an invalid value.
1283
1284 --*/
1285 ;
1286
1287
1288 EFI_STATUS
1289 EFIAPI
1290 CoreLocateHandleBuffer (
1291   IN     EFI_LOCATE_SEARCH_TYPE         SearchType,
1292   IN     EFI_GUID                       *Protocol OPTIONAL,
1293   IN     VOID                           *SearchKey OPTIONAL,
1294   IN OUT UINTN                          *NumberHandles,
1295   OUT    EFI_HANDLE                     **Buffer
1296   )
1297 /*++
1298
1299 Routine Description:
1300
1301   Function returns an array of handles that support the requested protocol
1302   in a buffer allocated from pool. This is a version of CoreLocateHandle()
1303   that allocates a buffer for the caller.
1304
1305 Arguments:
1306
1307   SearchType           - Specifies which handle(s) are to be returned.
1308   Protocol             - Provides the protocol to search by.
1309                          This parameter is only valid for SearchType ByProtocol.
1310   SearchKey            - Supplies the search key depending on the SearchType.
1311   NumberHandles      - The number of handles returned in Buffer.
1312   Buffer               - A pointer to the buffer to return the requested array of
1313                          handles that support Protocol.
1314
1315 Returns:
1316
1317   EFI_SUCCESS             - The result array of handles was returned.
1318   EFI_NOT_FOUND           - No handles match the search.
1319   EFI_OUT_OF_RESOURCES    - There is not enough pool memory to store the matching results.
1320   EFI_INVALID_PARAMETER   - Invalid parameter
1321
1322 --*/
1323 ;
1324
1325
1326 EFI_STATUS
1327 EFIAPI
1328 CoreLocateProtocol (
1329   IN    EFI_GUID  *Protocol,
1330   IN    VOID      *Registration OPTIONAL,
1331   OUT   VOID      **Interface
1332   )
1333 /*++
1334
1335 Routine Description:
1336
1337   Return the first Protocol Interface that matches the Protocol GUID. If
1338   Registration is pasased in return a Protocol Instance that was just add
1339   to the system. If Retistration is NULL return the first Protocol Interface
1340   you find.
1341
1342 Arguments:
1343
1344   Protocol     - The protocol to search for
1345
1346   Registration - Optional Registration Key returned from RegisterProtocolNotify()
1347
1348   Interface    - Return the Protocol interface (instance).
1349
1350 Returns:
1351
1352   EFI_SUCCESS                 - If a valid Interface is returned
1353
1354   EFI_INVALID_PARAMETER       - Invalid parameter
1355
1356   EFI_NOT_FOUND               - Protocol interface not found
1357
1358 --*/
1359 ;
1360
1361 UINT64
1362 CoreGetHandleDatabaseKey (
1363   VOID
1364   )
1365 /*++
1366
1367 Routine Description:
1368
1369   return handle database key.
1370
1371 Arguments:
1372
1373   None
1374
1375 Returns:
1376
1377   Handle database key.
1378
1379 --*/
1380 ;
1381
1382 VOID
1383 CoreConnectHandlesByKey (
1384   UINT64  Key
1385   )
1386 /*++
1387
1388 Routine Description:
1389
1390   Go connect any handles that were created or modified while a image executed.
1391
1392 Arguments:
1393
1394   Key  -  The Key to show that the handle has been created/modified
1395
1396 Returns:
1397
1398   None
1399 --*/
1400 ;
1401
1402
1403 EFI_STATUS
1404 EFIAPI
1405 CoreConnectController (
1406   IN  EFI_HANDLE                ControllerHandle,
1407   IN  EFI_HANDLE                *DriverImageHandle    OPTIONAL,
1408   IN  EFI_DEVICE_PATH_PROTOCOL  *RemainingDevicePath  OPTIONAL,
1409   IN  BOOLEAN                   Recursive
1410   )
1411 /*++
1412
1413 Routine Description:
1414
1415   Connects one or more drivers to a controller.
1416
1417 Arguments:
1418
1419   ControllerHandle            - Handle of the controller to be connected.
1420
1421   DriverImageHandle           - DriverImageHandle A pointer to an ordered list of driver image handles.
1422
1423   RemainingDevicePath         - RemainingDevicePath A pointer to the device path that specifies a child of the
1424                                 controller specified by ControllerHandle.
1425
1426   Recursive -                 - Whether the function would be called recursively or not.
1427
1428 Returns:
1429
1430   Status code.
1431
1432 --*/
1433 ;
1434
1435
1436 EFI_STATUS
1437 EFIAPI
1438 CoreDisconnectController (
1439   IN EFI_HANDLE  ControllerHandle,
1440   IN EFI_HANDLE  DriverImageHandle  OPTIONAL,
1441   IN EFI_HANDLE  ChildHandle        OPTIONAL
1442   )
1443 /*++
1444
1445 Routine Description:
1446
1447   Disonnects a controller from a driver
1448
1449 Arguments:
1450
1451   ControllerHandle  - ControllerHandle The handle of the controller from which driver(s)
1452                         are to be disconnected.
1453   DriverImageHandle - DriverImageHandle The driver to disconnect from ControllerHandle.
1454   ChildHandle       - ChildHandle The handle of the child to destroy.
1455
1456 Returns:
1457
1458   EFI_SUCCESS           -  One or more drivers were disconnected from the controller.
1459   EFI_SUCCESS           -  On entry, no drivers are managing ControllerHandle.
1460   EFI_SUCCESS           -  DriverImageHandle is not NULL, and on entry DriverImageHandle is not managing ControllerHandle.
1461   EFI_INVALID_PARAMETER -  ControllerHandle is not a valid EFI_HANDLE.
1462   EFI_INVALID_PARAMETER -  DriverImageHandle is not NULL, and it is not a valid EFI_HANDLE.
1463   EFI_INVALID_PARAMETER -  ChildHandle is not NULL, and it is not a valid EFI_HANDLE.
1464   EFI_OUT_OF_RESOURCES  -  There are not enough resources available to disconnect any drivers from ControllerHandle.
1465   EFI_DEVICE_ERROR      -  The controller could not be disconnected because of a device error.
1466
1467 --*/
1468 ;
1469
1470
1471 EFI_STATUS
1472 EFIAPI
1473 CoreAllocatePages (
1474   IN      EFI_ALLOCATE_TYPE       Type,
1475   IN      EFI_MEMORY_TYPE         MemoryType,
1476   IN      UINTN                   NumberOfPages,
1477   IN OUT  EFI_PHYSICAL_ADDRESS    *Memory
1478   )
1479 /*++
1480
1481 Routine Description:
1482
1483   Allocates pages from the memory map.
1484
1485 Arguments:
1486
1487   Type          - The type of allocation to perform
1488
1489   MemoryType    - The type of memory to turn the allocated pages into
1490
1491   NumberOfPages - The number of pages to allocate
1492
1493   Memory        - A pointer to receive the base allocated memory address
1494
1495 Returns:
1496
1497   Status. On success, Memory is filled in with the base address allocated
1498
1499   EFI_INVALID_PARAMETER     - Parameters violate checking rules defined in spec.
1500
1501   EFI_NOT_FOUND             - Could not allocate pages match the requirement.
1502
1503   EFI_OUT_OF_RESOURCES      - No enough pages to allocate.
1504
1505   EFI_SUCCESS               - Pages successfully allocated.
1506
1507 --*/
1508 ;
1509
1510
1511 EFI_STATUS
1512 EFIAPI
1513 CoreFreePages (
1514   IN EFI_PHYSICAL_ADDRESS   Memory,
1515   IN UINTN                  NumberOfPages
1516   )
1517 /*++
1518
1519 Routine Description:
1520
1521   Frees previous allocated pages.
1522
1523 Arguments:
1524
1525   Memory        - Base address of memory being freed
1526
1527   NumberOfPages - The number of pages to free
1528
1529 Returns:
1530
1531   EFI_NOT_FOUND       - Could not find the entry that covers the range
1532
1533   EFI_INVALID_PARAMETER   - Address not aligned
1534
1535   EFI_SUCCESS         -Pages successfully freed.
1536
1537 --*/
1538 ;
1539
1540
1541 EFI_STATUS
1542 EFIAPI
1543 CoreGetMemoryMap (
1544   IN OUT UINTN                       *MemoryMapSize,
1545   IN OUT EFI_MEMORY_DESCRIPTOR       *Desc,
1546   OUT    UINTN                       *MapKey,
1547   OUT    UINTN                       *DescriptorSize,
1548   OUT    UINT32                      *DescriptorVersion
1549   )
1550 /*++
1551
1552 Routine Description:
1553
1554   Returns the current memory map.
1555
1556 Arguments:
1557
1558   MemoryMapSize     - On input the buffer size of MemoryMap allocated by caller
1559                       On output the required buffer size to contain the memory map
1560
1561   Desc              - The buffer to return the current memory map
1562
1563   MapKey            - The address to return the current map key
1564
1565   DescriptorSize    - The size in bytes for an individual EFI_MEMORY_DESCRIPTOR
1566
1567   DescriptorVersion - The version number associated with the EFI_MEMORY_DESCRIPTOR
1568
1569 Returns:
1570
1571   EFI_SUCCESS           The current memory map was returned successfully
1572
1573   EFI_BUFFER_TOO_SMALL  The MemoryMap buffer was too small
1574
1575   EFI_INVALID_PARAMETER One of the parameters has an invalid value
1576
1577 --*/
1578 ;
1579
1580
1581 EFI_STATUS
1582 EFIAPI
1583 CoreAllocatePool (
1584   IN   EFI_MEMORY_TYPE  PoolType,
1585   IN   UINTN            Size,
1586   OUT  VOID             **Buffer
1587   )
1588 /*++
1589
1590 Routine Description:
1591
1592   Allocate pool of a particular type.
1593
1594 Arguments:
1595
1596   PoolType    - Type of pool to allocate
1597
1598   Size        - The amount of pool to allocate
1599
1600   Buffer      - The address to return a pointer to the allocated pool
1601
1602 Returns:
1603
1604   EFI_INVALID_PARAMETER     - PoolType not valid
1605
1606   EFI_OUT_OF_RESOURCES      - Size exceeds max pool size or allocation failed.
1607
1608   EFI_SUCCESS               - Pool successfully allocated.
1609
1610 --*/
1611 ;
1612
1613
1614 EFI_STATUS
1615 EFIAPI
1616 CoreFreePool (
1617   IN VOID      *Buffer
1618   )
1619 /*++
1620
1621 Routine Description:
1622
1623   Frees pool.
1624
1625 Arguments:
1626
1627   Buffer      - The allocated pool entry to free
1628
1629 Returns:
1630
1631   EFI_INVALID_PARAMETER   - Buffer is not a valid value.
1632
1633   EFI_SUCCESS             - Pool successfully freed.
1634
1635 --*/
1636 ;
1637
1638
1639 EFI_STATUS
1640 EFIAPI
1641 CoreLoadImage (
1642   IN  BOOLEAN                    BootPolicy,
1643   IN  EFI_HANDLE                 ParentImageHandle,
1644   IN  EFI_DEVICE_PATH_PROTOCOL   *FilePath,
1645   IN  VOID                       *SourceBuffer   OPTIONAL,
1646   IN  UINTN                      SourceSize,
1647   OUT EFI_HANDLE                 *ImageHandle
1648   )
1649 /*++
1650
1651 Routine Description:
1652
1653   Loads an EFI image into memory and returns a handle to the image.
1654
1655 Arguments:
1656
1657   BootPolicy          - If TRUE, indicates that the request originates from the boot manager,
1658                         and that the boot manager is attempting to load FilePath as a boot selection.
1659   ParentImageHandle   - The caller's image handle.
1660   FilePath            - The specific file path from which the image is loaded.
1661   SourceBuffer        - If not NULL, a pointer to the memory location containing a copy of
1662                         the image to be loaded.
1663   SourceSize          - The size in bytes of SourceBuffer.
1664   ImageHandle         - Pointer to the returned image handle that is created when the image
1665                         is successfully loaded.
1666
1667 Returns:
1668
1669   EFI_SUCCESS            - The image was loaded into memory.
1670   EFI_NOT_FOUND          - The FilePath was not found.
1671   EFI_INVALID_PARAMETER  - One of the parameters has an invalid value.
1672   EFI_UNSUPPORTED        - The image type is not supported, or the device path cannot be
1673                            parsed to locate the proper protocol for loading the file.
1674   EFI_OUT_OF_RESOURCES   - Image was not loaded due to insufficient resources.
1675 --*/
1676 ;
1677
1678
1679 EFI_STATUS
1680 EFIAPI
1681 CoreUnloadImage (
1682   IN EFI_HANDLE  ImageHandle
1683   )
1684 /*++
1685
1686 Routine Description:
1687
1688   Unload the specified image.
1689
1690 Arguments:
1691
1692   ImageHandle       - The specified image handle.
1693
1694 Returns:
1695
1696   EFI_INVALID_PARAMETER       - Image handle is NULL.
1697
1698   EFI_UNSUPPORTED             - Attempt to unload an unsupported image.
1699
1700   EFI_SUCCESS                 - Image successfully unloaded.
1701
1702 --*/
1703 ;
1704
1705
1706 EFI_STATUS
1707 EFIAPI
1708 CoreStartImage (
1709   IN  EFI_HANDLE  ImageHandle,
1710   OUT UINTN       *ExitDataSize,
1711   OUT CHAR16      **ExitData  OPTIONAL
1712   )
1713 /*++
1714
1715 Routine Description:
1716
1717   Transfer control to a loaded image's entry point.
1718
1719 Arguments:
1720
1721   ImageHandle     - Handle of image to be started.
1722
1723   ExitDataSize    - Pointer of the size to ExitData
1724
1725   ExitData        - Pointer to a pointer to a data buffer that includes a Null-terminated
1726                     Unicode string, optionally followed by additional binary data. The string
1727                     is a description that the caller may use to further indicate the reason for
1728                     the image's exit.
1729
1730 Returns:
1731
1732   EFI_INVALID_PARAMETER     - Invalid parameter
1733
1734   EFI_OUT_OF_RESOURCES       - No enough buffer to allocate
1735
1736   EFI_SUCCESS               - Successfully transfer control to the image's entry point.
1737
1738 --*/
1739 ;
1740
1741
1742 EFI_STATUS
1743 EFIAPI
1744 CoreExit (
1745   IN EFI_HANDLE  ImageHandle,
1746   IN EFI_STATUS  Status,
1747   IN UINTN       ExitDataSize,
1748   IN CHAR16      *ExitData  OPTIONAL
1749   )
1750 /*++
1751
1752 Routine Description:
1753
1754   Terminates the currently loaded EFI image and returns control to boot services.
1755
1756 Arguments:
1757
1758   ImageHandle       - Handle that identifies the image. This parameter is passed to the image
1759                       on entry.
1760   Status            - The image's exit code.
1761   ExitDataSize      - The size, in bytes, of ExitData. Ignored if ExitStatus is
1762                       EFI_SUCCESS.
1763   ExitData          - Pointer to a data buffer that includes a Null-terminated Unicode string,
1764                       optionally followed by additional binary data. The string is a
1765                       description that the caller may use to further indicate the reason for
1766                       the image's exit.
1767
1768 Returns:
1769
1770   EFI_INVALID_PARAMETER     - Image handle is NULL or it is not current image.
1771
1772   EFI_SUCCESS               - Successfully terminates the currently loaded EFI image.
1773
1774   EFI_ACCESS_DENIED         - Should never reach there.
1775
1776 --*/
1777 ;
1778
1779
1780 EFI_STATUS
1781 EFIAPI
1782 CoreCreateEvent (
1783   IN  UINT32               Type,
1784   IN  EFI_TPL              NotifyTpl,
1785   IN  EFI_EVENT_NOTIFY     NotifyFunction,
1786   IN  VOID                 *NotifyContext,
1787   OUT EFI_EVENT            *pEvent
1788   )
1789 /*++
1790
1791 Routine Description:
1792
1793   Creates a general-purpose event structure
1794
1795 Arguments:
1796
1797   Type                - The type of event to create and its mode and attributes
1798   NotifyTpl           - The task priority level of event notifications
1799   NotifyFunction      - Pointer to the event's notification function
1800   NotifyContext       - Pointer to the notification function's context; corresponds to
1801                         parameter "Context" in the notification function
1802   pEvent              - Pointer to the newly created event if the call succeeds; undefined otherwise
1803
1804 Returns:
1805
1806   EFI_SUCCESS           - The event structure was created
1807   EFI_INVALID_PARAMETER - One of the parameters has an invalid value
1808   EFI_OUT_OF_RESOURCES  - The event could not be allocated
1809
1810 --*/
1811 ;
1812
1813
1814 EFI_STATUS
1815 EFIAPI
1816 CoreCreateEventEx (
1817   IN UINT32                   Type,
1818   IN EFI_TPL                  NotifyTpl,
1819   IN EFI_EVENT_NOTIFY         NotifyFunction, OPTIONAL
1820   IN CONST VOID               *NotifyContext, OPTIONAL
1821   IN CONST EFI_GUID           *EventGroup,    OPTIONAL
1822   OUT EFI_EVENT               *Event
1823   )
1824 /*++
1825
1826 Routine Description:
1827   Creates a general-purpose event structure
1828
1829 Arguments:
1830   Type                - The type of event to create and its mode and attributes
1831   NotifyTpl           - The task priority level of event notifications
1832   NotifyFunction      - Pointer to the events notification function
1833   NotifyContext       - Pointer to the notification functions context; corresponds to
1834                         parameter "Context" in the notification function
1835   EventGrout          - GUID for EventGroup if NULL act the same as gBS->CreateEvent().
1836   Event               - Pointer to the newly created event if the call succeeds; undefined otherwise
1837
1838 Returns:
1839   EFI_SUCCESS           - The event structure was created
1840   EFI_INVALID_PARAMETER - One of the parameters has an invalid value
1841   EFI_OUT_OF_RESOURCES  - The event could not be allocated
1842
1843 --*/
1844 ;
1845
1846
1847 EFI_STATUS
1848 EFIAPI
1849 CoreSetTimer (
1850   IN EFI_EVENT            Event,
1851   IN EFI_TIMER_DELAY      Type,
1852   IN UINT64               TriggerTime
1853   )
1854 /*++
1855
1856 Routine Description:
1857
1858   Sets the type of timer and the trigger time for a timer event.
1859
1860 Arguments:
1861
1862   UserEvent   - The timer event that is to be signaled at the specified time
1863   Type        - The type of time that is specified in TriggerTime
1864   TriggerTime - The number of 100ns units until the timer expires
1865
1866 Returns:
1867
1868   EFI_SUCCESS           - The event has been set to be signaled at the requested time
1869   EFI_INVALID_PARAMETER - Event or Type is not valid
1870
1871 --*/
1872 ;
1873
1874
1875 EFI_STATUS
1876 EFIAPI
1877 CoreSignalEvent (
1878   IN EFI_EVENT            Event
1879   )
1880 /*++
1881
1882 Routine Description:
1883
1884   Signals the event.  Queues the event to be notified if needed
1885
1886 Arguments:
1887
1888   Event - The event to signal
1889
1890 Returns:
1891
1892   EFI_INVALID_PARAMETER - Parameters are not valid.
1893
1894   EFI_SUCCESS - The event was signaled.
1895
1896 --*/
1897 ;
1898
1899
1900 EFI_STATUS
1901 EFIAPI
1902 CoreWaitForEvent (
1903   IN  UINTN        NumberOfEvents,
1904   IN  EFI_EVENT    *UserEvents,
1905   OUT UINTN        *UserIndex
1906   )
1907 /*++
1908
1909 Routine Description:
1910
1911   Stops execution until an event is signaled.
1912
1913 Arguments:
1914
1915   NumberOfEvents  - The number of events in the UserEvents array
1916   UserEvents      - An array of EFI_EVENT
1917   UserIndex       - Pointer to the index of the event which satisfied the wait condition
1918
1919 Returns:
1920
1921   EFI_SUCCESS           - The event indicated by Index was signaled.
1922   EFI_INVALID_PARAMETER - The event indicated by Index has a notification function or
1923                           Event was not a valid type
1924   EFI_UNSUPPORTED       - The current TPL is not TPL_APPLICATION
1925
1926 --*/
1927 ;
1928
1929
1930 EFI_STATUS
1931 EFIAPI
1932 CoreCloseEvent (
1933   IN EFI_EVENT            Event
1934   )
1935 /*++
1936
1937 Routine Description:
1938
1939   Closes an event and frees the event structure.
1940
1941 Arguments:
1942
1943   UserEvent - Event to close
1944
1945 Returns:
1946
1947   EFI_INVALID_PARAMETER - Parameters are not valid.
1948
1949   EFI_SUCCESS - The event has been closed
1950
1951 --*/
1952 ;
1953
1954
1955 EFI_STATUS
1956 EFIAPI
1957 CoreCheckEvent (
1958   IN EFI_EVENT            Event
1959   )
1960 /*++
1961
1962 Routine Description:
1963
1964   Check the status of an event
1965
1966 Arguments:
1967
1968   UserEvent - The event to check
1969
1970 Returns:
1971
1972   EFI_SUCCESS           - The event is in the signaled state
1973   EFI_NOT_READY         - The event is not in the signaled state
1974   EFI_INVALID_PARAMETER - Event is of type EVT_NOTIFY_SIGNAL
1975
1976 --*/
1977 ;
1978
1979 EFI_STATUS
1980 CoreAddMemorySpace (
1981   IN EFI_GCD_MEMORY_TYPE   GcdMemoryType,
1982   IN EFI_PHYSICAL_ADDRESS  BaseAddress,
1983   IN UINT64                Length,
1984   IN UINT64                Capabilities
1985   )
1986 /*++
1987
1988 Routine Description:
1989
1990   Add a segment of memory space to GCD map and add all available pages in this segment
1991   as memory descriptors.
1992
1993 Arguments:
1994
1995   GcdMemoryType     - Memory type of the segment.
1996
1997   BaseAddress       - Base address of the segment.
1998
1999   Length            - Length of the segment.
2000
2001   Capabilities      - alterable attributes of the segment.
2002
2003 Returns:
2004
2005   EFI_SUCCESS       - Merged this segment into GCD map.
2006
2007 --*/
2008 ;
2009
2010 EFI_STATUS
2011 CoreAllocateMemorySpace (
2012   IN     EFI_GCD_ALLOCATE_TYPE  GcdAllocateType,
2013   IN     EFI_GCD_MEMORY_TYPE    GcdMemoryType,
2014   IN     UINTN                  Alignment,
2015   IN     UINT64                 Length,
2016   IN OUT EFI_PHYSICAL_ADDRESS   *BaseAddress,
2017   IN     EFI_HANDLE             ImageHandle,
2018   IN     EFI_HANDLE             DeviceHandle OPTIONAL
2019   )
2020 /*++
2021
2022 Routine Description:
2023
2024   Allocate memory space on GCD map.
2025
2026 Arguments:
2027
2028   GcdAllocateType   - The type of allocate operation
2029
2030   GcdMemoryType     - The desired memory type
2031
2032   Alignment         - Align with 2^Alignment
2033
2034   Length            - Length to allocate
2035
2036   BaseAddress       - Base address to allocate
2037
2038   ImageHandle       - The image handle consume the allocated space.
2039
2040   DeviceHandle      - The device handle consume the allocated space.
2041
2042 Returns:
2043
2044   EFI_INVALID_PARAMETER       - Invalid parameter.
2045
2046   EFI_NOT_FOUND               - No descriptor contains the desired space.
2047
2048   EFI_SUCCESS                 - Memory space successfully allocated.
2049
2050 --*/
2051 ;
2052
2053 EFI_STATUS
2054 CoreFreeMemorySpace (
2055   IN EFI_PHYSICAL_ADDRESS  BaseAddress,
2056   IN UINT64                Length
2057   )
2058 /*++
2059
2060 Routine Description:Routine Description:
2061
2062   Free a segment of memory space in GCD map.
2063
2064 Arguments:
2065
2066   BaseAddress       - Base address of the segment.
2067
2068   Length            - Length of the segment.
2069
2070 Returns:
2071
2072   EFI_SUCCESS       - Space successfully freed.
2073
2074 --*/
2075 ;
2076
2077 EFI_STATUS
2078 CoreRemoveMemorySpace (
2079   IN EFI_PHYSICAL_ADDRESS  BaseAddress,
2080   IN UINT64                Length
2081   )
2082 /*++
2083
2084 Routine Description:Routine Description:
2085
2086   Remove a segment of memory space in GCD map.
2087
2088 Arguments:
2089
2090   BaseAddress       - Base address of the segment.
2091
2092   Length            - Length of the segment.
2093
2094 Returns:
2095
2096   EFI_SUCCESS       - Successfully a segment of memory space.
2097
2098 --*/
2099 ;
2100
2101 EFI_STATUS
2102 CoreGetMemorySpaceDescriptor (
2103   IN  EFI_PHYSICAL_ADDRESS             BaseAddress,
2104   OUT EFI_GCD_MEMORY_SPACE_DESCRIPTOR  *Descriptor
2105   )
2106 /*++
2107
2108 Routine Description:
2109
2110   Search all entries in GCD map which contains specified segment and build it to a descriptor.
2111
2112 Arguments:
2113
2114   BaseAddress       - Specified start address
2115
2116   Descriptor        - Specified length
2117
2118 Returns:
2119
2120   EFI_INVALID_PARAMETER       - Invalid parameter
2121
2122   EFI_SUCCESS                 - Successfully get memory space descriptor.
2123
2124 --*/
2125 ;
2126
2127 EFI_STATUS
2128 CoreSetMemorySpaceAttributes (
2129   IN EFI_PHYSICAL_ADDRESS  BaseAddress,
2130   IN UINT64                Length,
2131   IN UINT64                Attributes
2132   )
2133 /*++
2134
2135 Routine Description:
2136
2137   Set memory space with specified attributes.
2138
2139 Arguments:
2140
2141   BaseAddress       - Specified start address
2142
2143   Length            - Specified length
2144
2145   Attributes        - Specified attributes
2146
2147 Returns:
2148
2149   EFI_SUCCESS       - Successfully set attribute of a segment of memory space.
2150
2151 --*/
2152 ;
2153
2154 EFI_STATUS
2155 CoreGetMemorySpaceMap (
2156   OUT UINTN                            *NumberOfDescriptors,
2157   OUT EFI_GCD_MEMORY_SPACE_DESCRIPTOR  **MemorySpaceMap
2158   )
2159 /*++
2160
2161 Routine Description:
2162
2163   Transer all entries of GCD memory map into memory descriptors and pass to caller.
2164
2165 Arguments:
2166
2167   NumberOfDescriptors       - Number of descriptors.
2168
2169   MemorySpaceMap            - Descriptor array
2170
2171 Returns:
2172
2173   EFI_INVALID_PARAMETER     - Invalid parameter
2174
2175   EFI_OUT_OF_RESOURCES      - No enough buffer to allocate
2176
2177   EFI_SUCCESS               - Successfully get memory space map.
2178
2179 --*/
2180 ;
2181
2182 EFI_STATUS
2183 CoreAddIoSpace (
2184   IN EFI_GCD_IO_TYPE       GcdIoType,
2185   IN EFI_PHYSICAL_ADDRESS  BaseAddress,
2186   IN UINT64                Length
2187   )
2188 /*++
2189
2190 Routine Description:
2191
2192   Add a segment of IO space to GCD map.
2193
2194 Arguments:
2195
2196   GcdIoType         - IO type of the segment.
2197
2198   BaseAddress       - Base address of the segment.
2199
2200   Length            - Length of the segment.
2201
2202 Returns:
2203
2204   EFI_SUCCESS       - Merged this segment into GCD map.
2205
2206 --*/
2207 ;
2208
2209 EFI_STATUS
2210 CoreAllocateIoSpace (
2211   IN     EFI_GCD_ALLOCATE_TYPE  GcdAllocateType,
2212   IN     EFI_GCD_IO_TYPE        GcdIoType,
2213   IN     UINTN                  Alignment,
2214   IN     UINT64                 Length,
2215   IN OUT EFI_PHYSICAL_ADDRESS   *BaseAddress,
2216   IN     EFI_HANDLE             ImageHandle,
2217   IN     EFI_HANDLE             DeviceHandle OPTIONAL
2218   )
2219 /*++
2220
2221 Routine Description:
2222
2223   Allocate IO space on GCD map.
2224
2225 Arguments:
2226
2227   GcdAllocateType   - The type of allocate operation
2228
2229   GcdIoType         - The desired IO type
2230
2231   Alignment         - Align with 2^Alignment
2232
2233   Length            - Length to allocate
2234
2235   BaseAddress       - Base address to allocate
2236
2237   ImageHandle       - The image handle consume the allocated space.
2238
2239   DeviceHandle      - The device handle consume the allocated space.
2240
2241 Returns:
2242
2243   EFI_INVALID_PARAMETER       - Invalid parameter.
2244
2245   EFI_NOT_FOUND               - No descriptor contains the desired space.
2246
2247   EFI_SUCCESS                 - IO space successfully allocated.
2248
2249 --*/
2250 ;
2251
2252 EFI_STATUS
2253 CoreFreeIoSpace (
2254   IN EFI_PHYSICAL_ADDRESS  BaseAddress,
2255   IN UINT64                Length
2256   )
2257 /*++
2258
2259 Routine Description:Routine Description:
2260
2261   Free a segment of IO space in GCD map.
2262
2263 Arguments:
2264
2265   BaseAddress       - Base address of the segment.
2266
2267   Length            - Length of the segment.
2268
2269 Returns:
2270
2271   EFI_SUCCESS       - Space successfully freed.
2272
2273 --*/
2274 ;
2275
2276 EFI_STATUS
2277 CoreRemoveIoSpace (
2278   IN EFI_PHYSICAL_ADDRESS  BaseAddress,
2279   IN UINT64                Length
2280   )
2281 /*++
2282
2283 Routine Description:Routine Description:
2284
2285   Remove a segment of IO space in GCD map.
2286
2287 Arguments:
2288
2289   BaseAddress       - Base address of the segment.
2290
2291   Length            - Length of the segment.
2292
2293 Returns:
2294
2295   EFI_SUCCESS       - Successfully removed a segment of IO space.
2296
2297 --*/
2298 ;
2299
2300 EFI_STATUS
2301 CoreGetIoSpaceDescriptor (
2302   IN  EFI_PHYSICAL_ADDRESS         BaseAddress,
2303   OUT EFI_GCD_IO_SPACE_DESCRIPTOR  *Descriptor
2304   )
2305 /*++
2306
2307 Routine Description:
2308
2309   Search all entries in GCD map which contains specified segment and build it to a descriptor.
2310
2311 Arguments:
2312
2313   BaseAddress       - Specified start address
2314
2315   Descriptor        - Specified length
2316
2317 Returns:
2318
2319   EFI_INVALID_PARAMETER       - Descriptor is NULL.
2320
2321   EFI_SUCCESS                 - Successfully get the IO space descriptor.
2322
2323 --*/
2324 ;
2325
2326 EFI_STATUS
2327 CoreGetIoSpaceMap (
2328   OUT UINTN                        *NumberOfDescriptors,
2329   OUT EFI_GCD_IO_SPACE_DESCRIPTOR  **IoSpaceMap
2330   )
2331 /*++
2332
2333 Routine Description:
2334
2335   Transer all entries of GCD IO map into IO descriptors and pass to caller.
2336
2337 Arguments:
2338
2339   NumberOfDescriptors       - Number of descriptors.
2340
2341   IoSpaceMap                - Descriptor array
2342
2343 Returns:
2344
2345   EFI_INVALID_PARAMETER     - Invalid parameter
2346
2347   EFI_OUT_OF_RESOURCES      - No enough buffer to allocate
2348
2349   EFI_SUCCESS               - Successfully get IO space map.
2350
2351 --*/
2352 ;
2353
2354 EFI_DXESERVICE
2355 EFI_STATUS
2356 EFIAPI
2357 CoreDispatcher (
2358   VOID
2359   )
2360 /*++
2361
2362 Routine Description:
2363
2364   This is the main Dispatcher for DXE and it exits when there are no more
2365   drivers to run. Drain the mScheduledQueue and load and start a PE
2366   image for each driver. Search the mDiscoveredList to see if any driver can
2367   be placed on the mScheduledQueue. If no drivers are placed on the
2368   mScheduledQueue exit the function. On exit it is assumed the Bds()
2369   will be called, and when the Bds() exits the Dispatcher will be called
2370   again.
2371
2372 Arguments:
2373
2374   NONE
2375
2376 Returns:
2377
2378   EFI_ALREADY_STARTED - The DXE Dispatcher is already running
2379
2380   EFI_NOT_FOUND       - No DXE Drivers were dispatched
2381
2382   EFI_SUCCESS         - One or more DXE Drivers were dispatched
2383
2384 --*/
2385 ;
2386 EFI_DXESERVICE
2387 EFI_STATUS
2388 EFIAPI
2389 CoreSchedule (
2390   IN  EFI_HANDLE  FirmwareVolumeHandle,
2391   IN  EFI_GUID    *DriverName
2392   )
2393 /*++
2394
2395 Routine Description:
2396
2397   Check every driver and locate a matching one. If the driver is found, the Unrequested
2398   state flag is cleared.
2399
2400 Arguments:
2401
2402   FirmwareVolumeHandle - The handle of the Firmware Volume that contains the firmware
2403                          file specified by DriverName.
2404
2405   DriverName           - The Driver name to put in the Dependent state.
2406
2407 Returns:
2408
2409   EFI_SUCCESS   - The DriverName was found and it's SOR bit was cleared
2410
2411   EFI_NOT_FOUND - The DriverName does not exist or it's SOR bit was not set.
2412
2413 --*/
2414 ;
2415
2416 EFI_DXESERVICE
2417 EFI_STATUS
2418 EFIAPI
2419 CoreTrust (
2420   IN  EFI_HANDLE  FirmwareVolumeHandle,
2421   IN  EFI_GUID    *DriverName
2422   )
2423 /*++
2424
2425 Routine Description:
2426
2427   Convert a driver from the Untrused back to the Scheduled state
2428
2429 Arguments:
2430
2431   FirmwareVolumeHandle - The handle of the Firmware Volume that contains the firmware
2432                          file specified by DriverName.
2433
2434   DriverName           - The Driver name to put in the Scheduled state
2435
2436 Returns:
2437
2438   EFI_SUCCESS   - The file was found in the untrusted state, and it was promoted
2439                   to the trusted state.
2440
2441   EFI_NOT_FOUND - The file was not found in the untrusted state.
2442
2443 --*/
2444 ;
2445
2446 BOOLEAN
2447 CoreGrowBuffer (
2448   IN OUT EFI_STATUS       *Status,
2449   IN OUT VOID             **Buffer,
2450   IN     UINTN            BufferSize
2451   )
2452 /*++
2453
2454 Routine Description:
2455
2456     Helper function called as part of the code needed
2457     to allocate the proper sized buffer for various
2458     EFI interfaces.
2459
2460 Arguments:
2461
2462     Status      - Current status
2463
2464     Buffer      - Current allocated buffer, or NULL
2465
2466     BufferSize  - Current buffer size needed
2467
2468 Returns:
2469
2470     TRUE - if the buffer was reallocated and the caller
2471     should try the API again.
2472
2473     FALSE - buffer could not be allocated and the caller
2474     should not try the API again.
2475
2476 --*/
2477 ;
2478
2479 EFI_STATUS
2480 EFIAPI
2481 FwVolDriverInit (
2482   IN EFI_HANDLE                   ImageHandle,
2483   IN EFI_SYSTEM_TABLE             *SystemTable
2484   )
2485 /*++
2486
2487 Routine Description:
2488     This routine is the driver initialization entry point.  It initializes the
2489     libraries, and registers two notification functions.  These notification
2490     functions are responsible for building the FV stack dynamically.
2491
2492 Arguments:
2493     ImageHandle   - The image handle.
2494     SystemTable   - The system table.
2495
2496 Returns:
2497     EFI_SUCCESS   - Function successfully returned.
2498
2499 --*/
2500 ;
2501
2502 EFI_STATUS
2503 EFIAPI
2504 InitializeSectionExtraction (
2505   IN EFI_HANDLE                   ImageHandle,
2506   IN EFI_SYSTEM_TABLE             *SystemTable
2507   )
2508 /*++
2509
2510 Routine Description:
2511   Entry point of the section extraction code. Initializes an instance of the
2512   section extraction interface and installs it on a new handle.
2513
2514 Arguments:
2515   ImageHandle   EFI_HANDLE: A handle for the image that is initializing this driver
2516   SystemTable   EFI_SYSTEM_TABLE: A pointer to the EFI system table
2517
2518 Returns:
2519   EFI_SUCCESS:  Driver initialized successfully
2520   EFI_OUT_OF_RESOURCES:   Could not allocate needed resources
2521
2522 --*/
2523 ;
2524
2525 EFI_STATUS
2526 CoreProcessFirmwareVolume (
2527   IN  VOID                         *FvHeader,
2528   IN  UINTN                        Size,
2529   OUT EFI_HANDLE                   *FVProtocolHandle
2530   )
2531 /*++
2532
2533 Routine Description:
2534     This DXE service routine is used to process a firmware volume. In
2535     particular, it can be called by BDS to process a single firmware
2536     volume found in a capsule.
2537
2538 Arguments:
2539     FvHeader              - pointer to a firmware volume header
2540     Size                  - the size of the buffer pointed to by FvHeader
2541     FVProtocolHandle      - the handle on which a firmware volume protocol
2542                             was produced for the firmware volume passed in.
2543
2544 Returns:
2545     EFI_OUT_OF_RESOURCES  - if an FVB could not be produced due to lack of
2546                             system resources
2547     EFI_VOLUME_CORRUPTED  - if the volume was corrupted
2548     EFI_SUCCESS           - a firmware volume protocol was produced for the
2549                             firmware volume
2550
2551 --*/
2552 ;
2553
2554 //
2555 //Functions used during debug buils
2556 //
2557 VOID
2558 CoreDisplayMissingArchProtocols (
2559   VOID
2560   )
2561 /*++
2562
2563   Routine Description:
2564   Displays Architectural protocols that were not loaded and are required for DXE core to function
2565   Only used in Debug Builds
2566
2567   Arguments:
2568     NONE
2569
2570   Returns:
2571     NONE
2572
2573 --*/;
2574
2575 VOID
2576 CoreDisplayDiscoveredNotDispatched (
2577   VOID
2578   )
2579 /*++
2580
2581   Routine Description:
2582
2583     Traverse the discovered list for any drivers that were discovered but not loaded
2584     because the dependency experessions evaluated to false
2585
2586   Arguments:
2587
2588     NONE
2589
2590   Returns:
2591
2592     NONE
2593
2594 --*/;
2595
2596 EFI_STATUS
2597 EFIAPI
2598 CoreEfiNotAvailableYetArg0 (
2599   VOID
2600   )
2601 /*++
2602
2603 Routine Description:
2604
2605   Place holder function until all the Boot Services and Runtime Services are available
2606
2607 Arguments:
2608
2609   None
2610
2611 Returns:
2612
2613   EFI_NOT_AVAILABLE_YET
2614
2615 --*/
2616 ;
2617
2618 EFI_STATUS
2619 EFIAPI
2620 CoreEfiNotAvailableYetArg1 (
2621   UINTN Arg1
2622   )
2623 /*++
2624
2625 Routine Description:
2626
2627   Place holder function until all the Boot Services and Runtime Services are available
2628
2629 Arguments:
2630
2631   Arg1        - Undefined
2632
2633 Returns:
2634
2635   EFI_NOT_AVAILABLE_YET
2636
2637 --*/
2638 ;
2639
2640 EFI_STATUS
2641 EFIAPI
2642 CoreEfiNotAvailableYetArg2 (
2643   UINTN Arg1,
2644   UINTN Arg2
2645   )
2646 /*++
2647
2648 Routine Description:
2649
2650   Place holder function until all the Boot Services and Runtime Services are available
2651
2652 Arguments:
2653
2654   Arg1        - Undefined
2655
2656   Arg2        - Undefined
2657
2658 Returns:
2659
2660   EFI_NOT_AVAILABLE_YET
2661
2662 --*/
2663 ;
2664
2665 EFI_STATUS
2666 EFIAPI
2667 CoreEfiNotAvailableYetArg3 (
2668   UINTN Arg1,
2669   UINTN Arg2,
2670   UINTN Arg3
2671   )
2672 /*++
2673
2674 Routine Description:
2675
2676   Place holder function until all the Boot Services and Runtime Services are available
2677
2678 Arguments:
2679
2680   Arg1        - Undefined
2681
2682   Arg2        - Undefined
2683
2684   Arg3        - Undefined
2685
2686 Returns:
2687
2688   EFI_NOT_AVAILABLE_YET
2689
2690 --*/
2691 ;
2692
2693 EFI_STATUS
2694 EFIAPI
2695 CoreEfiNotAvailableYetArg4 (
2696   UINTN Arg1,
2697   UINTN Arg2,
2698   UINTN Arg3,
2699   UINTN Arg4
2700   )
2701 /*++
2702
2703 Routine Description:
2704
2705   Place holder function until all the Boot Services and Runtime Services are available
2706
2707 Arguments:
2708
2709   Arg1        - Undefined
2710
2711   Arg2        - Undefined
2712
2713   Arg3        - Undefined
2714
2715   Arg4        - Undefined
2716
2717 Returns:
2718
2719   EFI_NOT_AVAILABLE_YET
2720
2721 --*/
2722 ;
2723
2724 EFI_STATUS
2725 EFIAPI
2726 CoreEfiNotAvailableYetArg5 (
2727   UINTN Arg1,
2728   UINTN Arg2,
2729   UINTN Arg3,
2730   UINTN Arg4,
2731   UINTN Arg5
2732   )
2733 /*++
2734
2735 Routine Description:
2736
2737   Place holder function until all the Boot Services and Runtime Services are available
2738
2739 Arguments:
2740
2741   Arg1        - Undefined
2742
2743   Arg2        - Undefined
2744
2745   Arg3        - Undefined
2746
2747   Arg4        - Undefined
2748
2749   Arg5        - Undefined
2750
2751 Returns:
2752
2753   EFI_NOT_AVAILABLE_YET
2754
2755 --*/
2756 ;
2757
2758 EFI_STATUS
2759 CoreGetPeiProtocol (
2760   IN EFI_GUID  *ProtocolGuid,
2761   IN VOID      **Interface
2762   )
2763 /*++
2764
2765 Routine Description:
2766
2767   Searches for a Protocol Interface passed from PEI through a HOB
2768
2769 Arguments:
2770
2771   ProtocolGuid - The Protocol GUID to search for in the HOB List
2772
2773   Interface    - A pointer to the interface for the Protocol GUID
2774
2775 Returns:
2776
2777   EFI_SUCCESS   - The Protocol GUID was found and its interface is returned in Interface
2778
2779   EFI_NOT_FOUND - The Protocol GUID was not found in the HOB List
2780
2781 --*/
2782 ;
2783
2784 EFI_STATUS
2785 DxeMainUefiDecompressGetInfo (
2786   IN EFI_DECOMPRESS_PROTOCOL            *This,
2787   IN   VOID                             *Source,
2788   IN   UINT32                           SourceSize,
2789   OUT  UINT32                           *DestinationSize,
2790   OUT  UINT32                           *ScratchSize
2791   );
2792
2793 EFI_STATUS
2794 EFIAPI
2795 DxeMainUefiDecompress (
2796   IN EFI_DECOMPRESS_PROTOCOL              *This,
2797   IN     VOID                             *Source,
2798   IN     UINT32                           SourceSize,
2799   IN OUT VOID                             *Destination,
2800   IN     UINT32                           DestinationSize,
2801   IN OUT VOID                             *Scratch,
2802   IN     UINT32                           ScratchSize
2803   );
2804
2805 EFI_STATUS
2806 DxeMainTianoDecompressGetInfo (
2807   IN EFI_TIANO_DECOMPRESS_PROTOCOL      *This,
2808   IN   VOID                             *Source,
2809   IN   UINT32                           SourceSize,
2810   OUT  UINT32                           *DestinationSize,
2811   OUT  UINT32                           *ScratchSize
2812   );
2813
2814 EFI_STATUS
2815 EFIAPI
2816 DxeMainTianoDecompress (
2817   IN EFI_TIANO_DECOMPRESS_PROTOCOL        *This,
2818   IN     VOID                             *Source,
2819   IN     UINT32                           SourceSize,
2820   IN OUT VOID                             *Destination,
2821   IN     UINT32                           DestinationSize,
2822   IN OUT VOID                             *Scratch,
2823   IN     UINT32                           ScratchSize
2824   );
2825
2826 EFI_STATUS
2827 DxeMainCustomDecompressGetInfo (
2828   IN EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL  *This,
2829   IN   VOID                              *Source,
2830   IN   UINT32                            SourceSize,
2831   OUT  UINT32                            *DestinationSize,
2832   OUT  UINT32                            *ScratchSize
2833   );
2834
2835 EFI_STATUS
2836 EFIAPI
2837 DxeMainCustomDecompress (
2838   IN EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL  *This,
2839   IN     VOID                            *Source,
2840   IN     UINT32                          SourceSize,
2841   IN OUT VOID                            *Destination,
2842   IN     UINT32                          DestinationSize,
2843   IN OUT VOID                            *Scratch,
2844   IN     UINT32                          ScratchSize
2845   );
2846
2847 #endif