MdePkg/Library/PeiHobLib/HobLib.c

   1 /** @file
   2   Provide Hob Library functions for Pei phase.
   3
   4 Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php.
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include <PiPei.h>
  16
  17 #include <Guid/MemoryAllocationHob.h>
  18
  19 #include <Library/HobLib.h>
  20 #include <Library/DebugLib.h>
  21 #include <Library/PeiServicesLib.h>
  22 #include <Library/BaseMemoryLib.h>
  23
  24 /**
  25   Returns the pointer to the HOB list.
  26
  27   This function returns the pointer to first HOB in the list.
  28   For PEI phase, the PEI service GetHobList() can be used to retrieve the pointer
  29   to the HOB list.  For the DXE phase, the HOB list pointer can be retrieved through
  30   the EFI System Table by looking up theHOB list GUID in the System Configuration Table.
  31   Since the System Configuration Table does not exist that the time the DXE Core is
  32   launched, the DXE Core uses a global variable from the DXE Core Entry Point Library
  33   to manage the pointer to the HOB list.
  34
  35   If the pointer to the HOB list is NULL, then ASSERT().
  36
  37   @return The pointer to the HOB list.
  38
  39 **/
  40 VOID *
  41 EFIAPI
  42 GetHobList (
  43   VOID
  44   )
  45 {
  46   EFI_STATUS            Status;
  47   VOID                  *HobList;
  48
  49   Status = PeiServicesGetHobList (&HobList);
  50   ASSERT_EFI_ERROR (Status);
  51   ASSERT (HobList != NULL);
  52
  53   return HobList;
  54 }
  55
  56 /**
  57   Returns the next instance of a HOB type from the starting HOB.
  58
  59   This function searches the first instance of a HOB type from the starting HOB pointer.
  60   If there does not exist such HOB type from the starting HOB pointer, it will return NULL.
  61   In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
  62   unconditionally: it returns HobStart back if HobStart itself meets the requirement;
  63   caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
  64
  65   If HobStart is NULL, then ASSERT().
  66
  67   @param  Type          The HOB type to return.
  68   @param  HobStart      The starting HOB pointer to search from.
  69
  70   @return The next instance of a HOB type from the starting HOB.
  71
  72 **/
  73 VOID *
  74 EFIAPI
  75 GetNextHob (
  76   IN UINT16                 Type,
  77   IN CONST VOID             *HobStart
  78   )
  79 {
  80   EFI_PEI_HOB_POINTERS  Hob;
  81
  82   ASSERT (HobStart != NULL);
  83
  84   Hob.Raw = (UINT8 *) HobStart;
  85   //
  86   // Parse the HOB list until end of list or matching type is found.
  87   //
  88   while (!END_OF_HOB_LIST (Hob)) {
  89     if (Hob.Header->HobType == Type) {
  90       return Hob.Raw;
  91     }
  92     Hob.Raw = GET_NEXT_HOB (Hob);
  93   }
  94   return NULL;
  95 }
  96
  97 /**
  98   Returns the first instance of a HOB type among the whole HOB list.
  99
 100   This function searches the first instance of a HOB type among the whole HOB list.
 101   If there does not exist such HOB type in the HOB list, it will return NULL.
 102
 103   If the pointer to the HOB list is NULL, then ASSERT().
 104
 105   @param  Type          The HOB type to return.
 106
 107   @return The next instance of a HOB type from the starting HOB.
 108
 109 **/
 110 VOID *
 111 EFIAPI
 112 GetFirstHob (
 113   IN UINT16                 Type
 114   )
 115 {
 116   VOID      *HobList;
 117
 118   HobList = GetHobList ();
 119   return GetNextHob (Type, HobList);
 120 }
 121
 122 /**
 123   Returns the next instance of the matched GUID HOB from the starting HOB.
 124
 125   This function searches the first instance of a HOB from the starting HOB pointer.
 126   Such HOB should satisfy two conditions:
 127   its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
 128   If there does not exist such HOB from the starting HOB pointer, it will return NULL.
 129   Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
 130   to extract the data section and its size information, respectively.
 131   In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
 132   unconditionally: it returns HobStart back if HobStart itself meets the requirement;
 133   caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
 134
 135   If Guid is NULL, then ASSERT().
 136   If HobStart is NULL, then ASSERT().
 137
 138   @param  Guid          The GUID to match with in the HOB list.
 139   @param  HobStart      A pointer to a Guid.
 140
 141   @return The next instance of the matched GUID HOB from the starting HOB.
 142
 143 **/
 144 VOID *
 145 EFIAPI
 146 GetNextGuidHob (
 147   IN CONST EFI_GUID         *Guid,
 148   IN CONST VOID             *HobStart
 149   )
 150 {
 151   EFI_PEI_HOB_POINTERS  GuidHob;
 152
 153   GuidHob.Raw = (UINT8 *) HobStart;
 154   while ((GuidHob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, GuidHob.Raw)) != NULL) {
 155     if (CompareGuid (Guid, &GuidHob.Guid->Name)) {
 156       break;
 157     }
 158     GuidHob.Raw = GET_NEXT_HOB (GuidHob);
 159   }
 160   return GuidHob.Raw;
 161 }
 162
 163 /**
 164   Returns the first instance of the matched GUID HOB among the whole HOB list.
 165
 166   This function searches the first instance of a HOB among the whole HOB list.
 167   Such HOB should satisfy two conditions:
 168   its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
 169   If there does not exist such HOB from the starting HOB pointer, it will return NULL.
 170   Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
 171   to extract the data section and its size information, respectively.
 172
 173   If the pointer to the HOB list is NULL, then ASSERT().
 174   If Guid is NULL, then ASSERT().
 175
 176   @param  Guid          The GUID to match with in the HOB list.
 177
 178   @return The first instance of the matched GUID HOB among the whole HOB list.
 179
 180 **/
 181 VOID *
 182 EFIAPI
 183 GetFirstGuidHob (
 184   IN CONST EFI_GUID         *Guid
 185   )
 186 {
 187   VOID      *HobList;
 188
 189   HobList = GetHobList ();
 190   return GetNextGuidHob (Guid, HobList);
 191 }
 192
 193 /**
 194   Get the system boot mode from the HOB list.
 195
 196   This function returns the system boot mode information from the
 197   PHIT HOB in HOB list.
 198
 199   If the pointer to the HOB list is NULL, then ASSERT().
 200
 201   @param  VOID.
 202
 203   @return The Boot Mode.
 204
 205 **/
 206 EFI_BOOT_MODE
 207 EFIAPI
 208 GetBootModeHob (
 209   VOID
 210   )
 211 {
 212   EFI_STATUS             Status;
 213   EFI_BOOT_MODE          BootMode;
 214
 215   Status = PeiServicesGetBootMode (&BootMode);
 216   ASSERT_EFI_ERROR (Status);
 217
 218   return BootMode;
 219 }
 220
 221 /**
 222   Adds a new HOB to the HOB List.
 223
 224   This internal function enables PEIMs to create various types of HOBs.
 225
 226   @param  Type          Type of the new HOB.
 227   @param  Length        Length of the new HOB to allocate.
 228
 229   @retval  NULL         The HOB could not be allocated.
 230   @retval  others       The address of new HOB.
 231
 232 **/
 233 VOID *
 234 EFIAPI
 235 InternalPeiCreateHob (
 236   IN UINT16                      Type,
 237   IN UINT16                      Length
 238   )
 239 {
 240   EFI_STATUS        Status;
 241   VOID              *Hob;
 242
 243   Status = PeiServicesCreateHob (Type, Length, &Hob);
 244   if (EFI_ERROR (Status)) {
 245     Hob = NULL;
 246   }
 247   //
 248   // Assume the process of HOB building is always successful.
 249   //
 250   ASSERT (Hob != NULL);
 251   return Hob;
 252 }
 253
 254 /**
 255   Builds a HOB for a loaded PE32 module.
 256
 257   This function builds a HOB for a loaded PE32 module.
 258   It can only be invoked during PEI phase;
 259   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 260
 261   If ModuleName is NULL, then ASSERT().
 262   If there is no additional space for HOB creation, then ASSERT().
 263
 264   @param  ModuleName              The GUID File Name of the module.
 265   @param  MemoryAllocationModule  The 64 bit physical address of the module.
 266   @param  ModuleLength            The length of the module in bytes.
 267   @param  EntryPoint              The 64 bit physical address of the module entry point.
 268
 269 **/
 270 VOID
 271 EFIAPI
 272 BuildModuleHob (
 273   IN CONST EFI_GUID         *ModuleName,
 274   IN EFI_PHYSICAL_ADDRESS   MemoryAllocationModule,
 275   IN UINT64                 ModuleLength,
 276   IN EFI_PHYSICAL_ADDRESS   EntryPoint
 277   )
 278 {
 279   EFI_HOB_MEMORY_ALLOCATION_MODULE  *Hob;
 280
 281   ASSERT (((MemoryAllocationModule & (EFI_PAGE_SIZE - 1)) == 0) &&
 282           ((ModuleLength & (EFI_PAGE_SIZE - 1)) == 0));
 283
 284   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION_MODULE));
 285   if (Hob == NULL) {
 286     return;
 287   }
 288
 289   CopyGuid (&(Hob->MemoryAllocationHeader.Name), &gEfiHobMemoryAllocModuleGuid);
 290   Hob->MemoryAllocationHeader.MemoryBaseAddress = MemoryAllocationModule;
 291   Hob->MemoryAllocationHeader.MemoryLength      = ModuleLength;
 292   Hob->MemoryAllocationHeader.MemoryType        = EfiBootServicesCode;
 293
 294   //
 295   // Zero the reserved space to match HOB spec
 296   //
 297   ZeroMem (Hob->MemoryAllocationHeader.Reserved, sizeof (Hob->MemoryAllocationHeader.Reserved));
 298
 299   CopyGuid (&Hob->ModuleName, ModuleName);
 300   Hob->EntryPoint = EntryPoint;
 301 }
 302
 303 /**
 304   Builds a HOB that describes a chunk of system memory with Owner GUID.
 305
 306   This function builds a HOB that describes a chunk of system memory.
 307   It can only be invoked during PEI phase;
 308   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 309
 310   If there is no additional space for HOB creation, then ASSERT().
 311
 312   @param  ResourceType        The type of resource described by this HOB.
 313   @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
 314   @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
 315   @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
 316   @param  OwnerGUID           GUID for the owner of this resource.
 317
 318 **/
 319 VOID
 320 EFIAPI
 321 BuildResourceDescriptorWithOwnerHob (
 322   IN EFI_RESOURCE_TYPE            ResourceType,
 323   IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
 324   IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
 325   IN UINT64                       NumberOfBytes,
 326   IN EFI_GUID                     *OwnerGUID
 327   )
 328 {
 329   EFI_HOB_RESOURCE_DESCRIPTOR  *Hob;
 330
 331   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, (UINT16) sizeof (EFI_HOB_RESOURCE_DESCRIPTOR));
 332   if (Hob == NULL) {
 333     return;
 334   }
 335
 336   Hob->ResourceType      = ResourceType;
 337   Hob->ResourceAttribute = ResourceAttribute;
 338   Hob->PhysicalStart     = PhysicalStart;
 339   Hob->ResourceLength    = NumberOfBytes;
 340
 341   CopyGuid (&Hob->Owner, OwnerGUID);
 342 }
 343
 344 /**
 345   Builds a HOB that describes a chunk of system memory.
 346
 347   This function builds a HOB that describes a chunk of system memory.
 348   It can only be invoked during PEI phase;
 349   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 350
 351   If there is no additional space for HOB creation, then ASSERT().
 352
 353   @param  ResourceType        The type of resource described by this HOB.
 354   @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
 355   @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
 356   @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
 357
 358 **/
 359 VOID
 360 EFIAPI
 361 BuildResourceDescriptorHob (
 362   IN EFI_RESOURCE_TYPE            ResourceType,
 363   IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
 364   IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
 365   IN UINT64                       NumberOfBytes
 366   )
 367 {
 368   EFI_HOB_RESOURCE_DESCRIPTOR  *Hob;
 369
 370   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, (UINT16) sizeof (EFI_HOB_RESOURCE_DESCRIPTOR));
 371   if (Hob == NULL) {
 372     return;
 373   }
 374
 375   Hob->ResourceType      = ResourceType;
 376   Hob->ResourceAttribute = ResourceAttribute;
 377   Hob->PhysicalStart     = PhysicalStart;
 378   Hob->ResourceLength    = NumberOfBytes;
 379   ZeroMem (&(Hob->Owner), sizeof (EFI_GUID));
 380 }
 381
 382 /**
 383   Builds a customized HOB tagged with a GUID for identification and returns
 384   the start address of GUID HOB data.
 385
 386   This function builds a customized HOB tagged with a GUID for identification
 387   and returns the start address of GUID HOB data so that caller can fill the customized data.
 388   The HOB Header and Name field is already stripped.
 389   It can only be invoked during PEI phase;
 390   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 391
 392   If Guid is NULL, then ASSERT().
 393   If there is no additional space for HOB creation, then ASSERT().
 394   If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
 395   HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
 396
 397   @param  Guid          The GUID to tag the customized HOB.
 398   @param  DataLength    The size of the data payload for the GUID HOB.
 399
 400   @retval  NULL         The GUID HOB could not be allocated.
 401   @retval  others       The start address of GUID HOB data.
 402
 403 **/
 404 VOID *
 405 EFIAPI
 406 BuildGuidHob (
 407   IN CONST EFI_GUID              *Guid,
 408   IN UINTN                       DataLength
 409   )
 410 {
 411   EFI_HOB_GUID_TYPE *Hob;
 412
 413   //
 414   // Make sure Guid is valid
 415   //
 416   ASSERT (Guid != NULL);
 417
 418   //
 419   // Make sure that data length is not too long.
 420   //
 421   ASSERT (DataLength <= (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)));
 422
 423   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_GUID_EXTENSION, (UINT16) (sizeof (EFI_HOB_GUID_TYPE) + DataLength));
 424   if (Hob == NULL) {
 425     return Hob;
 426   }
 427   CopyGuid (&Hob->Name, Guid);
 428   return Hob + 1;
 429 }
 430
 431 /**
 432   Builds a customized HOB tagged with a GUID for identification, copies the input data to the HOB
 433   data field, and returns the start address of the GUID HOB data.
 434
 435   This function builds a customized HOB tagged with a GUID for identification and copies the input
 436   data to the HOB data field and returns the start address of the GUID HOB data.  It can only be
 437   invoked during PEI phase; for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 438   The HOB Header and Name field is already stripped.
 439   It can only be invoked during PEI phase;
 440   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 441
 442   If Guid is NULL, then ASSERT().
 443   If Data is NULL and DataLength > 0, then ASSERT().
 444   If there is no additional space for HOB creation, then ASSERT().
 445   If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
 446   HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
 447
 448   @param  Guid          The GUID to tag the customized HOB.
 449   @param  Data          The data to be copied into the data field of the GUID HOB.
 450   @param  DataLength    The size of the data payload for the GUID HOB.
 451
 452   @retval  NULL         The GUID HOB could not be allocated.
 453   @retval  others       The start address of GUID HOB data.
 454
 455 **/
 456 VOID *
 457 EFIAPI
 458 BuildGuidDataHob (
 459   IN CONST EFI_GUID              *Guid,
 460   IN VOID                        *Data,
 461   IN UINTN                       DataLength
 462   )
 463 {
 464   VOID  *HobData;
 465
 466   ASSERT (Data != NULL || DataLength == 0);
 467
 468   HobData = BuildGuidHob (Guid, DataLength);
 469   if (HobData == NULL) {
 470     return HobData;
 471   }
 472
 473   return CopyMem (HobData, Data, DataLength);
 474 }
 475
 476 /**
 477   Builds a Firmware Volume HOB.
 478
 479   This function builds a Firmware Volume HOB.
 480   It can only be invoked during PEI phase;
 481   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 482
 483   If there is no additional space for HOB creation, then ASSERT().
 484
 485   @param  BaseAddress   The base address of the Firmware Volume.
 486   @param  Length        The size of the Firmware Volume in bytes.
 487
 488 **/
 489 VOID
 490 EFIAPI
 491 BuildFvHob (
 492   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 493   IN UINT64                      Length
 494   )
 495 {
 496   EFI_HOB_FIRMWARE_VOLUME  *Hob;
 497
 498   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_FV, (UINT16) sizeof (EFI_HOB_FIRMWARE_VOLUME));
 499   if (Hob == NULL) {
 500     return;
 501   }
 502
 503   Hob->BaseAddress = BaseAddress;
 504   Hob->Length      = Length;
 505 }
 506
 507 /**
 508   Builds a EFI_HOB_TYPE_FV2 HOB.
 509
 510   This function builds a EFI_HOB_TYPE_FV2 HOB.
 511   It can only be invoked during PEI phase;
 512   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 513
 514   If there is no additional space for HOB creation, then ASSERT().
 515
 516   @param  BaseAddress   The base address of the Firmware Volume.
 517   @param  Length        The size of the Firmware Volume in bytes.
 518   @param  FvName        The name of the Firmware Volume.
 519   @param  FileName      The name of the file.
 520
 521 **/
 522 VOID
 523 EFIAPI
 524 BuildFv2Hob (
 525   IN          EFI_PHYSICAL_ADDRESS        BaseAddress,
 526   IN          UINT64                      Length,
 527   IN CONST    EFI_GUID                    *FvName,
 528   IN CONST    EFI_GUID                    *FileName
 529   )
 530 {
 531   EFI_HOB_FIRMWARE_VOLUME2  *Hob;
 532
 533   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_FV2, (UINT16) sizeof (EFI_HOB_FIRMWARE_VOLUME2));
 534   if (Hob == NULL) {
 535     return;
 536   }
 537
 538   Hob->BaseAddress = BaseAddress;
 539   Hob->Length      = Length;
 540   CopyGuid (&Hob->FvName, FvName);
 541   CopyGuid (&Hob->FileName, FileName);
 542 }
 543
 544 /**
 545   Builds a Capsule Volume HOB.
 546
 547   This function builds a Capsule Volume HOB.
 548   It can only be invoked during PEI phase;
 549   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 550
 551   If the platform does not support Capsule Volume HOBs, then ASSERT().
 552   If there is no additional space for HOB creation, then ASSERT().
 553
 554   @param  BaseAddress   The base address of the Capsule Volume.
 555   @param  Length        The size of the Capsule Volume in bytes.
 556
 557 **/
 558 VOID
 559 EFIAPI
 560 BuildCvHob (
 561   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 562   IN UINT64                      Length
 563   )
 564 {
 565   EFI_HOB_UEFI_CAPSULE  *Hob;
 566
 567   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_UEFI_CAPSULE, (UINT16) sizeof (EFI_HOB_UEFI_CAPSULE));
 568   if (Hob == NULL) {
 569     return;
 570   }
 571
 572   Hob->BaseAddress  = BaseAddress;
 573   Hob->Length       = Length;
 574 }
 575
 576 /**
 577   Builds a HOB for the CPU.
 578
 579   This function builds a HOB for the CPU.
 580   It can only be invoked during PEI phase;
 581   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 582
 583   If there is no additional space for HOB creation, then ASSERT().
 584
 585   @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.
 586   @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.
 587
 588 **/
 589 VOID
 590 EFIAPI
 591 BuildCpuHob (
 592   IN UINT8                       SizeOfMemorySpace,
 593   IN UINT8                       SizeOfIoSpace
 594   )
 595 {
 596   EFI_HOB_CPU  *Hob;
 597
 598   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_CPU, (UINT16) sizeof (EFI_HOB_CPU));
 599   if (Hob == NULL) {
 600     return;
 601   }
 602
 603   Hob->SizeOfMemorySpace = SizeOfMemorySpace;
 604   Hob->SizeOfIoSpace     = SizeOfIoSpace;
 605
 606   //
 607   // Zero the reserved space to match HOB spec
 608   //
 609   ZeroMem (Hob->Reserved, sizeof (Hob->Reserved));
 610 }
 611
 612 /**
 613   Builds a HOB for the Stack.
 614
 615   This function builds a HOB for the stack.
 616   It can only be invoked during PEI phase;
 617   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 618
 619   If there is no additional space for HOB creation, then ASSERT().
 620
 621   @param  BaseAddress   The 64 bit physical address of the Stack.
 622   @param  Length        The length of the stack in bytes.
 623
 624 **/
 625 VOID
 626 EFIAPI
 627 BuildStackHob (
 628   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 629   IN UINT64                      Length
 630   )
 631 {
 632   EFI_HOB_MEMORY_ALLOCATION_STACK  *Hob;
 633
 634   ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
 635           ((Length & (EFI_PAGE_SIZE - 1)) == 0));
 636
 637   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION_STACK));
 638   if (Hob == NULL) {
 639     return;
 640   }
 641
 642   CopyGuid (&(Hob->AllocDescriptor.Name), &gEfiHobMemoryAllocStackGuid);
 643   Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
 644   Hob->AllocDescriptor.MemoryLength      = Length;
 645   Hob->AllocDescriptor.MemoryType        = EfiBootServicesData;
 646
 647   //
 648   // Zero the reserved space to match HOB spec
 649   //
 650   ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
 651 }
 652
 653 /**
 654   Builds a HOB for the BSP store.
 655
 656   This function builds a HOB for BSP store.
 657   It can only be invoked during PEI phase;
 658   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 659
 660   If there is no additional space for HOB creation, then ASSERT().
 661
 662   @param  BaseAddress   The 64 bit physical address of the BSP.
 663   @param  Length        The length of the BSP store in bytes.
 664   @param  MemoryType    The type of memory allocated by this HOB.
 665
 666 **/
 667 VOID
 668 EFIAPI
 669 BuildBspStoreHob (
 670   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 671   IN UINT64                      Length,
 672   IN EFI_MEMORY_TYPE             MemoryType
 673   )
 674 {
 675   EFI_HOB_MEMORY_ALLOCATION_BSP_STORE  *Hob;
 676
 677   ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
 678           ((Length & (EFI_PAGE_SIZE - 1)) == 0));
 679
 680   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION_BSP_STORE));
 681   if (Hob == NULL) {
 682     return;
 683   }
 684
 685   CopyGuid (&(Hob->AllocDescriptor.Name), &gEfiHobMemoryAllocBspStoreGuid);
 686   Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
 687   Hob->AllocDescriptor.MemoryLength      = Length;
 688   Hob->AllocDescriptor.MemoryType        = MemoryType;
 689
 690   //
 691   // Zero the reserved space to match HOB spec
 692   //
 693   ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
 694 }
 695
 696 /**
 697   Builds a HOB for the memory allocation.
 698
 699   This function builds a HOB for the memory allocation.
 700   It can only be invoked during PEI phase;
 701   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 702
 703   If there is no additional space for HOB creation, then ASSERT().
 704
 705   @param  BaseAddress   The 64 bit physical address of the memory.
 706   @param  Length        The length of the memory allocation in bytes.
 707   @param  MemoryType    The type of memory allocated by this HOB.
 708
 709 **/
 710 VOID
 711 EFIAPI
 712 BuildMemoryAllocationHob (
 713   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 714   IN UINT64                      Length,
 715   IN EFI_MEMORY_TYPE             MemoryType
 716   )
 717 {
 718   EFI_HOB_MEMORY_ALLOCATION  *Hob;
 719
 720   ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
 721           ((Length & (EFI_PAGE_SIZE - 1)) == 0));
 722
 723   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION));
 724   if (Hob == NULL) {
 725     return;
 726   }
 727
 728   ZeroMem (&(Hob->AllocDescriptor.Name), sizeof (EFI_GUID));
 729   Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
 730   Hob->AllocDescriptor.MemoryLength      = Length;
 731   Hob->AllocDescriptor.MemoryType        = MemoryType;
 732   //
 733   // Zero the reserved space to match HOB spec
 734   //
 735   ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
 736 }