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   mHobStart = HobStart;
 398
 399   //
 400   // Initialize Memory Services
 401   //
 402   CoreInitializeMemoryServices (&HobStart, &MemoryBaseAddress, &MemoryLength);
 403
 404   //
 405   // Allocate the EFI System Table and EFI Runtime Service Table from EfiRuntimeServicesData
 406   // Use the templates to initialize the contents of the EFI System Table and EFI Runtime Services Table
 407   //
 408   gST = CoreAllocateRuntimeCopyPool (sizeof (EFI_SYSTEM_TABLE), &mEfiSystemTableTemplate);
 409   ASSERT (gST != NULL);
 410
 411   gRT = CoreAllocateRuntimeCopyPool (sizeof (EFI_RUNTIME_SERVICES), &mEfiRuntimeServicesTableTemplate);
 412   ASSERT (gRT != NULL);
 413
 414   gST->RuntimeServices = gRT;
 415
 416   //
 417   // Start the Image Services.
 418   //
 419   Status = CoreInitializeImageServices (HobStart);
 420   ASSERT_EFI_ERROR (Status);
 421
 422   //
 423   // Call constructor for all libraries
 424   //
 425   ProcessLibraryConstructorList (gDxeCoreImageHandle, gST);
 426
 427   //
 428   // Initialize the Global Coherency Domain Services
 429   //
 430   Status = CoreInitializeGcdServices (&HobStart, MemoryBaseAddress, MemoryLength);
 431   ASSERT_EFI_ERROR (Status);
 432
 433   //
 434   // Install the DXE Services Table into the EFI System Tables's Configuration Table
 435   //
 436   Status = CoreInstallConfigurationTable (&gEfiDxeServicesTableGuid, gDS);
 437   ASSERT_EFI_ERROR (Status);
 438
 439   //
 440   // Install the HOB List into the EFI System Tables's Configuration Table
 441   //
 442   Status = CoreInstallConfigurationTable (&gEfiHobListGuid, HobStart);
 443   ASSERT_EFI_ERROR (Status);
 444
 445   //
 446   // Install Memory Type Information Table into the EFI System Tables's Configuration Table
 447   //
 448   Status = CoreInstallConfigurationTable (&gEfiMemoryTypeInformationGuid, &gMemoryTypeInformation);
 449   ASSERT_EFI_ERROR (Status);
 450
 451   //
 452   // Initialize the ReportStatusCode with PEI version, if availible
 453   //
 454   CoreGetPeiProtocol (&gEfiStatusCodeRuntimeProtocolGuid, (VOID **)&gStatusCode->ReportStatusCode);
 455 #if ((EDK_RELEASE_VERSION != 0) && (EFI_SPECIFICATION_VERSION < 0x00020000))
 456   //
 457   // This Tiano extension was removed when UEFI 2.0 support was added.
 458   // It's now just a protocol.
 459   //
 460   gRT->ReportStatusCode = gStatusCode->ReportStatusCode;
 461 #endif
 462
 463   //
 464   // Report Status Code here for DXE_ENTRY_POINT once it is available
 465   //
 466   CoreReportProgressCode ((EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_PC_ENTRY_POINT));
 467
 468   //
 469   // Create the aligned system table pointer structure that is used by external
 470   // debuggers to locate the system table...  Also, install debug image info
 471   // configuration table.
 472   //
 473   CoreInitializeDebugImageInfoTable ();
 474   CoreNewDebugImageInfoEntry (
 475     EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL,
 476     gDxeCoreLoadedImage,
 477     gDxeCoreImageHandle
 478     );
 479
 480   DEBUG ((EFI_D_INFO | EFI_D_LOAD, "HOBLIST address in DXE = 0x%08x\n", HobStart));
 481
 482   //
 483   // Initialize the Event Services
 484   //
 485   Status = CoreInitializeEventServices ();
 486   ASSERT_EFI_ERROR (Status);
 487
 488
 489   //
 490   // Get the Protocols that were passed in from PEI to DXE through GUIDed HOBs
 491   //
 492   // These Protocols are not architectural. This implementation is sharing code between
 493   // PEI and DXE in order to save FLASH space. These Protocols could also be implemented
 494   // as part of the DXE Core. However, that would also require the DXE Core to be ported
 495   // each time a different CPU is used, a different Decompression algorithm is used, or a
 496   // different Image type is used. By placing these Protocols in PEI, the DXE Core remains
 497   // generic, and only PEI and the Arch Protocols need to be ported from Platform to Platform,
 498   // and from CPU to CPU.
 499   //
 500
 501   //
 502   // Publish the EFI, Tiano, and Custom Decompress protocols for use by other DXE components
 503   //
 504   Status = CoreInstallMultipleProtocolInterfaces (
 505               &mDecompressHandle,
 506               &gEfiDecompressProtocolGuid,           &gEfiDecompress,
 507               &gEfiTianoDecompressProtocolGuid,      &gEfiTianoDecompress,
 508               &gEfiCustomizedDecompressProtocolGuid, &gEfiCustomizedDecompress,
 509               NULL
 510               );
 511   ASSERT_EFI_ERROR (Status);
 512
 513   gEfiPeiPeCoffLoader = GetPeCoffLoaderProtocol ();
 514   ASSERT (gEfiPeiPeCoffLoader != NULL);
 515
 516   //
 517   // Register for the GUIDs of the Architectural Protocols, so the rest of the
 518   // EFI Boot Services and EFI Runtime Services tables can be filled in.
 519   //
 520   CoreNotifyOnArchProtocolInstallation ();
 521
 522   //
 523   // Produce Firmware Volume Protocols, one for each FV in the HOB list.
 524   //
 525   Status = FwVolBlockDriverInit (gDxeCoreImageHandle, gST);
 526   ASSERT_EFI_ERROR (Status);
 527
 528   Status = FwVolDriverInit (gDxeCoreImageHandle, gST);
 529   ASSERT_EFI_ERROR (Status);
 530
 531   //
 532   // Produce the Section Extraction Protocol
 533   //
 534   Status = InitializeSectionExtraction (gDxeCoreImageHandle, gST);
 535   ASSERT_EFI_ERROR (Status);
 536
 537   //
 538   // Initialize the DXE Dispatcher
 539   //
 540   PERF_START (0,"CoreInitializeDispatcher", "DxeMain", 0) ;
 541   CoreInitializeDispatcher ();
 542   PERF_END (0,"CoreInitializeDispatcher", "DxeMain", 0) ;
 543
 544   //
 545   // Invoke the DXE Dispatcher
 546   //
 547   PERF_START (0, "CoreDispatcher", "DxeMain", 0);
 548   CoreDispatcher ();
 549   PERF_END (0, "CoreDispatcher", "DxeMain", 0);
 550
 551   //
 552   // Display Architectural protocols that were not loaded if this is DEBUG build
 553   //
 554   DEBUG_CODE_BEGIN ();
 555     CoreDisplayMissingArchProtocols ();
 556   DEBUG_CODE_END ();
 557
 558   //
 559   // Assert if the Architectural Protocols are not present.
 560   //
 561   ASSERT_EFI_ERROR (CoreAllEfiServicesAvailable ());
 562
 563   //
 564   // Report Status code before transfer control to BDS
 565   //
 566   CoreReportProgressCode ((EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_PC_HANDOFF_TO_NEXT));
 567   //
 568   // Display any drivers that were not dispatched because dependency expression
 569   // evaluated to false if this is a debug build
 570   //
 571   DEBUG_CODE_BEGIN ();
 572     CoreDisplayDiscoveredNotDispatched ();
 573   DEBUG_CODE_END ();
 574
 575   //
 576   // Transfer control to the BDS Architectural Protocol
 577   //
 578   gBds->Entry (gBds);
 579
 580   //
 581   // BDS should never return
 582   //
 583   ASSERT (FALSE);
 584   CpuDeadLoop ();
 585 }
 586
 587
 588 EFI_STATUS
 589 EFIAPI
 590 CoreEfiNotAvailableYetArg0 (
 591   VOID
 592   )
 593 /*++
 594
 595 Routine Description:
 596
 597   Place holder function until all the Boot Services and Runtime Services are available
 598
 599 Arguments:
 600
 601   None
 602
 603 Returns:
 604
 605   EFI_NOT_AVAILABLE_YET
 606
 607 --*/
 608 {
 609   //
 610   // This function should never be executed.  If it does, then the architectural protocols
 611   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 612   // DXE Core and all the Architectural Protocols are complete.
 613   //
 614
 615   return EFI_NOT_AVAILABLE_YET;
 616 }
 617
 618 EFI_STATUS
 619 EFIAPI
 620 CoreEfiNotAvailableYetArg1 (
 621   UINTN Arg1
 622   )
 623 /*++
 624
 625 Routine Description:
 626
 627   Place holder function until all the Boot Services and Runtime Services are available
 628
 629 Arguments:
 630
 631   Arg1        - Undefined
 632
 633 Returns:
 634
 635   EFI_NOT_AVAILABLE_YET
 636
 637 --*/
 638 {
 639   //
 640   // This function should never be executed.  If it does, then the architectural protocols
 641   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 642   // DXE Core and all the Architectural Protocols are complete.
 643   //
 644
 645   return EFI_NOT_AVAILABLE_YET;
 646 }
 647
 648 EFI_STATUS
 649 EFIAPI
 650 CoreEfiNotAvailableYetArg2 (
 651   UINTN Arg1,
 652   UINTN Arg2
 653   )
 654 /*++
 655
 656 Routine Description:
 657
 658   Place holder function until all the Boot Services and Runtime Services are available
 659
 660 Arguments:
 661
 662   Arg1        - Undefined
 663
 664   Arg2        - Undefined
 665
 666 Returns:
 667
 668   EFI_NOT_AVAILABLE_YET
 669
 670 --*/
 671 {
 672   //
 673   // This function should never be executed.  If it does, then the architectural protocols
 674   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 675   // DXE Core and all the Architectural Protocols are complete.
 676   //
 677
 678   return EFI_NOT_AVAILABLE_YET;
 679 }
 680
 681 EFI_STATUS
 682 EFIAPI
 683 CoreEfiNotAvailableYetArg3 (
 684   UINTN Arg1,
 685   UINTN Arg2,
 686   UINTN Arg3
 687   )
 688 /*++
 689
 690 Routine Description:
 691
 692   Place holder function until all the Boot Services and Runtime Services are available
 693
 694 Arguments:
 695
 696   Arg1        - Undefined
 697
 698   Arg2        - Undefined
 699
 700   Arg3        - Undefined
 701
 702 Returns:
 703
 704   EFI_NOT_AVAILABLE_YET
 705
 706 --*/
 707 {
 708   //
 709   // This function should never be executed.  If it does, then the architectural protocols
 710   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 711   // DXE Core and all the Architectural Protocols are complete.
 712   //
 713
 714   return EFI_NOT_AVAILABLE_YET;
 715 }
 716
 717 EFI_STATUS
 718 EFIAPI
 719 CoreEfiNotAvailableYetArg4 (
 720   UINTN Arg1,
 721   UINTN Arg2,
 722   UINTN Arg3,
 723   UINTN Arg4
 724   )
 725 /*++
 726
 727 Routine Description:
 728
 729   Place holder function until all the Boot Services and Runtime Services are available
 730
 731 Arguments:
 732
 733   Arg1        - Undefined
 734
 735   Arg2        - Undefined
 736
 737   Arg3        - Undefined
 738
 739   Arg4        - Undefined
 740
 741 Returns:
 742
 743   EFI_NOT_AVAILABLE_YET
 744
 745 --*/
 746 {
 747   //
 748   // This function should never be executed.  If it does, then the architectural protocols
 749   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 750   // DXE Core and all the Architectural Protocols are complete.
 751   //
 752
 753   return EFI_NOT_AVAILABLE_YET;
 754 }
 755
 756 EFI_STATUS
 757 EFIAPI
 758 CoreEfiNotAvailableYetArg5 (
 759   UINTN Arg1,
 760   UINTN Arg2,
 761   UINTN Arg3,
 762   UINTN Arg4,
 763   UINTN Arg5
 764   )
 765 /*++
 766
 767 Routine Description:
 768
 769   Place holder function until all the Boot Services and Runtime Services are available
 770
 771 Arguments:
 772
 773   Arg1        - Undefined
 774
 775   Arg2        - Undefined
 776
 777   Arg3        - Undefined
 778
 779   Arg4        - Undefined
 780
 781   Arg5        - Undefined
 782
 783 Returns:
 784
 785   EFI_NOT_AVAILABLE_YET
 786
 787 --*/
 788 {
 789   //
 790   // This function should never be executed.  If it does, then the architectural protocols
 791   // have not been designed correctly.  The CpuBreakpoint () is commented out for now until the
 792   // DXE Core and all the Architectural Protocols are complete.
 793   //
 794
 795   return EFI_NOT_AVAILABLE_YET;
 796 }
 797
 798
 799 EFI_STATUS
 800 CoreGetPeiProtocol (
 801   IN EFI_GUID  *ProtocolGuid,
 802   IN VOID      **Interface
 803   )
 804 /*++
 805
 806 Routine Description:
 807
 808   Searches for a Protocol Interface passed from PEI through a HOB
 809
 810 Arguments:
 811
 812   ProtocolGuid - The Protocol GUID to search for in the HOB List
 813
 814   Interface    - A pointer to the interface for the Protocol GUID
 815
 816 Returns:
 817
 818   EFI_SUCCESS   - The Protocol GUID was found and its interface is returned in Interface
 819
 820   EFI_NOT_FOUND - The Protocol GUID was not found in the HOB List
 821
 822 --*/
 823 {
 824   EFI_HOB_GUID_TYPE   *GuidHob;
 825   VOID                *Buffer;
 826
 827   GuidHob = GetNextGuidHob (ProtocolGuid, mHobStart);
 828   if (GuidHob == NULL) {
 829     return EFI_NOT_FOUND;
 830   }
 831
 832   Buffer = GET_GUID_HOB_DATA (GuidHob);
 833   ASSERT (Buffer != NULL);
 834
 835   *Interface = (VOID *)(*(UINTN *)(Buffer));
 836
 837   return EFI_SUCCESS;
 838 }
 839
 840
 841 VOID
 842 CalculateEfiHdrCrc (
 843   IN  OUT EFI_TABLE_HEADER    *Hdr
 844   )
 845 /*++
 846
 847 Routine Description:
 848
 849   Calcualte the 32-bit CRC in a EFI table using the service provided by the
 850   gRuntime service.
 851
 852 Arguments:
 853
 854   Hdr  - Pointer to an EFI standard header
 855
 856 Returns:
 857
 858   None
 859
 860 --*/
 861 {
 862   UINT32 Crc;
 863
 864   Hdr->CRC32 = 0;
 865
 866   //
 867   // If gBS->CalculateCrce32 () == CoreEfiNotAvailableYet () then
 868   //  Crc will come back as zero if we set it to zero here
 869   //
 870   Crc = 0;
 871   gBS->CalculateCrc32 ((UINT8 *)Hdr, Hdr->HeaderSize, &Crc);
 872   Hdr->CRC32 = Crc;
 873 }
 874
 875
 876
 877 EFI_STATUS
 878 EFIAPI
 879 CoreExitBootServices (
 880   IN EFI_HANDLE   ImageHandle,
 881   IN UINTN        MapKey
 882   )
 883 /*++
 884
 885 Routine Description:
 886
 887   EFI 1.0 API to terminate Boot Services
 888
 889 Arguments:
 890
 891   ImageHandle  - Handle that represents the identity of the calling image
 892
 893   MapKey -Key to the latest memory map.
 894
 895 Returns:
 896
 897   EFI_SUCCESS - Boot Services terminated
 898   EFI_INVALID_PARAMETER - MapKey is incorrect.
 899
 900 --*/
 901 {
 902   EFI_STATUS    Status;
 903
 904   //
 905   // Terminate memory services if the MapKey matches
 906   //
 907   Status = CoreTerminateMemoryMap (MapKey);
 908   if (EFI_ERROR (Status)) {
 909     return Status;
 910   }
 911
 912   //
 913   // Notify other drivers that we are exiting boot services.
 914   //
 915   CoreNotifySignalList (&gEfiEventExitBootServicesGuid);
 916
 917   //
 918   // Disable Timer
 919   //
 920   gTimer->SetTimerPeriod (gTimer, 0);
 921
 922   //
 923   // Disable CPU Interrupts
 924   //
 925   gCpu->DisableInterrupt (gCpu);
 926
 927   //
 928   // Register Runtime events with the Runtime Architectural Protocol
 929   //
 930   CoreShutdownEventServices ();
 931
 932   //
 933   // Register Runtime images with the Runtime Architectural Protocol
 934   //
 935   CoreShutdownImageServices ();
 936
 937   //
 938   // Report that ExitBootServices() has been called
 939   //
 940   // We are using gEfiDxeServicesTableGuid as the caller ID for Dxe Core
 941   //
 942   CoreReportProgressCode ((EFI_SOFTWARE_EFI_BOOT_SERVICE | EFI_SW_BS_PC_EXIT_BOOT_SERVICES));
 943
 944   //
 945   // Clear the non-runtime values of the EFI System Table
 946   //
 947   gST->BootServices        = NULL;
 948   gST->ConIn               = NULL;
 949   gST->ConsoleInHandle     = NULL;
 950   gST->ConOut              = NULL;
 951   gST->ConsoleOutHandle    = NULL;
 952   gST->StdErr              = NULL;
 953   gST->StandardErrorHandle = NULL;
 954
 955   //
 956   // Recompute the 32-bit CRC of the EFI System Table
 957   //
 958   CalculateEfiHdrCrc (&gST->Hdr);
 959
 960   //
 961   // Zero out the Boot Service Table
 962   //
 963   SetMem (gBS, sizeof (EFI_BOOT_SERVICES), 0);
 964   gBS = NULL;
 965
 966   return Status;
 967 }
 968
 969 EFI_STATUS
 970 DxeMainUefiDecompressGetInfo (
 971   IN EFI_DECOMPRESS_PROTOCOL            *This,
 972   IN   VOID                             *Source,
 973   IN   UINT32                           SourceSize,
 974   OUT  UINT32                           *DestinationSize,
 975   OUT  UINT32                           *ScratchSize
 976   )
 977 {
 978   return UefiDecompressGetInfo (Source, SourceSize, DestinationSize, ScratchSize);
 979 }
 980
 981 EFI_STATUS
 982 EFIAPI
 983 DxeMainUefiDecompress (
 984   IN EFI_DECOMPRESS_PROTOCOL              *This,
 985   IN     VOID                             *Source,
 986   IN     UINT32                           SourceSize,
 987   IN OUT VOID                             *Destination,
 988   IN     UINT32                           DestinationSize,
 989   IN OUT VOID                             *Scratch,
 990   IN     UINT32                           ScratchSize
 991   )
 992 {
 993   EFI_STATUS  Status;
 994   UINT32      TestDestinationSize;
 995   UINT32      TestScratchSize;
 996
 997   Status = UefiDecompressGetInfo (Source, SourceSize, &TestDestinationSize, &TestScratchSize);
 998   if (EFI_ERROR (Status)) {
 999     return Status;
1000   }
1001
1002   if (ScratchSize < TestScratchSize || DestinationSize < TestDestinationSize) {
1003     return RETURN_INVALID_PARAMETER;
1004   }
1005
1006   return UefiDecompress (Source, Destination, Scratch);
1007 }
1008
1009 EFI_STATUS
1010 DxeMainTianoDecompressGetInfo (
1011   IN EFI_TIANO_DECOMPRESS_PROTOCOL      *This,
1012   IN   VOID                             *Source,
1013   IN   UINT32                           SourceSize,
1014   OUT  UINT32                           *DestinationSize,
1015   OUT  UINT32                           *ScratchSize
1016   )
1017 {
1018   return TianoDecompressGetInfo (Source, SourceSize, DestinationSize, ScratchSize);
1019 }
1020
1021 EFI_STATUS
1022 EFIAPI
1023 DxeMainTianoDecompress (
1024   IN EFI_TIANO_DECOMPRESS_PROTOCOL        *This,
1025   IN     VOID                             *Source,
1026   IN     UINT32                           SourceSize,
1027   IN OUT VOID                             *Destination,
1028   IN     UINT32                           DestinationSize,
1029   IN OUT VOID                             *Scratch,
1030   IN     UINT32                           ScratchSize
1031   )
1032 {
1033   EFI_STATUS  Status;
1034   UINT32      TestDestinationSize;
1035   UINT32      TestScratchSize;
1036
1037   Status = TianoDecompressGetInfo (Source, SourceSize, &TestDestinationSize, &TestScratchSize);
1038   if (EFI_ERROR (Status)) {
1039     return Status;
1040   }
1041
1042   if (ScratchSize < TestScratchSize || DestinationSize < TestDestinationSize) {
1043     return RETURN_INVALID_PARAMETER;
1044   }
1045
1046   return TianoDecompress (Source, Destination, Scratch);
1047 }
1048
1049 EFI_STATUS
1050 DxeMainCustomDecompressGetInfo (
1051   IN EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL  *This,
1052   IN   VOID                              *Source,
1053   IN   UINT32                            SourceSize,
1054   OUT  UINT32                            *DestinationSize,
1055   OUT  UINT32                            *ScratchSize
1056   )
1057 {
1058   return CustomDecompressGetInfo (Source, SourceSize, DestinationSize, ScratchSize);
1059 }
1060
1061 EFI_STATUS
1062 EFIAPI
1063 DxeMainCustomDecompress (
1064   IN EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL  *This,
1065   IN     VOID                            *Source,
1066   IN     UINT32                          SourceSize,
1067   IN OUT VOID                            *Destination,
1068   IN     UINT32                          DestinationSize,
1069   IN OUT VOID                            *Scratch,
1070   IN     UINT32                          ScratchSize
1071   )
1072 {
1073   EFI_STATUS  Status;
1074   UINT32      TestDestinationSize;
1075   UINT32      TestScratchSize;
1076
1077   Status = CustomDecompressGetInfo (Source, SourceSize, &TestDestinationSize, &TestScratchSize);
1078   if (EFI_ERROR (Status)) {
1079     return Status;
1080   }
1081
1082   if (ScratchSize < TestScratchSize || DestinationSize < TestDestinationSize) {
1083     return RETURN_INVALID_PARAMETER;
1084   }
1085
1086   return CustomDecompress (Source, Destination, Scratch);
1087 }
1088