EdkModulePkg/Core/Dxe/DxeMain/DxeMain.c

   1 /*++
   2
   3 Copyright (c) 2006, 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.c
  15
  16 Abstract:
  17
  18   DXE Core Main Entry Point
  19
  20 --*/
  21
  22 #include <DxeMain.h>
  23
  24 VOID
  25 EFIAPI
  26 DxeMain (
  27   IN  VOID *HobStart
  28   );
  29
  30 EFI_STATUS
  31 EFIAPI
  32 CoreEfiNotAvailableYetArg0 (
  33   VOID
  34   );
  35
  36 EFI_STATUS
  37 EFIAPI
  38 CoreEfiNotAvailableYetArg1 (
  39   UINTN Arg1
  40   );
  41
  42 EFI_STATUS
  43 EFIAPI
  44 CoreEfiNotAvailableYetArg2 (
  45   UINTN Arg1,
  46   UINTN Arg2
  47   );
  48
  49 EFI_STATUS
  50 EFIAPI
  51 CoreEfiNotAvailableYetArg3 (
  52   UINTN Arg1,
  53   UINTN Arg2,
  54   UINTN Arg3
  55   );
  56
  57 EFI_STATUS
  58 EFIAPI
  59 CoreEfiNotAvailableYetArg4 (
  60   UINTN Arg1,
  61   UINTN Arg2,
  62   UINTN Arg3,
  63   UINTN Arg4
  64   );
  65
  66 EFI_STATUS
  67 EFIAPI
  68 CoreEfiNotAvailableYetArg5 (
  69   UINTN Arg1,
  70   UINTN Arg2,
  71   UINTN Arg3,
  72   UINTN Arg4,
  73   UINTN Arg5
  74   );
  75
  76 EFI_STATUS
  77 CoreGetPeiProtocol (
  78   IN EFI_GUID  *ProtocolGuid,
  79   IN VOID      **Interface
  80   );
  81
  82 EFI_STATUS
  83 DxeMainUefiDecompressGetInfo (
  84   IN EFI_DECOMPRESS_PROTOCOL            *This,
  85   IN   VOID                             *Source,
  86   IN   UINT32                           SourceSize,
  87   OUT  UINT32                           *DestinationSize,
  88   OUT  UINT32                           *ScratchSize
  89   );
  90
  91 EFI_STATUS
  92 EFIAPI
  93 DxeMainUefiDecompress (
  94   IN EFI_DECOMPRESS_PROTOCOL              *This,
  95   IN     VOID                             *Source,
  96   IN     UINT32                           SourceSize,
  97   IN OUT VOID                             *Destination,
  98   IN     UINT32                           DestinationSize,
  99   IN OUT VOID                             *Scratch,
 100   IN     UINT32                           ScratchSize
 101   );
 102
 103 EFI_STATUS
 104 DxeMainTianoDecompressGetInfo (
 105   IN EFI_TIANO_DECOMPRESS_PROTOCOL      *This,
 106   IN   VOID                             *Source,
 107   IN   UINT32                           SourceSize,
 108   OUT  UINT32                           *DestinationSize,
 109   OUT  UINT32                           *ScratchSize
 110   );
 111
 112 EFI_STATUS
 113 EFIAPI
 114 DxeMainTianoDecompress (
 115   IN EFI_TIANO_DECOMPRESS_PROTOCOL        *This,
 116   IN     VOID                             *Source,
 117   IN     UINT32                           SourceSize,
 118   IN OUT VOID                             *Destination,
 119   IN     UINT32                           DestinationSize,
 120   IN OUT VOID                             *Scratch,
 121   IN     UINT32                           ScratchSize
 122   );
 123
 124 EFI_STATUS
 125 DxeMainCustomDecompressGetInfo (
 126   IN EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL  *This,
 127   IN   VOID                              *Source,
 128   IN   UINT32                            SourceSize,
 129   OUT  UINT32                            *DestinationSize,
 130   OUT  UINT32                            *ScratchSize
 131   );
 132
 133 EFI_STATUS
 134 EFIAPI
 135 DxeMainCustomDecompress (
 136   IN EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL  *This,
 137   IN     VOID                            *Source,
 138   IN     UINT32                          SourceSize,
 139   IN OUT VOID                            *Destination,
 140   IN     UINT32                          DestinationSize,
 141   IN OUT VOID                            *Scratch,
 142   IN     UINT32                          ScratchSize
 143   );
 144
 145 //
 146 // DXE Core Global Variables for Protocols from PEI
 147 //
 148 EFI_HANDLE                                mDecompressHandle = NULL;
 149 EFI_PEI_PE_COFF_LOADER_PROTOCOL           *gEfiPeiPeCoffLoader          = NULL;
 150
 151 //
 152 // DXE Core globals for Architecture Protocols
 153 //
 154 EFI_SECURITY_ARCH_PROTOCOL        *gSecurity      = NULL;
 155 EFI_CPU_ARCH_PROTOCOL             *gCpu           = NULL;
 156 EFI_METRONOME_ARCH_PROTOCOL       *gMetronome     = NULL;
 157 EFI_TIMER_ARCH_PROTOCOL           *gTimer         = NULL;
 158 EFI_BDS_ARCH_PROTOCOL             *gBds           = NULL;
 159 EFI_WATCHDOG_TIMER_ARCH_PROTOCOL  *gWatchdogTimer = NULL;
 160 EFI_RUNTIME_ARCH_PROTOCOL         *gRuntime       = NULL;
 161
 162 //
 163 // BugBug: I'n not runtime, but is the PPI?
 164 //
 165 EFI_STATUS_CODE_PROTOCOL     gStatusCodeInstance = {
 166   NULL
 167 };
 168
 169 EFI_STATUS_CODE_PROTOCOL     *gStatusCode    = &gStatusCodeInstance;
 170
 171
 172 //
 173 // DXE Core Global used to update core loaded image protocol handle
 174 //
 175 EFI_GUID                           *gDxeCoreFileName;
 176 EFI_LOADED_IMAGE_PROTOCOL          *gDxeCoreLoadedImage;
 177
 178
 179
 180 //
 181 // DXE Core Module Variables
 182 //
 183
 184 EFI_BOOT_SERVICES mBootServices = {
 185   {
 186     EFI_BOOT_SERVICES_SIGNATURE,                                                          // Signature
 187     EFI_BOOT_SERVICES_REVISION,                                                           // Revision
 188     sizeof (EFI_BOOT_SERVICES),                                                           // HeaderSize
 189     0,                                                                                    // CRC32
 190     0                                                                                     // Reserved
 191   },
 192   (EFI_RAISE_TPL)                               CoreRaiseTpl,                             // RaiseTPL
 193   (EFI_RESTORE_TPL)                             CoreRestoreTpl,                           // RestoreTPL
 194   (EFI_ALLOCATE_PAGES)                          CoreAllocatePages,                        // AllocatePages
 195   (EFI_FREE_PAGES)                              CoreFreePages,                            // FreePages
 196   (EFI_GET_MEMORY_MAP)                          CoreGetMemoryMap,                         // GetMemoryMap
 197   (EFI_ALLOCATE_POOL)                           CoreAllocatePool,                         // AllocatePool
 198   (EFI_FREE_POOL)                               CoreFreePool,                             // FreePool
 199   (EFI_CREATE_EVENT)                            CoreCreateEvent,                          // CreateEvent
 200   (EFI_SET_TIMER)                               CoreSetTimer,                             // SetTimer
 201   (EFI_WAIT_FOR_EVENT)                          CoreWaitForEvent,                         // WaitForEvent
 202   (EFI_SIGNAL_EVENT)                            CoreSignalEvent,                          // SignalEvent
 203   (EFI_CLOSE_EVENT)                             CoreCloseEvent,                           // CloseEvent
 204   (EFI_CHECK_EVENT)                             CoreCheckEvent,                           // CheckEvent
 205   (EFI_INSTALL_PROTOCOL_INTERFACE)              CoreInstallProtocolInterface,             // InstallProtocolInterface
 206   (EFI_REINSTALL_PROTOCOL_INTERFACE)            CoreReinstallProtocolInterface,           // ReinstallProtocolInterface
 207   (EFI_UNINSTALL_PROTOCOL_INTERFACE)            CoreUninstallProtocolInterface,           // UninstallProtocolInterface
 208   (EFI_HANDLE_PROTOCOL)                         CoreHandleProtocol,                       // HandleProtocol
 209   (VOID *)                                      NULL,                                     // Reserved
 210   (EFI_REGISTER_PROTOCOL_NOTIFY)                CoreRegisterProtocolNotify,               // RegisterProtocolNotify
 211   (EFI_LOCATE_HANDLE)                           CoreLocateHandle,                         // LocateHandle
 212   (EFI_LOCATE_DEVICE_PATH)                      CoreLocateDevicePath,                     // LocateDevicePath
 213   (EFI_INSTALL_CONFIGURATION_TABLE)             CoreInstallConfigurationTable,            // InstallConfigurationTable
 214   (EFI_IMAGE_LOAD)                              CoreLoadImage,                            // LoadImage
 215   (EFI_IMAGE_START)                             CoreStartImage,                           // StartImage
 216   (EFI_EXIT)                                    CoreExit,                                 // Exit
 217   (EFI_IMAGE_UNLOAD)                            CoreUnloadImage,                          // UnloadImage
 218   (EFI_EXIT_BOOT_SERVICES)                      CoreExitBootServices,                     // ExitBootServices
 219   (EFI_GET_NEXT_MONOTONIC_COUNT)                CoreEfiNotAvailableYetArg1,               // GetNextMonotonicCount
 220   (EFI_STALL)                                   CoreStall,                                // Stall
 221   (EFI_SET_WATCHDOG_TIMER)                      CoreSetWatchdogTimer,                     // SetWatchdogTimer
 222   (EFI_CONNECT_CONTROLLER)                      CoreConnectController,                    // ConnectController
 223   (EFI_DISCONNECT_CONTROLLER)                   CoreDisconnectController,                 // DisconnectController
 224   (EFI_OPEN_PROTOCOL)                           CoreOpenProtocol,                         // OpenProtocol
 225   (EFI_CLOSE_PROTOCOL)                          CoreCloseProtocol,                        // CloseProtocol
 226   (EFI_OPEN_PROTOCOL_INFORMATION)               CoreOpenProtocolInformation,              // OpenProtocolInformation
 227   (EFI_PROTOCOLS_PER_HANDLE)                    CoreProtocolsPerHandle,                   // ProtocolsPerHandle
 228   (EFI_LOCATE_HANDLE_BUFFER)                    CoreLocateHandleBuffer,                   // LocateHandleBuffer
 229   (EFI_LOCATE_PROTOCOL)                         CoreLocateProtocol,                       // LocateProtocol
 230   (EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES)    CoreInstallMultipleProtocolInterfaces,    // InstallMultipleProtocolInterfaces
 231   (EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES)  CoreUninstallMultipleProtocolInterfaces,  // UninstallMultipleProtocolInterfaces
 232   (EFI_CALCULATE_CRC32)                         CoreEfiNotAvailableYetArg3,               // CalculateCrc32
 233   (EFI_COPY_MEM)                                CopyMem,                                  // CopyMem
 234   (EFI_SET_MEM)                                 SetMem                                    // SetMem
 235 #if (EFI_SPECIFICATION_VERSION >= 0x00020000)
 236   ,
 237   (EFI_CREATE_EVENT_EX)                          CoreCreateEventEx                         // CreateEventEx
 238 #endif
 239 };
 240
 241 EFI_DXE_SERVICES mDxeServices = {
 242   {
 243     EFI_DXE_SERVICES_SIGNATURE,                                           // Signature
 244     EFI_DXE_SERVICES_REVISION,                                            // Revision
 245     sizeof (EFI_DXE_SERVICES),                                            // HeaderSize
 246     0,                                                                    // CRC32
 247     0                                                                     // Reserved
 248   },
 249   (EFI_ADD_MEMORY_SPACE)             CoreAddMemorySpace,                  // AddMemorySpace
 250   (EFI_ALLOCATE_MEMORY_SPACE)        CoreAllocateMemorySpace,             // AllocateMemorySpace
 251   (EFI_FREE_MEMORY_SPACE)            CoreFreeMemorySpace,                 // FreeMemorySpace
 252   (EFI_REMOVE_MEMORY_SPACE)          CoreRemoveMemorySpace,               // RemoveMemorySpace
 253   (EFI_GET_MEMORY_SPACE_DESCRIPTOR)  CoreGetMemorySpaceDescriptor,        // GetMemorySpaceDescriptor
 254   (EFI_SET_MEMORY_SPACE_ATTRIBUTES)  CoreSetMemorySpaceAttributes,        // SetMemorySpaceAttributes
 255   (EFI_GET_MEMORY_SPACE_MAP)         CoreGetMemorySpaceMap,               // GetMemorySpaceMap
 256   (EFI_ADD_IO_SPACE)                 CoreAddIoSpace,                      // AddIoSpace
 257   (EFI_ALLOCATE_IO_SPACE)            CoreAllocateIoSpace,                 // AllocateIoSpace
 258   (EFI_FREE_IO_SPACE)                CoreFreeIoSpace,                     // FreeIoSpace
 259   (EFI_REMOVE_IO_SPACE)              CoreRemoveIoSpace,                   // RemoveIoSpace
 260   (EFI_GET_IO_SPACE_DESCRIPTOR)      CoreGetIoSpaceDescriptor,            // GetIoSpaceDescriptor
 261   (EFI_GET_IO_SPACE_MAP)             CoreGetIoSpaceMap,                   // GetIoSpaceMap
 262   (EFI_DISPATCH)                     CoreDispatcher,                      // Dispatch
 263   (EFI_SCHEDULE)                     CoreSchedule,                        // Schedule
 264   (EFI_TRUST)                        CoreTrust,                           // Trust
 265   (EFI_PROCESS_FIRMWARE_VOLUME)      CoreProcessFirmwareVolume,           // ProcessFirmwareVolume
 266 };
 267
 268 EFI_SYSTEM_TABLE mEfiSystemTableTemplate = {
 269   {
 270     EFI_SYSTEM_TABLE_SIGNATURE,                                           // Signature
 271     EFI_SYSTEM_TABLE_REVISION,                                            // Revision
 272     sizeof (EFI_SYSTEM_TABLE),                                            // HeaderSize
 273     0,                                                                    // CRC32
 274     0                                                                     // Reserved
 275   },
 276   NULL,                                                                   // FirmwareVendor
 277   0,                                                                      // FirmwareRevision
 278   NULL,                                                                   // ConsoleInHandle
 279   NULL,                                                                   // ConIn
 280   NULL,                                                                   // ConsoleOutHandle
 281   NULL,                                                                   // ConOut
 282   NULL,                                                                   // StandardErrorHandle
 283   NULL,                                                                   // StdErr
 284   NULL,                                                                   // RuntimeServices
 285   &mBootServices,                                                         // BootServices
 286   0,                                                                      // NumberOfConfigurationTableEntries
 287   NULL                                                                    // ConfigurationTable
 288 };
 289
 290 EFI_RUNTIME_SERVICES mEfiRuntimeServicesTableTemplate = {
 291   {
 292     EFI_RUNTIME_SERVICES_SIGNATURE,                               // Signature
 293     EFI_RUNTIME_SERVICES_REVISION,                                // Revision
 294     sizeof (EFI_RUNTIME_SERVICES),                                // HeaderSize
 295     0,                                                            // CRC32
 296     0                                                             // Reserved
 297   },
 298   (EFI_GET_TIME)                 CoreEfiNotAvailableYetArg2,      // GetTime
 299   (EFI_SET_TIME)                 CoreEfiNotAvailableYetArg1,      // SetTime
 300   (EFI_GET_WAKEUP_TIME)          CoreEfiNotAvailableYetArg3,      // GetWakeupTime
 301   (EFI_SET_WAKEUP_TIME)          CoreEfiNotAvailableYetArg2,      // SetWakeupTime
 302   (EFI_SET_VIRTUAL_ADDRESS_MAP)  CoreEfiNotAvailableYetArg4,      // SetVirtualAddressMap
 303   (EFI_CONVERT_POINTER)          CoreEfiNotAvailableYetArg2,      // ConvertPointer
 304   (EFI_GET_VARIABLE)             CoreEfiNotAvailableYetArg5,      // GetVariable
 305   (EFI_GET_NEXT_VARIABLE_NAME)   CoreEfiNotAvailableYetArg3,      // GetNextVariableName
 306   (EFI_SET_VARIABLE)             CoreEfiNotAvailableYetArg5,      // SetVariable
 307   (EFI_GET_NEXT_HIGH_MONO_COUNT) CoreEfiNotAvailableYetArg1,      // GetNextHighMonotonicCount
 308   (EFI_RESET_SYSTEM)             CoreEfiNotAvailableYetArg4       // ResetSystem
 309 #if ((EDK_RELEASE_VERSION != 0) && (EFI_SPECIFICATION_VERSION <  0x00020000))
 310   //
 311   // This Tiano extension was removed when UEFI 2.0 support was added.
 312   // It's now just a protocol.
 313   //
 314   ,
 315   (EFI_REPORT_STATUS_CODE)       CoreEfiNotAvailableYetArg5       // ReportStatusCode
 316 #elif (EFI_SPECIFICATION_VERSION >= 0x00020000)
 317   //
 318   // New runtime services added by UEFI 2.0
 319   //
 320   ,
 321   (EFI_UPDATE_CAPSULE)              CoreEfiNotAvailableYetArg3,   // UpdateCapsule
 322   (EFI_QUERY_CAPSULE_CAPABILITIES)  CoreEfiNotAvailableYetArg4,   // QueryCapsuleCapabilities
 323   (EFI_QUERY_VARIABLE_INFO)         CoreEfiNotAvailableYetArg4    // QueryVariableInfo
 324 #endif
 325 };
 326
 327 //
 328 // DXE Core Global Variables for the EFI System Table, Boot Services Table,
 329 // DXE Services Table, and Runtime Services Table
 330 //
 331 EFI_BOOT_SERVICES     *gBS = &mBootServices;
 332 EFI_DXE_SERVICES      *gDS = &mDxeServices;
 333 EFI_SYSTEM_TABLE      *gST = NULL;
 334
 335 //
 336 // For debug initialize gRT to template. gRT must be allocated from RT memory
 337 //  but gRT is used for ASSERT () and DEBUG () type macros so lets give it
 338 //  a value that will not cause debug infrastructure to crash early on.
 339 //
 340 EFI_RUNTIME_SERVICES  *gRT = &mEfiRuntimeServicesTableTemplate;
 341 EFI_HANDLE            gDxeCoreImageHandle = NULL;
 342
 343 VOID  *mHobStart;
 344
 345 //
 346 // EFI Decompress Protocol
 347 //
 348 EFI_DECOMPRESS_PROTOCOL  gEfiDecompress = {
 349   DxeMainUefiDecompressGetInfo,
 350   DxeMainUefiDecompress
 351 };
 352
 353 //
 354 // Tiano Decompress Protocol
 355 //
 356 EFI_TIANO_DECOMPRESS_PROTOCOL  gEfiTianoDecompress = {
 357   DxeMainTianoDecompressGetInfo,
 358   DxeMainTianoDecompress
 359 };
 360
 361 //
 362 // Customized Decompress Protocol
 363 //
 364 EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL  gEfiCustomizedDecompress = {
 365   DxeMainCustomDecompressGetInfo,
 366   DxeMainCustomDecompress
 367 };
 368
 369 //
 370 // Main entry point to the DXE Core
 371 //
 372 VOID
 373 EFIAPI
 374 DxeMain (
 375   IN  VOID *HobStart
 376   )
 377 /*++
 378
 379 Routine Description:
 380
 381   Main entry point to DXE Core.
 382
 383 Arguments:
 384
 385   HobStart - Pointer to the beginning of the HOB List from PEI
 386
 387 Returns:
 388
 389   This function should never return
 390
 391 --*/
 392 {
 393   EFI_STATUS                         Status;
 394   EFI_PHYSICAL_ADDRESS               MemoryBaseAddress;
 395   UINT64                             MemoryLength;
 396
 397 #ifdef EFI_DXE_PERFORMANCE
 398   UINT64                             Tick;
 399
 400   GetTimerValue (&Tick);
 401 #endif
 402
 403   mHobStart = HobStart;
 404
 405   //
 406   // Initialize Memory Services
 407   //
 408   CoreInitializeMemoryServices (&HobStart, &MemoryBaseAddress, &MemoryLength);
 409
 410   //
 411   // Allocate the EFI System Table and EFI Runtime Service Table from EfiRuntimeServicesData
 412   // Use the templates to initialize the contents of the EFI System Table and EFI Runtime Services Table
 413   //
 414   gST = CoreAllocateRuntimeCopyPool (sizeof (EFI_SYSTEM_TABLE), &mEfiSystemTableTemplate);
 415   ASSERT (gST != NULL);
 416
 417   gRT = CoreAllocateRuntimeCopyPool (sizeof (EFI_RUNTIME_SERVICES), &mEfiRuntimeServicesTableTemplate);
 418   ASSERT (gRT != NULL);
 419
 420   gST->RuntimeServices = gRT;
 421
 422   //
 423   // Start the Image Services.
 424   //
 425   Status = CoreInitializeImageServices (HobStart);
 426   ASSERT_EFI_ERROR (Status);
 427
 428   //
 429   // Call constructor for all libraries
 430   //
 431   ProcessLibraryConstructorList (gDxeCoreImageHandle, gST);
 432
 433   //
 434   // Initialize the Global Coherency Domain Services
 435   //
 436   Status = CoreInitializeGcdServices (&HobStart, MemoryBaseAddress, MemoryLength);
 437   ASSERT_EFI_ERROR (Status);
 438
 439   //
 440   // Install the DXE Services Table into the EFI System Tables's Configuration Table
 441   //
 442   Status = CoreInstallConfigurationTable (&gEfiDxeServicesTableGuid, gDS);
 443   ASSERT_EFI_ERROR (Status);
 444
 445   //
 446   // Install the HOB List into the EFI System Tables's Configuration Table
 447   //
 448   Status = CoreInstallConfigurationTable (&gEfiHobListGuid, HobStart);
 449   ASSERT_EFI_ERROR (Status);
 450
 451   //
 452   // Install Memory Type Information Table into the EFI System Tables's Configuration Table
 453   //
 454   Status = CoreInstallConfigurationTable (&gEfiMemoryTypeInformationGuid, &gMemoryTypeInformation);
 455   ASSERT_EFI_ERROR (Status);
 456
 457   //
 458   // Initialize the ReportStatusCode with PEI version, if availible
 459   //
 460   CoreGetPeiProtocol (&gEfiStatusCodeRuntimeProtocolGuid, (VOID **)&gStatusCode->ReportStatusCode);
 461 #if ((EDK_RELEASE_VERSION != 0) && (EFI_SPECIFICATION_VERSION < 0x00020000))
 462   //
 463   // This Tiano extension was removed when UEFI 2.0 support was added.
 464   // It's now just a protocol.
 465   //
 466   gRT->ReportStatusCode = gStatusCode->ReportStatusCode;
 467 #endif
 468
 469   //
 470   // Report Status Code here for DXE_ENTRY_POINT once it is available
 471   //
 472   CoreReportProgressCode ((EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_PC_ENTRY_POINT));
 473
 474   //
 475   // Create the aligned system table pointer structure that is used by external
 476   // debuggers to locate the system table...  Also, install debug image info
 477   // configuration table.
 478   //
 479   CoreInitializeDebugImageInfoTable ();
 480   CoreNewDebugImageInfoEntry (
 481     EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL,
 482     gDxeCoreLoadedImage,
 483     gDxeCoreImageHandle
 484     );
 485
 486   DEBUG ((EFI_D_INFO | EFI_D_LOAD, "HOBLIST address in DXE = 0x%08x\n", HobStart));
 487
 488   //
 489   // Initialize the Event Services
 490   //
 491   Status = CoreInitializeEventServices ();
 492   ASSERT_EFI_ERROR (Status);
 493
 494
 495   //
 496   // Get the Protocols that were passed in from PEI to DXE through GUIDed HOBs
 497   //
 498   // These Protocols are not architectural. This implementation is sharing code between
 499   // PEI and DXE in order to save FLASH space. These Protocols could also be implemented
 500   // as part of the DXE Core. However, that would also require the DXE Core to be ported
 501   // each time a different CPU is used, a different Decompression algorithm is used, or a
 502   // different Image type is used. By placing these Protocols in PEI, the DXE Core remains
 503   // generic, and only PEI and the Arch Protocols need to be ported from Platform to Platform,
 504   // and from CPU to CPU.
 505   //
 506
 507   //
 508   // Publish the EFI, Tiano, and Custom Decompress protocols for use by other DXE components
 509   //
 510   Status = CoreInstallMultipleProtocolInterfaces (
 511               &mDecompressHandle,
 512               &gEfiDecompressProtocolGuid,           &gEfiDecompress,
 513               &gEfiTianoDecompressProtocolGuid,      &gEfiTianoDecompress,
 514               &gEfiCustomizedDecompressProtocolGuid, &gEfiCustomizedDecompress,
 515               NULL
 516               );
 517   ASSERT_EFI_ERROR (Status);
 518
 519   gEfiPeiPeCoffLoader = GetPeCoffLoaderProtocol ();
 520   ASSERT (gEfiPeiPeCoffLoader != NULL);
 521
 522   //
 523   // Register for the GUIDs of the Architectural Protocols, so the rest of the
 524   // EFI Boot Services and EFI Runtime Services tables can be filled in.
 525   //
 526   CoreNotifyOnArchProtocolInstallation ();
 527
 528   //
 529   // Produce Firmware Volume Protocols, one for each FV in the HOB list.
 530   //
 531   Status = FwVolBlockDriverInit (gDxeCoreImageHandle, gST);
 532   ASSERT_EFI_ERROR (Status);
 533
 534   Status = FwVolDriverInit (gDxeCoreImageHandle, gST);
 535   ASSERT_EFI_ERROR (Status);
 536
 537   //
 538   // Produce the Section Extraction Protocol
 539   //
 540   Status = InitializeSectionExtraction (gDxeCoreImageHandle, gST);
 541   ASSERT_EFI_ERROR (Status);
 542
 543   //
 544   // Initialize the DXE Dispatcher
 545   //
 546   PERF_START (0,"CoreInitializeDispatcher", "DxeMain", 0) ;
 547   CoreInitializeDispatcher ();
 548   PERF_END (0,"CoreInitializeDispatcher", "DxeMain", 0) ;
 549
 550   //
 551   // Invoke the DXE Dispatcher
 552   //
 553   PERF_START (0, "CoreDispatcher", "DxeMain", 0);
 554   CoreDispatcher ();
 555   PERF_END (0, "CoreDispatcher", "DxeMain", 0);
 556
 557   //
 558   // Display Architectural protocols that were not loaded if this is DEBUG build
 559   //
 560   DEBUG_CODE_BEGIN ();
 561     CoreDisplayMissingArchProtocols ();
 562   DEBUG_CODE_END ();
 563
 564   //
 565   // Assert if the Architectural Protocols are not present.
 566   //
 567   ASSERT_EFI_ERROR (CoreAllEfiServicesAvailable ());
 568
 569   //
 570   // Report Status code before transfer control to BDS
 571   //
 572   CoreReportProgressCode ((EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_PC_HANDOFF_TO_NEXT));
 573   //
 574   // Display any drivers that were not dispatched because dependency expression
 575   // evaluated to false if this is a debug build
 576   //
 577   DEBUG_CODE_BEGIN ();
 578     CoreDisplayDiscoveredNotDispatched ();
 579   DEBUG_CODE_END ();
 580
 581   //
 582   // Transfer control to the BDS Architectural Protocol
 583   //
 584   gBds->Entry (gBds);
 585
 586   //
 587   // BDS should never return
 588   //
 589   ASSERT (FALSE);
 590   CpuDeadLoop ();
 591 }
 592
 593
 594 EFI_STATUS
 595 EFIAPI
 596 CoreEfiNotAvailableYetArg0 (
 597   VOID
 598   )
 599 /*++
 600
 601 Routine Description:
 602
 603   Place holder function until all the Boot Services and Runtime Services are available
 604
 605 Arguments:
 606
 607   None
 608
 609 Returns:
 610
 611   EFI_NOT_AVAILABLE_YET
 612
 613 --*/
 614 {
 615   //
 616   // This function should never be executed.  If it does, then the architectural protocols
 617   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 618   // DXE Core and all the Architectural Protocols are complete.
 619   //
 620
 621   return EFI_NOT_AVAILABLE_YET;
 622 }
 623
 624 EFI_STATUS
 625 EFIAPI
 626 CoreEfiNotAvailableYetArg1 (
 627   UINTN Arg1
 628   )
 629 /*++
 630
 631 Routine Description:
 632
 633   Place holder function until all the Boot Services and Runtime Services are available
 634
 635 Arguments:
 636
 637   Arg1        - Undefined
 638
 639 Returns:
 640
 641   EFI_NOT_AVAILABLE_YET
 642
 643 --*/
 644 {
 645   //
 646   // This function should never be executed.  If it does, then the architectural protocols
 647   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 648   // DXE Core and all the Architectural Protocols are complete.
 649   //
 650
 651   return EFI_NOT_AVAILABLE_YET;
 652 }
 653
 654 EFI_STATUS
 655 EFIAPI
 656 CoreEfiNotAvailableYetArg2 (
 657   UINTN Arg1,
 658   UINTN Arg2
 659   )
 660 /*++
 661
 662 Routine Description:
 663
 664   Place holder function until all the Boot Services and Runtime Services are available
 665
 666 Arguments:
 667
 668   Arg1        - Undefined
 669
 670   Arg2        - Undefined
 671
 672 Returns:
 673
 674   EFI_NOT_AVAILABLE_YET
 675
 676 --*/
 677 {
 678   //
 679   // This function should never be executed.  If it does, then the architectural protocols
 680   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 681   // DXE Core and all the Architectural Protocols are complete.
 682   //
 683
 684   return EFI_NOT_AVAILABLE_YET;
 685 }
 686
 687 EFI_STATUS
 688 EFIAPI
 689 CoreEfiNotAvailableYetArg3 (
 690   UINTN Arg1,
 691   UINTN Arg2,
 692   UINTN Arg3
 693   )
 694 /*++
 695
 696 Routine Description:
 697
 698   Place holder function until all the Boot Services and Runtime Services are available
 699
 700 Arguments:
 701
 702   Arg1        - Undefined
 703
 704   Arg2        - Undefined
 705
 706   Arg3        - Undefined
 707
 708 Returns:
 709
 710   EFI_NOT_AVAILABLE_YET
 711
 712 --*/
 713 {
 714   //
 715   // This function should never be executed.  If it does, then the architectural protocols
 716   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 717   // DXE Core and all the Architectural Protocols are complete.
 718   //
 719
 720   return EFI_NOT_AVAILABLE_YET;
 721 }
 722
 723 EFI_STATUS
 724 EFIAPI
 725 CoreEfiNotAvailableYetArg4 (
 726   UINTN Arg1,
 727   UINTN Arg2,
 728   UINTN Arg3,
 729   UINTN Arg4
 730   )
 731 /*++
 732
 733 Routine Description:
 734
 735   Place holder function until all the Boot Services and Runtime Services are available
 736
 737 Arguments:
 738
 739   Arg1        - Undefined
 740
 741   Arg2        - Undefined
 742
 743   Arg3        - Undefined
 744
 745   Arg4        - Undefined
 746
 747 Returns:
 748
 749   EFI_NOT_AVAILABLE_YET
 750
 751 --*/
 752 {
 753   //
 754   // This function should never be executed.  If it does, then the architectural protocols
 755   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 756   // DXE Core and all the Architectural Protocols are complete.
 757   //
 758
 759   return EFI_NOT_AVAILABLE_YET;
 760 }
 761
 762 EFI_STATUS
 763 EFIAPI
 764 CoreEfiNotAvailableYetArg5 (
 765   UINTN Arg1,
 766   UINTN Arg2,
 767   UINTN Arg3,
 768   UINTN Arg4,
 769   UINTN Arg5
 770   )
 771 /*++
 772
 773 Routine Description:
 774
 775   Place holder function until all the Boot Services and Runtime Services are available
 776
 777 Arguments:
 778
 779   Arg1        - Undefined
 780
 781   Arg2        - Undefined
 782
 783   Arg3        - Undefined
 784
 785   Arg4        - Undefined
 786
 787   Arg5        - Undefined
 788
 789 Returns:
 790
 791   EFI_NOT_AVAILABLE_YET
 792
 793 --*/
 794 {
 795   //
 796   // This function should never be executed.  If it does, then the architectural protocols
 797   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 798   // DXE Core and all the Architectural Protocols are complete.
 799   //
 800
 801   return EFI_NOT_AVAILABLE_YET;
 802 }
 803
 804
 805 EFI_STATUS
 806 CoreGetPeiProtocol (
 807   IN EFI_GUID  *ProtocolGuid,
 808   IN VOID      **Interface
 809   )
 810 /*++
 811
 812 Routine Description:
 813
 814   Searches for a Protocol Interface passed from PEI through a HOB
 815
 816 Arguments:
 817
 818   ProtocolGuid - The Protocol GUID to search for in the HOB List
 819
 820   Interface    - A pointer to the interface for the Protocol GUID
 821
 822 Returns:
 823
 824   EFI_SUCCESS   - The Protocol GUID was found and its interface is returned in Interface
 825
 826   EFI_NOT_FOUND - The Protocol GUID was not found in the HOB List
 827
 828 --*/
 829 {
 830   EFI_HOB_GUID_TYPE   *GuidHob;
 831   VOID                *Buffer;
 832
 833   GuidHob = GetNextGuidHob (ProtocolGuid, mHobStart);
 834   if (GuidHob == NULL) {
 835     return EFI_NOT_FOUND;
 836   }
 837
 838   Buffer = GET_GUID_HOB_DATA (GuidHob);
 839   ASSERT (Buffer != NULL);
 840
 841   *Interface = (VOID *)(*(UINTN *)(Buffer));
 842
 843   return EFI_SUCCESS;
 844 }
 845
 846
 847 VOID
 848 CalculateEfiHdrCrc (
 849   IN  OUT EFI_TABLE_HEADER    *Hdr
 850   )
 851 /*++
 852
 853 Routine Description:
 854
 855   Calcualte the 32-bit CRC in a EFI table using the service provided by the
 856   gRuntime service.
 857
 858 Arguments:
 859
 860   Hdr  - Pointer to an EFI standard header
 861
 862 Returns:
 863
 864   None
 865
 866 --*/
 867 {
 868   UINT32 Crc;
 869
 870   Hdr->CRC32 = 0;
 871
 872   //
 873   // If gBS->CalculateCrce32 () == CoreEfiNotAvailableYet () then
 874   //  Crc will come back as zero if we set it to zero here
 875   //
 876   Crc = 0;
 877   gBS->CalculateCrc32 ((UINT8 *)Hdr, Hdr->HeaderSize, &Crc);
 878   Hdr->CRC32 = Crc;
 879 }
 880
 881
 882
 883 EFI_STATUS
 884 EFIAPI
 885 CoreExitBootServices (
 886   IN EFI_HANDLE   ImageHandle,
 887   IN UINTN        MapKey
 888   )
 889 /*++
 890
 891 Routine Description:
 892
 893   EFI 1.0 API to terminate Boot Services
 894
 895 Arguments:
 896
 897   ImageHandle  - Handle that represents the identity of the calling image
 898
 899   MapKey -Key to the latest memory map.
 900
 901 Returns:
 902
 903   EFI_SUCCESS - Boot Services terminated
 904   EFI_INVALID_PARAMETER - MapKey is incorrect.
 905
 906 --*/
 907 {
 908   EFI_STATUS    Status;
 909
 910   //
 911   // Terminate memory services if the MapKey matches
 912   //
 913   Status = CoreTerminateMemoryMap (MapKey);
 914   if (EFI_ERROR (Status)) {
 915     return Status;
 916   }
 917
 918   //
 919   // Notify other drivers that we are exiting boot services.
 920   //
 921   CoreNotifySignalList (&gEfiEventExitBootServicesGuid);
 922
 923   //
 924   // Disable Timer
 925   //
 926   gTimer->SetTimerPeriod (gTimer, 0);
 927
 928   //
 929   // Disable CPU Interrupts
 930   //
 931   gCpu->DisableInterrupt (gCpu);
 932
 933   //
 934   // Register Runtime events with the Runtime Architectural Protocol
 935   //
 936   CoreShutdownEventServices ();
 937
 938   //
 939   // Register Runtime images with the Runtime Architectural Protocol
 940   //
 941   CoreShutdownImageServices ();
 942
 943   //
 944   // Report that ExitBootServices() has been called
 945   //
 946   // We are using gEfiDxeServicesTableGuid as the caller ID for Dxe Core
 947   //
 948   CoreReportProgressCode ((EFI_SOFTWARE_EFI_BOOT_SERVICE | EFI_SW_BS_PC_EXIT_BOOT_SERVICES));
 949
 950   //
 951   // Clear the non-runtime values of the EFI System Table
 952   //
 953   gST->BootServices        = NULL;
 954   gST->ConIn               = NULL;
 955   gST->ConsoleInHandle     = NULL;
 956   gST->ConOut              = NULL;
 957   gST->ConsoleOutHandle    = NULL;
 958   gST->StdErr              = NULL;
 959   gST->StandardErrorHandle = NULL;
 960
 961   //
 962   // Recompute the 32-bit CRC of the EFI System Table
 963   //
 964   CalculateEfiHdrCrc (&gST->Hdr);
 965
 966   //
 967   // Zero out the Boot Service Table
 968   //
 969   SetMem (gBS, sizeof (EFI_BOOT_SERVICES), 0);
 970   gBS = NULL;
 971
 972   return Status;
 973 }
 974
 975 EFI_STATUS
 976 DxeMainUefiDecompressGetInfo (
 977   IN EFI_DECOMPRESS_PROTOCOL            *This,
 978   IN   VOID                             *Source,
 979   IN   UINT32                           SourceSize,
 980   OUT  UINT32                           *DestinationSize,
 981   OUT  UINT32                           *ScratchSize
 982   )
 983 {
 984   return UefiDecompressGetInfo (Source, SourceSize, DestinationSize, ScratchSize);
 985 }
 986
 987 EFI_STATUS
 988 EFIAPI
 989 DxeMainUefiDecompress (
 990   IN EFI_DECOMPRESS_PROTOCOL              *This,
 991   IN     VOID                             *Source,
 992   IN     UINT32                           SourceSize,
 993   IN OUT VOID                             *Destination,
 994   IN     UINT32                           DestinationSize,
 995   IN OUT VOID                             *Scratch,
 996   IN     UINT32                           ScratchSize
 997   )
 998 {
 999   EFI_STATUS  Status;
1000   UINT32      TestDestinationSize;
1001   UINT32      TestScratchSize;
1002
1003   Status = UefiDecompressGetInfo (Source, SourceSize, &TestDestinationSize, &TestScratchSize);
1004   if (EFI_ERROR (Status)) {
1005     return Status;
1006   }
1007
1008   if (ScratchSize < TestScratchSize || DestinationSize < TestDestinationSize) {
1009     return RETURN_INVALID_PARAMETER;
1010   }
1011
1012   return UefiDecompress (Source, Destination, Scratch);
1013 }
1014
1015 EFI_STATUS
1016 DxeMainTianoDecompressGetInfo (
1017   IN EFI_TIANO_DECOMPRESS_PROTOCOL      *This,
1018   IN   VOID                             *Source,
1019   IN   UINT32                           SourceSize,
1020   OUT  UINT32                           *DestinationSize,
1021   OUT  UINT32                           *ScratchSize
1022   )
1023 {
1024   return TianoDecompressGetInfo (Source, SourceSize, DestinationSize, ScratchSize);
1025 }
1026
1027 EFI_STATUS
1028 EFIAPI
1029 DxeMainTianoDecompress (
1030   IN EFI_TIANO_DECOMPRESS_PROTOCOL        *This,
1031   IN     VOID                             *Source,
1032   IN     UINT32                           SourceSize,
1033   IN OUT VOID                             *Destination,
1034   IN     UINT32                           DestinationSize,
1035   IN OUT VOID                             *Scratch,
1036   IN     UINT32                           ScratchSize
1037   )
1038 {
1039   EFI_STATUS  Status;
1040   UINT32      TestDestinationSize;
1041   UINT32      TestScratchSize;
1042
1043   Status = TianoDecompressGetInfo (Source, SourceSize, &TestDestinationSize, &TestScratchSize);
1044   if (EFI_ERROR (Status)) {
1045     return Status;
1046   }
1047
1048   if (ScratchSize < TestScratchSize || DestinationSize < TestDestinationSize) {
1049     return RETURN_INVALID_PARAMETER;
1050   }
1051
1052   return TianoDecompress (Source, Destination, Scratch);
1053 }
1054
1055 EFI_STATUS
1056 DxeMainCustomDecompressGetInfo (
1057   IN EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL  *This,
1058   IN   VOID                              *Source,
1059   IN   UINT32                            SourceSize,
1060   OUT  UINT32                            *DestinationSize,
1061   OUT  UINT32                            *ScratchSize
1062   )
1063 {
1064   return CustomDecompressGetInfo (Source, SourceSize, DestinationSize, ScratchSize);
1065 }
1066
1067 EFI_STATUS
1068 EFIAPI
1069 DxeMainCustomDecompress (
1070   IN EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL  *This,
1071   IN     VOID                            *Source,
1072   IN     UINT32                          SourceSize,
1073   IN OUT VOID                            *Destination,
1074   IN     UINT32                          DestinationSize,
1075   IN OUT VOID                            *Scratch,
1076   IN     UINT32                          ScratchSize
1077   )
1078 {
1079   EFI_STATUS  Status;
1080   UINT32      TestDestinationSize;
1081   UINT32      TestScratchSize;
1082
1083   Status = CustomDecompressGetInfo (Source, SourceSize, &TestDestinationSize, &TestScratchSize);
1084   if (EFI_ERROR (Status)) {
1085     return Status;
1086   }
1087
1088   if (ScratchSize < TestScratchSize || DestinationSize < TestDestinationSize) {
1089     return RETURN_INVALID_PARAMETER;
1090   }
1091
1092   return CustomDecompress (Source, Destination, Scratch);
1093 }
1094