IntelFsp2WrapperPkg/Library/PeiFspWrapperHobProcessLibSample/FspWrapperHobProcessLibSample.c

   1 /** @file
   2   Sample to provide FSP wrapper hob process related function.
   3
   4   Copyright (c) 2014 - 2018, Intel Corporation. All rights reserved.<BR>
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #include <PiPei.h>
  10
  11 #include <Library/PeiServicesLib.h>
  12 #include <Library/PeiServicesTablePointerLib.h>
  13 #include <Library/BaseLib.h>
  14 #include <Library/DebugLib.h>
  15 #include <Library/BaseMemoryLib.h>
  16 #include <Library/HobLib.h>
  17 #include <Library/PcdLib.h>
  18 #include <Library/FspWrapperPlatformLib.h>
  19
  20 #include <Guid/GuidHobFspEas.h>
  21 #include <Guid/MemoryTypeInformation.h>
  22 #include <Guid/PcdDataBaseHobGuid.h>
  23 #include <Ppi/Capsule.h>
  24
  25 //
  26 // Additional pages are used by DXE memory manager.
  27 // It should be consistent between RetrieveRequiredMemorySize() and GetPeiMemSize()
  28 //
  29 #define PEI_ADDITIONAL_MEMORY_SIZE    (16 * EFI_PAGE_SIZE)
  30
  31 /**
  32   Get the mem size in memory type infromation table.
  33
  34   @param[in] PeiServices  PEI Services table.
  35
  36   @return the mem size in memory type infromation table.
  37 **/
  38 UINT64
  39 GetMemorySizeInMemoryTypeInformation (
  40   IN EFI_PEI_SERVICES **PeiServices
  41   )
  42 {
  43   EFI_STATUS                  Status;
  44   EFI_PEI_HOB_POINTERS        Hob;
  45   EFI_MEMORY_TYPE_INFORMATION *MemoryData;
  46   UINT8                       Index;
  47   UINTN                       TempPageNum;
  48
  49   MemoryData = NULL;
  50   Status     = (*PeiServices)->GetHobList ((CONST EFI_PEI_SERVICES**)PeiServices, (VOID **) &Hob.Raw);
  51   ASSERT_EFI_ERROR (Status);
  52   while (!END_OF_HOB_LIST (Hob)) {
  53     if (Hob.Header->HobType == EFI_HOB_TYPE_GUID_EXTENSION &&
  54       CompareGuid (&Hob.Guid->Name, &gEfiMemoryTypeInformationGuid)) {
  55       MemoryData = (EFI_MEMORY_TYPE_INFORMATION *) (Hob.Raw + sizeof (EFI_HOB_GENERIC_HEADER) + sizeof (EFI_GUID));
  56       break;
  57     }
  58
  59     Hob.Raw = GET_NEXT_HOB (Hob);
  60   }
  61
  62   if (MemoryData == NULL) {
  63     return 0;
  64   }
  65
  66   TempPageNum = 0;
  67   for (Index = 0; MemoryData[Index].Type != EfiMaxMemoryType; Index++) {
  68     //
  69     // Accumulate default memory size requirements
  70     //
  71     TempPageNum += MemoryData[Index].NumberOfPages;
  72   }
  73
  74   return TempPageNum * EFI_PAGE_SIZE;
  75 }
  76
  77 /**
  78   Get the mem size need to be reserved in PEI phase.
  79
  80   @param[in] PeiServices  PEI Services table.
  81
  82   @return the mem size need to be reserved in PEI phase.
  83 **/
  84 UINT64
  85 RetrieveRequiredMemorySize (
  86   IN EFI_PEI_SERVICES **PeiServices
  87   )
  88 {
  89   UINT64                      Size;
  90
  91   Size = GetMemorySizeInMemoryTypeInformation (PeiServices);
  92   return Size + PEI_ADDITIONAL_MEMORY_SIZE;
  93 }
  94
  95 /**
  96   Get the mem size need to be consumed and reserved in PEI phase.
  97
  98   @param[in] PeiServices  PEI Services table.
  99   @param[in] BootMode     Current boot mode.
 100
 101   @return the mem size need to be consumed and reserved in PEI phase.
 102 **/
 103 UINT64
 104 GetPeiMemSize (
 105   IN EFI_PEI_SERVICES **PeiServices,
 106   IN UINT32           BootMode
 107   )
 108 {
 109   UINT64                      Size;
 110   UINT64                      MinSize;
 111
 112   if (BootMode == BOOT_IN_RECOVERY_MODE) {
 113     return PcdGet32 (PcdPeiRecoveryMinMemSize);
 114   }
 115
 116   Size = GetMemorySizeInMemoryTypeInformation (PeiServices);
 117
 118   if (BootMode == BOOT_ON_FLASH_UPDATE) {
 119     //
 120     // Maybe more size when in CapsuleUpdate phase ?
 121     //
 122     MinSize = PcdGet32 (PcdPeiMinMemSize);
 123   } else {
 124     MinSize = PcdGet32 (PcdPeiMinMemSize);
 125   }
 126
 127   return MinSize + Size + PEI_ADDITIONAL_MEMORY_SIZE;
 128 }
 129
 130 /**
 131   Post FSP-M HOB process for Memory Resource Descriptor.
 132
 133   @param[in] FspHobList  Pointer to the HOB data structure produced by FSP.
 134
 135   @return If platform process the FSP hob list successfully.
 136 **/
 137 EFI_STATUS
 138 EFIAPI
 139 PostFspmHobProcess (
 140   IN VOID                 *FspHobList
 141   )
 142 {
 143   EFI_PEI_HOB_POINTERS Hob;
 144   UINT64               LowMemorySize;
 145   UINT64               FspMemorySize;
 146   EFI_PHYSICAL_ADDRESS FspMemoryBase;
 147   UINT64               PeiMemSize;
 148   EFI_PHYSICAL_ADDRESS PeiMemBase;
 149   UINT64               S3PeiMemSize;
 150   EFI_PHYSICAL_ADDRESS S3PeiMemBase;
 151   BOOLEAN              FoundFspMemHob;
 152   EFI_STATUS           Status;
 153   EFI_BOOT_MODE        BootMode;
 154   EFI_PEI_CAPSULE_PPI  *Capsule;
 155   VOID                 *CapsuleBuffer;
 156   UINTN                CapsuleBufferLength;
 157   UINT64               RequiredMemSize;
 158   EFI_PEI_SERVICES     **PeiServices;
 159
 160   PeiServices = (EFI_PEI_SERVICES **)GetPeiServicesTablePointer ();
 161
 162   PeiServicesGetBootMode (&BootMode);
 163
 164   PeiMemBase = 0;
 165   LowMemorySize = 0;
 166   FspMemorySize = 0;
 167   FspMemoryBase = 0;
 168   FoundFspMemHob = FALSE;
 169
 170   //
 171   // Parse the hob list from fsp
 172   // Report all the resource hob except the memory between 1M and 4G
 173   //
 174   Hob.Raw = (UINT8 *)(UINTN)FspHobList;
 175   DEBUG((DEBUG_INFO, "FspHobList - 0x%x\n", FspHobList));
 176
 177   while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, Hob.Raw)) != NULL) {
 178     DEBUG((DEBUG_INFO, "\nResourceType: 0x%x\n", Hob.ResourceDescriptor->ResourceType));
 179     if ((Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) ||
 180         (Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_MEMORY_RESERVED)) {
 181       DEBUG((DEBUG_INFO, "ResourceAttribute: 0x%x\n", Hob.ResourceDescriptor->ResourceAttribute));
 182       DEBUG((DEBUG_INFO, "PhysicalStart: 0x%x\n", Hob.ResourceDescriptor->PhysicalStart));
 183       DEBUG((DEBUG_INFO, "ResourceLength: 0x%x\n", Hob.ResourceDescriptor->ResourceLength));
 184       DEBUG((DEBUG_INFO, "Owner: %g\n\n", &Hob.ResourceDescriptor->Owner));
 185     }
 186
 187     if ((Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY)  // Found the low memory length below 4G
 188         && (Hob.ResourceDescriptor->PhysicalStart >= BASE_1MB)
 189         && (Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength <= BASE_4GB)) {
 190         LowMemorySize += Hob.ResourceDescriptor->ResourceLength;
 191       Hob.Raw = GET_NEXT_HOB (Hob);
 192       continue;
 193     }
 194
 195     if ((Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_MEMORY_RESERVED)  // Found the low memory length below 4G
 196         && (Hob.ResourceDescriptor->PhysicalStart >= BASE_1MB)
 197         && (Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength <= BASE_4GB)
 198         && (CompareGuid (&Hob.ResourceDescriptor->Owner, &gFspReservedMemoryResourceHobGuid))) {
 199       FoundFspMemHob = TRUE;
 200       FspMemoryBase = Hob.ResourceDescriptor->PhysicalStart;
 201       FspMemorySize = Hob.ResourceDescriptor->ResourceLength;
 202       DEBUG((DEBUG_INFO, "Find fsp mem hob, base 0x%x, len 0x%x\n", FspMemoryBase, FspMemorySize));
 203     }
 204
 205     //
 206     // Report the resource hob
 207     //
 208     BuildResourceDescriptorHob (
 209       Hob.ResourceDescriptor->ResourceType,
 210       Hob.ResourceDescriptor->ResourceAttribute,
 211       Hob.ResourceDescriptor->PhysicalStart,
 212       Hob.ResourceDescriptor->ResourceLength
 213       );
 214
 215     Hob.Raw = GET_NEXT_HOB (Hob);
 216   }
 217
 218   if (!FoundFspMemHob) {
 219     DEBUG((DEBUG_INFO, "Didn't find the fsp used memory information.\n"));
 220     //ASSERT(FALSE);
 221   }
 222
 223   DEBUG((DEBUG_INFO, "LowMemorySize: 0x%x.\n", LowMemorySize));
 224   DEBUG((DEBUG_INFO, "FspMemoryBase: 0x%x.\n", FspMemoryBase));
 225   DEBUG((DEBUG_INFO, "FspMemorySize: 0x%x.\n", FspMemorySize));
 226
 227   if (BootMode == BOOT_ON_S3_RESUME) {
 228     BuildResourceDescriptorHob (
 229       EFI_RESOURCE_SYSTEM_MEMORY,
 230       (
 231          EFI_RESOURCE_ATTRIBUTE_PRESENT |
 232          EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 233          // EFI_RESOURCE_ATTRIBUTE_TESTED |
 234          EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 235          EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
 236          EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
 237          EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE
 238       ),
 239       BASE_1MB,
 240       LowMemorySize
 241       );
 242
 243     S3PeiMemBase = 0;
 244     S3PeiMemSize = 0;
 245     Status = GetS3MemoryInfo (&S3PeiMemSize, &S3PeiMemBase);
 246     ASSERT_EFI_ERROR (Status);
 247     DEBUG((DEBUG_INFO, "S3 memory %Xh - %Xh bytes\n", S3PeiMemBase, S3PeiMemSize));
 248
 249     //
 250     // Make sure Stack and PeiMemory are not overlap
 251     //
 252
 253     Status = PeiServicesInstallPeiMemory (
 254                S3PeiMemBase,
 255                S3PeiMemSize
 256                );
 257     ASSERT_EFI_ERROR (Status);
 258   } else {
 259     PeiMemSize = GetPeiMemSize (PeiServices, BootMode);
 260     DEBUG((DEBUG_INFO, "PEI memory size = %Xh bytes\n", PeiMemSize));
 261
 262     //
 263     // Capsule mode
 264     //
 265     Capsule = NULL;
 266     CapsuleBuffer = NULL;
 267     CapsuleBufferLength = 0;
 268     if (BootMode == BOOT_ON_FLASH_UPDATE) {
 269       Status = PeiServicesLocatePpi (
 270                  &gEfiPeiCapsulePpiGuid,
 271                  0,
 272                  NULL,
 273                  (VOID **) &Capsule
 274                  );
 275       ASSERT_EFI_ERROR (Status);
 276
 277       if (Status == EFI_SUCCESS) {
 278         //
 279         // Make sure Stack and CapsuleBuffer are not overlap
 280         //
 281         CapsuleBuffer = (VOID *)(UINTN)BASE_1MB;
 282         CapsuleBufferLength = (UINTN)(LowMemorySize - PeiMemSize);
 283         //
 284         // Call the Capsule PPI Coalesce function to coalesce the capsule data.
 285         //
 286         Status = Capsule->Coalesce (PeiServices, &CapsuleBuffer, &CapsuleBufferLength);
 287       }
 288     }
 289
 290     RequiredMemSize = RetrieveRequiredMemorySize (PeiServices);
 291     DEBUG((DEBUG_INFO, "Required memory size = %Xh bytes\n", RequiredMemSize));
 292
 293     //
 294     // Report the main memory
 295     //
 296     BuildResourceDescriptorHob (
 297       EFI_RESOURCE_SYSTEM_MEMORY,
 298       (
 299          EFI_RESOURCE_ATTRIBUTE_PRESENT |
 300          EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 301          EFI_RESOURCE_ATTRIBUTE_TESTED |
 302          EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 303          EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
 304          EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
 305          EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE
 306       ),
 307       BASE_1MB,
 308       LowMemorySize
 309       );
 310
 311     //
 312     // Make sure Stack and CapsuleBuffer are not overlap
 313     //
 314
 315     //
 316     // Install efi memory
 317     //
 318     PeiMemBase = BASE_1MB + LowMemorySize - PeiMemSize;
 319     Status = PeiServicesInstallPeiMemory (
 320                PeiMemBase,
 321                PeiMemSize - RequiredMemSize
 322                );
 323     ASSERT_EFI_ERROR (Status);
 324
 325     if (Capsule != NULL) {
 326       Status = Capsule->CreateState (PeiServices, CapsuleBuffer, CapsuleBufferLength);
 327     }
 328   }
 329
 330   return EFI_SUCCESS;
 331 }
 332
 333 /**
 334   Process FSP HOB list
 335
 336   @param[in] FspHobList  Pointer to the HOB data structure produced by FSP.
 337
 338 **/
 339 VOID
 340 ProcessFspHobList (
 341   IN VOID                 *FspHobList
 342   )
 343 {
 344   EFI_PEI_HOB_POINTERS  FspHob;
 345
 346   FspHob.Raw = FspHobList;
 347
 348   //
 349   // Add all the HOBs from FSP binary to FSP wrapper
 350   //
 351   while (!END_OF_HOB_LIST (FspHob)) {
 352     if (FspHob.Header->HobType == EFI_HOB_TYPE_GUID_EXTENSION) {
 353       //
 354       // Skip FSP binary creates PcdDataBaseHobGuid
 355       //
 356       if (!CompareGuid(&FspHob.Guid->Name, &gPcdDataBaseHobGuid)) {
 357         BuildGuidDataHob (
 358           &FspHob.Guid->Name,
 359           GET_GUID_HOB_DATA(FspHob),
 360           GET_GUID_HOB_DATA_SIZE(FspHob)
 361         );
 362       }
 363     }
 364     FspHob.Raw = GET_NEXT_HOB (FspHob);
 365   }
 366 }
 367
 368 /**
 369   Post FSP-S HOB process (not Memory Resource Descriptor).
 370
 371   @param[in] FspHobList  Pointer to the HOB data structure produced by FSP.
 372
 373   @return If platform process the FSP hob list successfully.
 374 **/
 375 EFI_STATUS
 376 EFIAPI
 377 PostFspsHobProcess (
 378   IN VOID                 *FspHobList
 379   )
 380 {
 381   ProcessFspHobList (FspHobList);
 382
 383   return EFI_SUCCESS;
 384 }