UefiPayloadPkg/UefiPayloadEntry/UefiPayloadEntry.c

   1 /** @file
   2
   3   Copyright (c) 2014 - 2021, Intel Corporation. All rights reserved.<BR>
   4   SPDX-License-Identifier: BSD-2-Clause-Patent
   5
   6 **/
   7
   8 #include "UefiPayloadEntry.h"
   9
  10 STATIC UINT32 mTopOfLowerUsableDram = 0;
  11
  12 /**
  13    Callback function to build resource descriptor HOB
  14
  15    This function build a HOB based on the memory map entry info.
  16    It creates only EFI_RESOURCE_MEMORY_MAPPED_IO and EFI_RESOURCE_MEMORY_RESERVED
  17    resources.
  18
  19    @param MemoryMapEntry         Memory map entry info got from bootloader.
  20    @param Params                 A pointer to ACPI_BOARD_INFO.
  21
  22   @retval EFI_SUCCESS            Successfully build a HOB.
  23   @retval EFI_INVALID_PARAMETER  Invalid parameter provided.
  24 **/
  25 EFI_STATUS
  26 MemInfoCallbackMmio (
  27   IN MEMROY_MAP_ENTRY          *MemoryMapEntry,
  28   IN VOID                      *Params
  29   )
  30 {
  31   EFI_PHYSICAL_ADDRESS         Base;
  32   EFI_RESOURCE_TYPE            Type;
  33   UINT64                       Size;
  34   EFI_RESOURCE_ATTRIBUTE_TYPE  Attribue;
  35   ACPI_BOARD_INFO              *AcpiBoardInfo;
  36
  37   AcpiBoardInfo = (ACPI_BOARD_INFO *)Params;
  38   if (AcpiBoardInfo == NULL) {
  39     return EFI_INVALID_PARAMETER;
  40   }
  41
  42   //
  43   // Skip types already handled in MemInfoCallback
  44   //
  45   if (MemoryMapEntry->Type == E820_RAM || MemoryMapEntry->Type == E820_ACPI) {
  46     return EFI_SUCCESS;
  47   }
  48
  49   if (MemoryMapEntry->Base == AcpiBoardInfo->PcieBaseAddress) {
  50     //
  51     // MMCONF is always MMIO
  52     //
  53     Type = EFI_RESOURCE_MEMORY_MAPPED_IO;
  54   } else if (MemoryMapEntry->Base < mTopOfLowerUsableDram) {
  55     //
  56     // It's in DRAM and thus must be reserved
  57     //
  58     Type = EFI_RESOURCE_MEMORY_RESERVED;
  59   } else if ((MemoryMapEntry->Base < 0x100000000ULL) && (MemoryMapEntry->Base >= mTopOfLowerUsableDram)) {
  60     //
  61     // It's not in DRAM, must be MMIO
  62     //
  63     Type = EFI_RESOURCE_MEMORY_MAPPED_IO;
  64   } else {
  65     Type = EFI_RESOURCE_MEMORY_RESERVED;
  66   }
  67
  68   Base    = MemoryMapEntry->Base;
  69   Size    = MemoryMapEntry->Size;
  70
  71   Attribue = EFI_RESOURCE_ATTRIBUTE_PRESENT |
  72              EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
  73              EFI_RESOURCE_ATTRIBUTE_TESTED |
  74              EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
  75              EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
  76              EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
  77              EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE;
  78
  79   BuildResourceDescriptorHob (Type, Attribue, (EFI_PHYSICAL_ADDRESS)Base, Size);
  80   DEBUG ((DEBUG_INFO , "buildhob: base = 0x%lx, size = 0x%lx, type = 0x%x\n", Base, Size, Type));
  81
  82   if (MemoryMapEntry->Type == E820_UNUSABLE ||
  83     MemoryMapEntry->Type == E820_DISABLED) {
  84     BuildMemoryAllocationHob (Base, Size, EfiUnusableMemory);
  85   } else if (MemoryMapEntry->Type == E820_PMEM) {
  86     BuildMemoryAllocationHob (Base, Size, EfiPersistentMemory);
  87   }
  88
  89   return EFI_SUCCESS;
  90 }
  91
  92
  93 /**
  94    Callback function to find TOLUD (Top of Lower Usable DRAM)
  95
  96    Estimate where TOLUD (Top of Lower Usable DRAM) resides. The exact position
  97    would require platform specific code.
  98
  99    @param MemoryMapEntry         Memory map entry info got from bootloader.
 100    @param Params                 Not used for now.
 101
 102   @retval EFI_SUCCESS            Successfully updated mTopOfLowerUsableDram.
 103 **/
 104 EFI_STATUS
 105 FindToludCallback (
 106   IN MEMROY_MAP_ENTRY          *MemoryMapEntry,
 107   IN VOID                      *Params
 108   )
 109 {
 110   //
 111   // This code assumes that the memory map on this x86 machine below 4GiB is continous
 112   // until TOLUD. In addition it assumes that the bootloader provided memory tables have
 113   // no "holes" and thus the first memory range not covered by e820 marks the end of
 114   // usable DRAM. In addition it's assumed that every reserved memory region touching
 115   // usable RAM is also covering DRAM, everything else that is marked reserved thus must be
 116   // MMIO not detectable by bootloader/OS
 117   //
 118
 119   //
 120   // Skip memory types not RAM or reserved
 121   //
 122   if ((MemoryMapEntry->Type == E820_UNUSABLE) || (MemoryMapEntry->Type == E820_DISABLED) ||
 123     (MemoryMapEntry->Type == E820_PMEM)) {
 124     return EFI_SUCCESS;
 125   }
 126
 127   //
 128   // Skip resources above 4GiB
 129   //
 130   if ((MemoryMapEntry->Base + MemoryMapEntry->Size) > 0x100000000ULL) {
 131     return EFI_SUCCESS;
 132   }
 133
 134   if ((MemoryMapEntry->Type == E820_RAM) || (MemoryMapEntry->Type == E820_ACPI) ||
 135     (MemoryMapEntry->Type == E820_NVS)) {
 136     //
 137     // It's usable DRAM. Update TOLUD.
 138     //
 139     if (mTopOfLowerUsableDram < (MemoryMapEntry->Base + MemoryMapEntry->Size)) {
 140       mTopOfLowerUsableDram = (UINT32)(MemoryMapEntry->Base + MemoryMapEntry->Size);
 141     }
 142   } else {
 143     //
 144     // It might be 'reserved DRAM' or 'MMIO'.
 145     //
 146     // If it touches usable DRAM at Base assume it's DRAM as well,
 147     // as it could be bootloader installed tables, TSEG, GTT, ...
 148     //
 149     if (mTopOfLowerUsableDram == MemoryMapEntry->Base) {
 150       mTopOfLowerUsableDram = (UINT32)(MemoryMapEntry->Base + MemoryMapEntry->Size);
 151     }
 152   }
 153
 154   return EFI_SUCCESS;
 155 }
 156
 157
 158 /**
 159    Callback function to build resource descriptor HOB
 160
 161    This function build a HOB based on the memory map entry info.
 162    Only add EFI_RESOURCE_SYSTEM_MEMORY.
 163
 164    @param MemoryMapEntry         Memory map entry info got from bootloader.
 165    @param Params                 Not used for now.
 166
 167   @retval RETURN_SUCCESS        Successfully build a HOB.
 168 **/
 169 EFI_STATUS
 170 MemInfoCallback (
 171   IN MEMROY_MAP_ENTRY          *MemoryMapEntry,
 172   IN VOID                      *Params
 173   )
 174 {
 175   EFI_PHYSICAL_ADDRESS         Base;
 176   EFI_RESOURCE_TYPE            Type;
 177   UINT64                       Size;
 178   EFI_RESOURCE_ATTRIBUTE_TYPE  Attribue;
 179
 180   //
 181   // Skip everything not known to be usable DRAM.
 182   // It will be added later.
 183   //
 184   if ((MemoryMapEntry->Type != E820_RAM) && (MemoryMapEntry->Type != E820_ACPI) &&
 185     (MemoryMapEntry->Type != E820_NVS)) {
 186     return RETURN_SUCCESS;
 187   }
 188
 189   Type    = EFI_RESOURCE_SYSTEM_MEMORY;
 190   Base    = MemoryMapEntry->Base;
 191   Size    = MemoryMapEntry->Size;
 192
 193   Attribue = EFI_RESOURCE_ATTRIBUTE_PRESENT |
 194              EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 195              EFI_RESOURCE_ATTRIBUTE_TESTED |
 196              EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 197              EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
 198              EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
 199              EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE;
 200
 201   BuildResourceDescriptorHob (Type, Attribue, (EFI_PHYSICAL_ADDRESS)Base, Size);
 202   DEBUG ((DEBUG_INFO , "buildhob: base = 0x%lx, size = 0x%lx, type = 0x%x\n", Base, Size, Type));
 203
 204   if (MemoryMapEntry->Type == E820_ACPI) {
 205     BuildMemoryAllocationHob (Base, Size, EfiACPIReclaimMemory);
 206   } else if (MemoryMapEntry->Type == E820_NVS) {
 207     BuildMemoryAllocationHob (Base, Size, EfiACPIMemoryNVS);
 208   }
 209
 210   return RETURN_SUCCESS;
 211 }
 212
 213
 214
 215 /**
 216   It will build HOBs based on information from bootloaders.
 217
 218   @retval EFI_SUCCESS        If it completed successfully.
 219   @retval Others             If it failed to build required HOBs.
 220 **/
 221 EFI_STATUS
 222 BuildHobFromBl (
 223   VOID
 224   )
 225 {
 226   EFI_STATUS                       Status;
 227   SYSTEM_TABLE_INFO                SysTableInfo;
 228   SYSTEM_TABLE_INFO                *NewSysTableInfo;
 229   ACPI_BOARD_INFO                  *AcpiBoardInfo;
 230   EFI_PEI_GRAPHICS_INFO_HOB        GfxInfo;
 231   EFI_PEI_GRAPHICS_INFO_HOB        *NewGfxInfo;
 232   EFI_PEI_GRAPHICS_DEVICE_INFO_HOB GfxDeviceInfo;
 233   EFI_PEI_GRAPHICS_DEVICE_INFO_HOB *NewGfxDeviceInfo;
 234   UNIVERSAL_PAYLOAD_SMBIOS_TABLE   *SmBiosTableHob;
 235   UNIVERSAL_PAYLOAD_ACPI_TABLE     *AcpiTableHob;
 236
 237   //
 238   // First find TOLUD
 239   //
 240   DEBUG ((DEBUG_INFO , "Guessing Top of Lower Usable DRAM:\n"));
 241   Status = ParseMemoryInfo (FindToludCallback, NULL);
 242   if (EFI_ERROR(Status)) {
 243     return Status;
 244   }
 245   DEBUG ((DEBUG_INFO , "Assuming TOLUD = 0x%x\n", mTopOfLowerUsableDram));
 246
 247   //
 248   // Parse memory info and build memory HOBs for Usable RAM
 249   //
 250   DEBUG ((DEBUG_INFO , "Building ResourceDescriptorHobs for usable memory:\n"));
 251   Status = ParseMemoryInfo (MemInfoCallback, NULL);
 252   if (EFI_ERROR(Status)) {
 253     return Status;
 254   }
 255
 256   //
 257   // Create guid hob for frame buffer information
 258   //
 259   Status = ParseGfxInfo (&GfxInfo);
 260   if (!EFI_ERROR (Status)) {
 261     NewGfxInfo = BuildGuidHob (&gEfiGraphicsInfoHobGuid, sizeof (GfxInfo));
 262     ASSERT (NewGfxInfo != NULL);
 263     CopyMem (NewGfxInfo, &GfxInfo, sizeof (GfxInfo));
 264     DEBUG ((DEBUG_INFO, "Created graphics info hob\n"));
 265   }
 266
 267
 268   Status = ParseGfxDeviceInfo (&GfxDeviceInfo);
 269   if (!EFI_ERROR (Status)) {
 270     NewGfxDeviceInfo = BuildGuidHob (&gEfiGraphicsDeviceInfoHobGuid, sizeof (GfxDeviceInfo));
 271     ASSERT (NewGfxDeviceInfo != NULL);
 272     CopyMem (NewGfxDeviceInfo, &GfxDeviceInfo, sizeof (GfxDeviceInfo));
 273     DEBUG ((DEBUG_INFO, "Created graphics device info hob\n"));
 274   }
 275
 276
 277   //
 278   // Create guid hob for system tables like acpi table and smbios table
 279   //
 280   Status = ParseSystemTable(&SysTableInfo);
 281   ASSERT_EFI_ERROR (Status);
 282   if (!EFI_ERROR (Status)) {
 283     NewSysTableInfo = BuildGuidHob (&gUefiSystemTableInfoGuid, sizeof (SYSTEM_TABLE_INFO));
 284     ASSERT (NewSysTableInfo != NULL);
 285     CopyMem (NewSysTableInfo, &SysTableInfo, sizeof (SYSTEM_TABLE_INFO));
 286     DEBUG ((DEBUG_INFO, "Detected Acpi Table at 0x%lx, length 0x%x\n", SysTableInfo.AcpiTableBase, SysTableInfo.AcpiTableSize));
 287     DEBUG ((DEBUG_INFO, "Detected Smbios Table at 0x%lx, length 0x%x\n", SysTableInfo.SmbiosTableBase, SysTableInfo.SmbiosTableSize));
 288   }
 289   //
 290   // Creat SmBios table Hob
 291   //
 292   SmBiosTableHob = BuildGuidHob (&gUniversalPayloadSmbiosTableGuid, sizeof (UNIVERSAL_PAYLOAD_SMBIOS_TABLE));
 293   ASSERT (SmBiosTableHob != NULL);
 294   SmBiosTableHob->Header.Revision = UNIVERSAL_PAYLOAD_SMBIOS_TABLE_REVISION;
 295   SmBiosTableHob->Header.Length = sizeof (UNIVERSAL_PAYLOAD_SMBIOS_TABLE);
 296   SmBiosTableHob->SmBiosEntryPoint = SysTableInfo.SmbiosTableBase;
 297   DEBUG ((DEBUG_INFO, "Create smbios table gUniversalPayloadSmbiosTableGuid guid hob\n"));
 298
 299   //
 300   // Creat ACPI table Hob
 301   //
 302   AcpiTableHob = BuildGuidHob (&gUniversalPayloadAcpiTableGuid, sizeof (UNIVERSAL_PAYLOAD_ACPI_TABLE));
 303   ASSERT (AcpiTableHob != NULL);
 304   AcpiTableHob->Header.Revision = UNIVERSAL_PAYLOAD_ACPI_TABLE_REVISION;
 305   AcpiTableHob->Header.Length = sizeof (UNIVERSAL_PAYLOAD_ACPI_TABLE);
 306   AcpiTableHob->Rsdp = SysTableInfo.AcpiTableBase;
 307   DEBUG ((DEBUG_INFO, "Create smbios table gUniversalPayloadAcpiTableGuid guid hob\n"));
 308
 309   //
 310   // Create guid hob for acpi board information
 311   //
 312   AcpiBoardInfo = BuildHobFromAcpi (SysTableInfo.AcpiTableBase);
 313   ASSERT (AcpiBoardInfo != NULL);
 314
 315   //
 316   // Parse memory info and build memory HOBs for reserved DRAM and MMIO
 317   //
 318   DEBUG ((DEBUG_INFO , "Building ResourceDescriptorHobs for reserved memory:\n"));
 319   Status = ParseMemoryInfo (MemInfoCallbackMmio, AcpiBoardInfo);
 320   if (EFI_ERROR(Status)) {
 321     return Status;
 322   }
 323
 324   //
 325   // Parse platform specific information.
 326   //
 327   Status = ParsePlatformInfo ();
 328   if (EFI_ERROR (Status)) {
 329     DEBUG ((DEBUG_ERROR, "Error when parsing platform info, Status = %r\n", Status));
 330     return Status;
 331   }
 332
 333   return EFI_SUCCESS;
 334 }
 335
 336
 337 /**
 338   This function will build some generic HOBs that doesn't depend on information from bootloaders.
 339
 340 **/
 341 VOID
 342 BuildGenericHob (
 343   VOID
 344   )
 345 {
 346   UINT32                           RegEax;
 347   UINT8                            PhysicalAddressBits;
 348   EFI_RESOURCE_ATTRIBUTE_TYPE      ResourceAttribute;
 349
 350   // The UEFI payload FV
 351   BuildMemoryAllocationHob (PcdGet32 (PcdPayloadFdMemBase), PcdGet32 (PcdPayloadFdMemSize), EfiBootServicesData);
 352
 353   //
 354   // Build CPU memory space and IO space hob
 355   //
 356   AsmCpuid (0x80000000, &RegEax, NULL, NULL, NULL);
 357   if (RegEax >= 0x80000008) {
 358     AsmCpuid (0x80000008, &RegEax, NULL, NULL, NULL);
 359     PhysicalAddressBits = (UINT8) RegEax;
 360   } else {
 361     PhysicalAddressBits  = 36;
 362   }
 363
 364   BuildCpuHob (PhysicalAddressBits, 16);
 365
 366   //
 367   // Report Local APIC range, cause sbl HOB to be NULL, comment now
 368   //
 369   ResourceAttribute = (
 370       EFI_RESOURCE_ATTRIBUTE_PRESENT |
 371       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 372       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 373       EFI_RESOURCE_ATTRIBUTE_TESTED
 374   );
 375   BuildResourceDescriptorHob (EFI_RESOURCE_MEMORY_MAPPED_IO, ResourceAttribute, 0xFEC80000, SIZE_512KB);
 376   BuildMemoryAllocationHob ( 0xFEC80000, SIZE_512KB, EfiMemoryMappedIO);
 377
 378 }
 379
 380
 381 /**
 382   Entry point to the C language phase of UEFI payload.
 383
 384   @retval      It will not return if SUCCESS, and return error when passing bootloader parameter.
 385 **/
 386 EFI_STATUS
 387 EFIAPI
 388 _ModuleEntryPoint (
 389   IN UINTN                     BootloaderParameter
 390   )
 391 {
 392   EFI_STATUS                    Status;
 393   PHYSICAL_ADDRESS              DxeCoreEntryPoint;
 394   UINTN                         MemBase;
 395   UINTN                         HobMemBase;
 396   UINTN                         HobMemTop;
 397   EFI_PEI_HOB_POINTERS          Hob;
 398   SERIAL_PORT_INFO              SerialPortInfo;
 399   UNIVERSAL_PAYLOAD_SERIAL_PORT_INFO  *UniversalSerialPort;
 400
 401   PcdSet64S (PcdBootloaderParameter, BootloaderParameter);
 402   // Initialize floating point operating environment to be compliant with UEFI spec.
 403   InitializeFloatingPointUnits ();
 404
 405   // HOB region is used for HOB and memory allocation for this module
 406   MemBase    = PcdGet32 (PcdPayloadFdMemBase);
 407   HobMemBase = ALIGN_VALUE (MemBase + PcdGet32 (PcdPayloadFdMemSize), SIZE_1MB);
 408   HobMemTop  = HobMemBase + FixedPcdGet32 (PcdSystemMemoryUefiRegionSize);
 409
 410   HobConstructor ((VOID *)MemBase, (VOID *)HobMemTop, (VOID *)HobMemBase, (VOID *)HobMemTop);
 411
 412   //
 413   // Build serial port info
 414   //
 415   Status = ParseSerialInfo (&SerialPortInfo);
 416   if (!EFI_ERROR (Status)) {
 417     UniversalSerialPort = BuildGuidHob (&gUniversalPayloadSerialPortInfoGuid, sizeof (UNIVERSAL_PAYLOAD_SERIAL_PORT_INFO));
 418     ASSERT (UniversalSerialPort != NULL);
 419     UniversalSerialPort->Header.Revision = UNIVERSAL_PAYLOAD_SERIAL_PORT_INFO_REVISION;
 420     UniversalSerialPort->Header.Length   = sizeof (UNIVERSAL_PAYLOAD_SERIAL_PORT_INFO);
 421     UniversalSerialPort->UseMmio         = (SerialPortInfo.Type == 1)?FALSE:TRUE;
 422     UniversalSerialPort->RegisterBase    = SerialPortInfo.BaseAddr;
 423     UniversalSerialPort->BaudRate        = SerialPortInfo.Baud;
 424     UniversalSerialPort->RegisterStride  = (UINT8)SerialPortInfo.RegWidth;
 425   }
 426
 427   // The library constructors might depend on serial port, so call it after serial port hob
 428   ProcessLibraryConstructorList ();
 429   DEBUG ((DEBUG_INFO, "sizeof(UINTN) = 0x%x\n", sizeof(UINTN)));
 430
 431   // Build HOB based on information from Bootloader
 432   Status = BuildHobFromBl ();
 433   if (EFI_ERROR (Status)) {
 434     DEBUG ((DEBUG_ERROR, "BuildHobFromBl Status = %r\n", Status));
 435     return Status;
 436   }
 437
 438   // Build other HOBs required by DXE
 439   BuildGenericHob ();
 440
 441   // Load the DXE Core
 442   Status = LoadDxeCore (&DxeCoreEntryPoint);
 443   ASSERT_EFI_ERROR (Status);
 444
 445   DEBUG ((DEBUG_INFO, "DxeCoreEntryPoint = 0x%lx\n", DxeCoreEntryPoint));
 446
 447   //
 448   // Mask off all legacy 8259 interrupt sources
 449   //
 450   IoWrite8 (LEGACY_8259_MASK_REGISTER_MASTER, 0xFF);
 451   IoWrite8 (LEGACY_8259_MASK_REGISTER_SLAVE,  0xFF);
 452
 453   Hob.HandoffInformationTable = (EFI_HOB_HANDOFF_INFO_TABLE *) GetFirstHob(EFI_HOB_TYPE_HANDOFF);
 454   HandOffToDxeCore (DxeCoreEntryPoint, Hob);
 455
 456   // Should not get here
 457   CpuDeadLoop ();
 458   return EFI_SUCCESS;
 459 }