StandaloneMmPkg/Library/StandaloneMmCoreHobLib/StandaloneMmCoreHobLib.c

   1 /** @file
   2   HOB Library implementation for Standalone MM Core.
   3
   4 Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
   5 Copyright (c) 2017 - 2018, ARM Limited. All rights reserved.<BR>
   6
   7 SPDX-License-Identifier: BSD-2-Clause-Patent
   8
   9 **/
  10
  11 #include <PiMm.h>
  12
  13 #include <Library/HobLib.h>
  14 #include <Library/DebugLib.h>
  15 #include <Library/BaseMemoryLib.h>
  16
  17 #include <Guid/MemoryAllocationHob.h>
  18
  19 //
  20 // Cache copy of HobList pointer.
  21 //
  22 VOID *gHobList = NULL;
  23
  24 /**
  25   Returns the pointer to the HOB list.
  26
  27   This function returns the pointer to first HOB in the list.
  28   If the pointer to the HOB list is NULL, then ASSERT().
  29
  30   @return The pointer to the HOB list.
  31
  32 **/
  33 VOID *
  34 EFIAPI
  35 GetHobList (
  36   VOID
  37   )
  38 {
  39   ASSERT (gHobList != NULL);
  40   return gHobList;
  41 }
  42
  43 /**
  44   Returns the next instance of a HOB type from the starting HOB.
  45
  46   This function searches the first instance of a HOB type from the starting HOB pointer.
  47   If there does not exist such HOB type from the starting HOB pointer, it will return NULL.
  48   In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
  49   unconditionally: it returns HobStart back if HobStart itself meets the requirement;
  50   caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
  51
  52   If HobStart is NULL, then ASSERT().
  53
  54   @param  Type          The HOB type to return.
  55   @param  HobStart      The starting HOB pointer to search from.
  56
  57   @return The next instance of a HOB type from the starting HOB.
  58
  59 **/
  60 VOID *
  61 EFIAPI
  62 GetNextHob (
  63   IN UINT16                 Type,
  64   IN CONST VOID             *HobStart
  65   )
  66 {
  67   EFI_PEI_HOB_POINTERS  Hob;
  68
  69   ASSERT (HobStart != NULL);
  70
  71   Hob.Raw = (UINT8 *) HobStart;
  72   //
  73   // Parse the HOB list until end of list or matching type is found.
  74   //
  75   while (!END_OF_HOB_LIST (Hob)) {
  76     if (Hob.Header->HobType == Type) {
  77       return Hob.Raw;
  78     }
  79     Hob.Raw = GET_NEXT_HOB (Hob);
  80   }
  81   return NULL;
  82 }
  83
  84 /**
  85   Returns the first instance of a HOB type among the whole HOB list.
  86
  87   This function searches the first instance of a HOB type among the whole HOB list.
  88   If there does not exist such HOB type in the HOB list, it will return NULL.
  89
  90   If the pointer to the HOB list is NULL, then ASSERT().
  91
  92   @param  Type          The HOB type to return.
  93
  94   @return The next instance of a HOB type from the starting HOB.
  95
  96 **/
  97 VOID *
  98 EFIAPI
  99 GetFirstHob (
 100   IN UINT16                 Type
 101   )
 102 {
 103   VOID      *HobList;
 104
 105   HobList = GetHobList ();
 106   return GetNextHob (Type, HobList);
 107 }
 108
 109 /**
 110   Returns the next instance of the matched GUID HOB from the starting HOB.
 111
 112   This function searches the first instance of a HOB from the starting HOB pointer.
 113   Such HOB should satisfy two conditions:
 114   its HOB type is EFI_HOB_TYPE_GUID_EXTENSION, and its GUID Name equals to the input Guid.
 115   If such a HOB from the starting HOB pointer does not exist, it will return NULL.
 116   Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
 117   to extract the data section and its size information, respectively.
 118   In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
 119   unconditionally: it returns HobStart back if HobStart itself meets the requirement;
 120   caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
 121
 122   If Guid is NULL, then ASSERT().
 123   If HobStart is NULL, then ASSERT().
 124
 125   @param  Guid          The GUID to match with in the HOB list.
 126   @param  HobStart      A pointer to a Guid.
 127
 128   @return The next instance of the matched GUID HOB from the starting HOB.
 129
 130 **/
 131 VOID *
 132 EFIAPI
 133 GetNextGuidHob (
 134   IN CONST EFI_GUID         *Guid,
 135   IN CONST VOID             *HobStart
 136   )
 137 {
 138   EFI_PEI_HOB_POINTERS  GuidHob;
 139
 140   GuidHob.Raw = (UINT8 *) HobStart;
 141   while ((GuidHob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, GuidHob.Raw)) != NULL) {
 142     if (CompareGuid (Guid, &GuidHob.Guid->Name)) {
 143       break;
 144     }
 145     GuidHob.Raw = GET_NEXT_HOB (GuidHob);
 146   }
 147   return GuidHob.Raw;
 148 }
 149
 150 /**
 151   Returns the first instance of the matched GUID HOB among the whole HOB list.
 152
 153   This function searches the first instance of a HOB among the whole HOB list.
 154   Such HOB should satisfy two conditions:
 155   its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
 156   If such a HOB from the starting HOB pointer does not exist, it will return NULL.
 157   Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
 158   to extract the data section and its size information, respectively.
 159
 160   If the pointer to the HOB list is NULL, then ASSERT().
 161   If Guid is NULL, then ASSERT().
 162
 163   @param  Guid          The GUID to match with in the HOB list.
 164
 165   @return The first instance of the matched GUID HOB among the whole HOB list.
 166
 167 **/
 168 VOID *
 169 EFIAPI
 170 GetFirstGuidHob (
 171   IN CONST EFI_GUID         *Guid
 172   )
 173 {
 174   VOID      *HobList;
 175
 176   HobList = GetHobList ();
 177   return GetNextGuidHob (Guid, HobList);
 178 }
 179
 180 /**
 181   Get the system boot mode from the HOB list.
 182
 183   This function returns the system boot mode information from the
 184   PHIT HOB in HOB list.
 185
 186   If the pointer to the HOB list is NULL, then ASSERT().
 187
 188   @param  VOID
 189
 190   @return The Boot Mode.
 191
 192 **/
 193 EFI_BOOT_MODE
 194 EFIAPI
 195 GetBootModeHob (
 196   VOID
 197   )
 198 {
 199   EFI_HOB_HANDOFF_INFO_TABLE    *HandOffHob;
 200
 201   HandOffHob = (EFI_HOB_HANDOFF_INFO_TABLE *) GetHobList ();
 202
 203   return HandOffHob->BootMode;
 204 }
 205
 206 VOID *
 207 CreateHob (
 208   IN  UINT16    HobType,
 209   IN  UINT16    HobLength
 210   )
 211 {
 212   EFI_HOB_HANDOFF_INFO_TABLE  *HandOffHob;
 213   EFI_HOB_GENERIC_HEADER      *HobEnd;
 214   EFI_PHYSICAL_ADDRESS        FreeMemory;
 215   VOID                        *Hob;
 216
 217   HandOffHob = GetHobList ();
 218
 219   HobLength = (UINT16)((HobLength + 0x7) & (~0x7));
 220
 221   FreeMemory = HandOffHob->EfiFreeMemoryTop - HandOffHob->EfiFreeMemoryBottom;
 222
 223   if (FreeMemory < HobLength) {
 224     return NULL;
 225   }
 226
 227   Hob = (VOID*) (UINTN) HandOffHob->EfiEndOfHobList;
 228   ((EFI_HOB_GENERIC_HEADER*) Hob)->HobType = HobType;
 229   ((EFI_HOB_GENERIC_HEADER*) Hob)->HobLength = HobLength;
 230   ((EFI_HOB_GENERIC_HEADER*) Hob)->Reserved = 0;
 231
 232   HobEnd = (EFI_HOB_GENERIC_HEADER*) ((UINTN)Hob + HobLength);
 233   HandOffHob->EfiEndOfHobList = (EFI_PHYSICAL_ADDRESS) (UINTN) HobEnd;
 234
 235   HobEnd->HobType   = EFI_HOB_TYPE_END_OF_HOB_LIST;
 236   HobEnd->HobLength = sizeof (EFI_HOB_GENERIC_HEADER);
 237   HobEnd->Reserved  = 0;
 238   HobEnd++;
 239   HandOffHob->EfiFreeMemoryBottom = (EFI_PHYSICAL_ADDRESS) (UINTN) HobEnd;
 240
 241   return Hob;
 242 }
 243
 244 /**
 245   Builds a HOB for a loaded PE32 module.
 246
 247   This function builds a HOB for a loaded PE32 module.
 248   If ModuleName is NULL, then ASSERT().
 249   If there is no additional space for HOB creation, then ASSERT().
 250
 251   @param  ModuleName              The GUID File Name of the module.
 252   @param  MemoryAllocationModule  The 64 bit physical address of the module.
 253   @param  ModuleLength            The length of the module in bytes.
 254   @param  EntryPoint              The 64 bit physical address of the module entry point.
 255
 256 **/
 257 VOID
 258 EFIAPI
 259 BuildModuleHob (
 260   IN CONST EFI_GUID         *ModuleName,
 261   IN EFI_PHYSICAL_ADDRESS   MemoryAllocationModule,
 262   IN UINT64                 ModuleLength,
 263   IN EFI_PHYSICAL_ADDRESS   EntryPoint
 264   )
 265 {
 266   EFI_HOB_MEMORY_ALLOCATION_MODULE  *Hob;
 267
 268   ASSERT (((MemoryAllocationModule & (EFI_PAGE_SIZE - 1)) == 0) &&
 269           ((ModuleLength & (EFI_PAGE_SIZE - 1)) == 0));
 270
 271   Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION_MODULE));
 272
 273   CopyGuid (&(Hob->MemoryAllocationHeader.Name), &gEfiHobMemoryAllocModuleGuid);
 274   Hob->MemoryAllocationHeader.MemoryBaseAddress = MemoryAllocationModule;
 275   Hob->MemoryAllocationHeader.MemoryLength      = ModuleLength;
 276   Hob->MemoryAllocationHeader.MemoryType        = EfiBootServicesCode;
 277
 278   //
 279   // Zero the reserved space to match HOB spec
 280   //
 281   ZeroMem (Hob->MemoryAllocationHeader.Reserved, sizeof (Hob->MemoryAllocationHeader.Reserved));
 282
 283   CopyGuid (&Hob->ModuleName, ModuleName);
 284   Hob->EntryPoint = EntryPoint;
 285 }
 286
 287 /**
 288   Builds a HOB that describes a chunk of system memory.
 289
 290   This function builds a HOB that describes a chunk of system memory.
 291   If there is no additional space for HOB creation, then ASSERT().
 292
 293   @param  ResourceType        The type of resource described by this HOB.
 294   @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
 295   @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
 296   @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
 297
 298 **/
 299 VOID
 300 EFIAPI
 301 BuildResourceDescriptorHob (
 302   IN EFI_RESOURCE_TYPE            ResourceType,
 303   IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
 304   IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
 305   IN UINT64                       NumberOfBytes
 306   )
 307 {
 308   EFI_HOB_RESOURCE_DESCRIPTOR  *Hob;
 309
 310   Hob = CreateHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, sizeof (EFI_HOB_RESOURCE_DESCRIPTOR));
 311   ASSERT (Hob != NULL);
 312
 313   Hob->ResourceType      = ResourceType;
 314   Hob->ResourceAttribute = ResourceAttribute;
 315   Hob->PhysicalStart     = PhysicalStart;
 316   Hob->ResourceLength    = NumberOfBytes;
 317 }
 318
 319 /**
 320   Builds a GUID HOB with a certain data length.
 321
 322   This function builds a customized HOB tagged with a GUID for identification
 323   and returns the start address of GUID HOB data so that caller can fill the customized data.
 324   The HOB Header and Name field is already stripped.
 325   If Guid is NULL, then ASSERT().
 326   If there is no additional space for HOB creation, then ASSERT().
 327   If DataLength >= (0x10000 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
 328
 329   @param  Guid          The GUID to tag the customized HOB.
 330   @param  DataLength    The size of the data payload for the GUID HOB.
 331
 332   @return The start address of GUID HOB data.
 333
 334 **/
 335 VOID *
 336 EFIAPI
 337 BuildGuidHob (
 338   IN CONST EFI_GUID              *Guid,
 339   IN UINTN                       DataLength
 340   )
 341 {
 342   EFI_HOB_GUID_TYPE *Hob;
 343
 344   //
 345   // Make sure that data length is not too long.
 346   //
 347   ASSERT (DataLength <= (0xffff - sizeof (EFI_HOB_GUID_TYPE)));
 348
 349   Hob = CreateHob (EFI_HOB_TYPE_GUID_EXTENSION, (UINT16) (sizeof (EFI_HOB_GUID_TYPE) + DataLength));
 350   CopyGuid (&Hob->Name, Guid);
 351   return Hob + 1;
 352 }
 353
 354
 355 /**
 356   Copies a data buffer to a newly-built HOB.
 357
 358   This function builds a customized HOB tagged with a GUID for identification,
 359   copies the input data to the HOB data field and returns the start address of the GUID HOB data.
 360   The HOB Header and Name field is already stripped.
 361   If Guid is NULL, then ASSERT().
 362   If Data is NULL and DataLength > 0, then ASSERT().
 363   If there is no additional space for HOB creation, then ASSERT().
 364   If DataLength >= (0x10000 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
 365
 366   @param  Guid          The GUID to tag the customized HOB.
 367   @param  Data          The data to be copied into the data field of the GUID HOB.
 368   @param  DataLength    The size of the data payload for the GUID HOB.
 369
 370   @return The start address of GUID HOB data.
 371
 372 **/
 373 VOID *
 374 EFIAPI
 375 BuildGuidDataHob (
 376   IN CONST EFI_GUID              *Guid,
 377   IN VOID                        *Data,
 378   IN UINTN                       DataLength
 379   )
 380 {
 381   VOID  *HobData;
 382
 383   ASSERT (Data != NULL || DataLength == 0);
 384
 385   HobData = BuildGuidHob (Guid, DataLength);
 386
 387   return CopyMem (HobData, Data, DataLength);
 388 }
 389
 390 /**
 391   Builds a Firmware Volume HOB.
 392
 393   This function builds a Firmware Volume HOB.
 394   If there is no additional space for HOB creation, then ASSERT().
 395
 396   @param  BaseAddress   The base address of the Firmware Volume.
 397   @param  Length        The size of the Firmware Volume in bytes.
 398
 399 **/
 400 VOID
 401 EFIAPI
 402 BuildFvHob (
 403   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 404   IN UINT64                      Length
 405   )
 406 {
 407   EFI_HOB_FIRMWARE_VOLUME  *Hob;
 408
 409   Hob = CreateHob (EFI_HOB_TYPE_FV, sizeof (EFI_HOB_FIRMWARE_VOLUME));
 410
 411   Hob->BaseAddress = BaseAddress;
 412   Hob->Length      = Length;
 413 }
 414
 415
 416 /**
 417   Builds a EFI_HOB_TYPE_FV2 HOB.
 418
 419   This function builds a EFI_HOB_TYPE_FV2 HOB.
 420   If there is no additional space for HOB creation, then ASSERT().
 421
 422   @param  BaseAddress   The base address of the Firmware Volume.
 423   @param  Length        The size of the Firmware Volume in bytes.
 424   @param  FvName       The name of the Firmware Volume.
 425   @param  FileName      The name of the file.
 426
 427 **/
 428 VOID
 429 EFIAPI
 430 BuildFv2Hob (
 431   IN          EFI_PHYSICAL_ADDRESS        BaseAddress,
 432   IN          UINT64                      Length,
 433   IN CONST    EFI_GUID                    *FvName,
 434   IN CONST    EFI_GUID                    *FileName
 435   )
 436 {
 437   EFI_HOB_FIRMWARE_VOLUME2  *Hob;
 438
 439   Hob = CreateHob (EFI_HOB_TYPE_FV2, sizeof (EFI_HOB_FIRMWARE_VOLUME2));
 440
 441   Hob->BaseAddress = BaseAddress;
 442   Hob->Length      = Length;
 443   CopyGuid (&Hob->FvName, FvName);
 444   CopyGuid (&Hob->FileName, FileName);
 445 }
 446
 447
 448 /**
 449   Builds a HOB for the CPU.
 450
 451   This function builds a HOB for the CPU.
 452   If there is no additional space for HOB creation, then ASSERT().
 453
 454   @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.
 455   @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.
 456
 457 **/
 458 VOID
 459 EFIAPI
 460 BuildCpuHob (
 461   IN UINT8                       SizeOfMemorySpace,
 462   IN UINT8                       SizeOfIoSpace
 463   )
 464 {
 465   EFI_HOB_CPU  *Hob;
 466
 467   Hob = CreateHob (EFI_HOB_TYPE_CPU, sizeof (EFI_HOB_CPU));
 468
 469   Hob->SizeOfMemorySpace = SizeOfMemorySpace;
 470   Hob->SizeOfIoSpace     = SizeOfIoSpace;
 471
 472   //
 473   // Zero the reserved space to match HOB spec
 474   //
 475   ZeroMem (Hob->Reserved, sizeof (Hob->Reserved));
 476 }
 477
 478 /**
 479   Builds a HOB for the memory allocation.
 480
 481   This function builds a HOB for the memory allocation.
 482   If there is no additional space for HOB creation, then ASSERT().
 483
 484   @param  BaseAddress   The 64 bit physical address of the memory.
 485   @param  Length        The length of the memory allocation in bytes.
 486   @param  MemoryType    Type of memory allocated by this HOB.
 487
 488 **/
 489 VOID
 490 EFIAPI
 491 BuildMemoryAllocationHob (
 492   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 493   IN UINT64                      Length,
 494   IN EFI_MEMORY_TYPE             MemoryType
 495   )
 496 {
 497   EFI_HOB_MEMORY_ALLOCATION  *Hob;
 498
 499   ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
 500           ((Length & (EFI_PAGE_SIZE - 1)) == 0));
 501
 502   Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION));
 503
 504   ZeroMem (&(Hob->AllocDescriptor.Name), sizeof (EFI_GUID));
 505   Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
 506   Hob->AllocDescriptor.MemoryLength      = Length;
 507   Hob->AllocDescriptor.MemoryType        = MemoryType;
 508   //
 509   // Zero the reserved space to match HOB spec
 510   //
 511   ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
 512 }
 513
 514 /**
 515   Builds a HOB that describes a chunk of system memory with Owner GUID.
 516
 517   This function builds a HOB that describes a chunk of system memory.
 518   If there is no additional space for HOB creation, then ASSERT().
 519
 520   @param  ResourceType        The type of resource described by this HOB.
 521   @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
 522   @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
 523   @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
 524   @param  OwnerGUID           GUID for the owner of this resource.
 525
 526 **/
 527 VOID
 528 EFIAPI
 529 BuildResourceDescriptorWithOwnerHob (
 530   IN EFI_RESOURCE_TYPE            ResourceType,
 531   IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
 532   IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
 533   IN UINT64                       NumberOfBytes,
 534   IN EFI_GUID                     *OwnerGUID
 535   )
 536 {
 537   ASSERT (FALSE);
 538 }
 539
 540 /**
 541   Builds a Capsule Volume HOB.
 542
 543   This function builds a Capsule Volume HOB.
 544   If the platform does not support Capsule Volume HOBs, then ASSERT().
 545   If there is no additional space for HOB creation, then ASSERT().
 546
 547   @param  BaseAddress   The base address of the Capsule Volume.
 548   @param  Length        The size of the Capsule Volume in bytes.
 549
 550 **/
 551 VOID
 552 EFIAPI
 553 BuildCvHob (
 554   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 555   IN UINT64                      Length
 556   )
 557 {
 558   ASSERT (FALSE);
 559 }
 560
 561
 562 /**
 563   Builds a HOB for the BSP store.
 564
 565   This function builds a HOB for BSP store.
 566   If there is no additional space for HOB creation, then ASSERT().
 567
 568   @param  BaseAddress   The 64 bit physical address of the BSP.
 569   @param  Length        The length of the BSP store in bytes.
 570   @param  MemoryType    Type of memory allocated by this HOB.
 571
 572 **/
 573 VOID
 574 EFIAPI
 575 BuildBspStoreHob (
 576   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 577   IN UINT64                      Length,
 578   IN EFI_MEMORY_TYPE             MemoryType
 579   )
 580 {
 581   ASSERT (FALSE);
 582 }
 583
 584 /**
 585   Builds a HOB for the Stack.
 586
 587   This function builds a HOB for the stack.
 588   If there is no additional space for HOB creation, then ASSERT().
 589
 590   @param  BaseAddress   The 64 bit physical address of the Stack.
 591   @param  Length        The length of the stack in bytes.
 592
 593 **/
 594 VOID
 595 EFIAPI
 596 BuildStackHob (
 597   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 598   IN UINT64                      Length
 599   )
 600 {
 601   ASSERT (FALSE);
 602 }