MdePkg/Library/PeiHobLib/HobLib.c

   1 /** @file
   2   Provide Hob Library functions for Pei phase.
   3
   4 Copyright (c) 2007 - 2012, 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.
 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
 317 **/
 318 VOID
 319 EFIAPI
 320 BuildResourceDescriptorHob (
 321   IN EFI_RESOURCE_TYPE            ResourceType,
 322   IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
 323   IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
 324   IN UINT64                       NumberOfBytes
 325   )
 326 {
 327   EFI_HOB_RESOURCE_DESCRIPTOR  *Hob;
 328
 329   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, (UINT16) sizeof (EFI_HOB_RESOURCE_DESCRIPTOR));
 330   if (Hob == NULL) {
 331     return;
 332   }
 333
 334   Hob->ResourceType      = ResourceType;
 335   Hob->ResourceAttribute = ResourceAttribute;
 336   Hob->PhysicalStart     = PhysicalStart;
 337   Hob->ResourceLength    = NumberOfBytes;
 338 }
 339
 340 /**
 341   Builds a customized HOB tagged with a GUID for identification and returns
 342   the start address of GUID HOB data.
 343
 344   This function builds a customized HOB tagged with a GUID for identification
 345   and returns the start address of GUID HOB data so that caller can fill the customized data.
 346   The HOB Header and Name field is already stripped.
 347   It can only be invoked during PEI phase;
 348   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 349
 350   If Guid is NULL, then ASSERT().
 351   If there is no additional space for HOB creation, then ASSERT().
 352   If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
 353   HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
 354
 355   @param  Guid          The GUID to tag the customized HOB.
 356   @param  DataLength    The size of the data payload for the GUID HOB.
 357
 358   @retval  NULL         The GUID HOB could not be allocated.
 359   @retval  others       The start address of GUID HOB data.
 360
 361 **/
 362 VOID *
 363 EFIAPI
 364 BuildGuidHob (
 365   IN CONST EFI_GUID              *Guid,
 366   IN UINTN                       DataLength
 367   )
 368 {
 369   EFI_HOB_GUID_TYPE *Hob;
 370
 371   //
 372   // Make sure Guid is valid
 373   //
 374   ASSERT (Guid != NULL);
 375
 376   //
 377   // Make sure that data length is not too long.
 378   //
 379   ASSERT (DataLength <= (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)));
 380
 381   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_GUID_EXTENSION, (UINT16) (sizeof (EFI_HOB_GUID_TYPE) + DataLength));
 382   if (Hob == NULL) {
 383     return Hob;
 384   }
 385   CopyGuid (&Hob->Name, Guid);
 386   return Hob + 1;
 387 }
 388
 389 /**
 390   Builds a customized HOB tagged with a GUID for identification, copies the input data to the HOB
 391   data field, and returns the start address of the GUID HOB data.
 392
 393   This function builds a customized HOB tagged with a GUID for identification and copies the input
 394   data to the HOB data field and returns the start address of the GUID HOB data.  It can only be
 395   invoked during PEI phase; for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 396   The HOB Header and Name field is already stripped.
 397   It can only be invoked during PEI phase;
 398   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 399
 400   If Guid is NULL, then ASSERT().
 401   If Data is NULL and DataLength > 0, then ASSERT().
 402   If there is no additional space for HOB creation, then ASSERT().
 403   If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
 404   HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
 405
 406   @param  Guid          The GUID to tag the customized HOB.
 407   @param  Data          The data to be copied into the data field of the GUID HOB.
 408   @param  DataLength    The size of the data payload for the GUID HOB.
 409
 410   @retval  NULL         The GUID HOB could not be allocated.
 411   @retval  others       The start address of GUID HOB data.
 412
 413 **/
 414 VOID *
 415 EFIAPI
 416 BuildGuidDataHob (
 417   IN CONST EFI_GUID              *Guid,
 418   IN VOID                        *Data,
 419   IN UINTN                       DataLength
 420   )
 421 {
 422   VOID  *HobData;
 423
 424   ASSERT (Data != NULL || DataLength == 0);
 425
 426   HobData = BuildGuidHob (Guid, DataLength);
 427   if (HobData == NULL) {
 428     return HobData;
 429   }
 430
 431   return CopyMem (HobData, Data, DataLength);
 432 }
 433
 434 /**
 435   Builds a Firmware Volume HOB.
 436
 437   This function builds a Firmware Volume HOB.
 438   It can only be invoked during PEI phase;
 439   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 440
 441   If there is no additional space for HOB creation, then ASSERT().
 442
 443   @param  BaseAddress   The base address of the Firmware Volume.
 444   @param  Length        The size of the Firmware Volume in bytes.
 445
 446 **/
 447 VOID
 448 EFIAPI
 449 BuildFvHob (
 450   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 451   IN UINT64                      Length
 452   )
 453 {
 454   EFI_HOB_FIRMWARE_VOLUME  *Hob;
 455
 456   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_FV, (UINT16) sizeof (EFI_HOB_FIRMWARE_VOLUME));
 457   if (Hob == NULL) {
 458     return;
 459   }
 460
 461   Hob->BaseAddress = BaseAddress;
 462   Hob->Length      = Length;
 463 }
 464
 465 /**
 466   Builds a EFI_HOB_TYPE_FV2 HOB.
 467
 468   This function builds a EFI_HOB_TYPE_FV2 HOB.
 469   It can only be invoked during PEI phase;
 470   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 471
 472   If there is no additional space for HOB creation, then ASSERT().
 473
 474   @param  BaseAddress   The base address of the Firmware Volume.
 475   @param  Length        The size of the Firmware Volume in bytes.
 476   @param  FvName        The name of the Firmware Volume.
 477   @param  FileName      The name of the file.
 478
 479 **/
 480 VOID
 481 EFIAPI
 482 BuildFv2Hob (
 483   IN          EFI_PHYSICAL_ADDRESS        BaseAddress,
 484   IN          UINT64                      Length,
 485   IN CONST    EFI_GUID                    *FvName,
 486   IN CONST    EFI_GUID                    *FileName
 487   )
 488 {
 489   EFI_HOB_FIRMWARE_VOLUME2  *Hob;
 490
 491   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_FV2, (UINT16) sizeof (EFI_HOB_FIRMWARE_VOLUME2));
 492   if (Hob == NULL) {
 493     return;
 494   }
 495
 496   Hob->BaseAddress = BaseAddress;
 497   Hob->Length      = Length;
 498   CopyGuid (&Hob->FvName, FvName);
 499   CopyGuid (&Hob->FileName, FileName);
 500 }
 501
 502 /**
 503   Builds a Capsule Volume HOB.
 504
 505   This function builds a Capsule Volume HOB.
 506   It can only be invoked during PEI phase;
 507   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 508
 509   If the platform does not support Capsule Volume HOBs, then ASSERT().
 510   If there is no additional space for HOB creation, then ASSERT().
 511
 512   @param  BaseAddress   The base address of the Capsule Volume.
 513   @param  Length        The size of the Capsule Volume in bytes.
 514
 515 **/
 516 VOID
 517 EFIAPI
 518 BuildCvHob (
 519   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 520   IN UINT64                      Length
 521   )
 522 {
 523   EFI_HOB_UEFI_CAPSULE  *Hob;
 524
 525   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_UEFI_CAPSULE, (UINT16) sizeof (EFI_HOB_UEFI_CAPSULE));
 526   if (Hob == NULL) {
 527     return;
 528   }
 529
 530   Hob->BaseAddress  = BaseAddress;
 531   Hob->Length       = Length;
 532 }
 533
 534 /**
 535   Builds a HOB for the CPU.
 536
 537   This function builds a HOB for the CPU.
 538   It can only be invoked during PEI phase;
 539   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 540
 541   If there is no additional space for HOB creation, then ASSERT().
 542
 543   @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.
 544   @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.
 545
 546 **/
 547 VOID
 548 EFIAPI
 549 BuildCpuHob (
 550   IN UINT8                       SizeOfMemorySpace,
 551   IN UINT8                       SizeOfIoSpace
 552   )
 553 {
 554   EFI_HOB_CPU  *Hob;
 555
 556   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_CPU, (UINT16) sizeof (EFI_HOB_CPU));
 557   if (Hob == NULL) {
 558     return;
 559   }
 560
 561   Hob->SizeOfMemorySpace = SizeOfMemorySpace;
 562   Hob->SizeOfIoSpace     = SizeOfIoSpace;
 563
 564   //
 565   // Zero the reserved space to match HOB spec
 566   //
 567   ZeroMem (Hob->Reserved, sizeof (Hob->Reserved));
 568 }
 569
 570 /**
 571   Builds a HOB for the Stack.
 572
 573   This function builds a HOB for the stack.
 574   It can only be invoked during PEI phase;
 575   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 576
 577   If there is no additional space for HOB creation, then ASSERT().
 578
 579   @param  BaseAddress   The 64 bit physical address of the Stack.
 580   @param  Length        The length of the stack in bytes.
 581
 582 **/
 583 VOID
 584 EFIAPI
 585 BuildStackHob (
 586   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 587   IN UINT64                      Length
 588   )
 589 {
 590   EFI_HOB_MEMORY_ALLOCATION_STACK  *Hob;
 591
 592   ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
 593           ((Length & (EFI_PAGE_SIZE - 1)) == 0));
 594
 595   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION_STACK));
 596   if (Hob == NULL) {
 597     return;
 598   }
 599
 600   CopyGuid (&(Hob->AllocDescriptor.Name), &gEfiHobMemoryAllocStackGuid);
 601   Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
 602   Hob->AllocDescriptor.MemoryLength      = Length;
 603   Hob->AllocDescriptor.MemoryType        = EfiBootServicesData;
 604
 605   //
 606   // Zero the reserved space to match HOB spec
 607   //
 608   ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
 609 }
 610
 611 /**
 612   Builds a HOB for the BSP store.
 613
 614   This function builds a HOB for BSP store.
 615   It can only be invoked during PEI phase;
 616   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 617
 618   If there is no additional space for HOB creation, then ASSERT().
 619
 620   @param  BaseAddress   The 64 bit physical address of the BSP.
 621   @param  Length        The length of the BSP store in bytes.
 622   @param  MemoryType    The type of memory allocated by this HOB.
 623
 624 **/
 625 VOID
 626 EFIAPI
 627 BuildBspStoreHob (
 628   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 629   IN UINT64                      Length,
 630   IN EFI_MEMORY_TYPE             MemoryType
 631   )
 632 {
 633   EFI_HOB_MEMORY_ALLOCATION_BSP_STORE  *Hob;
 634
 635   ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
 636           ((Length & (EFI_PAGE_SIZE - 1)) == 0));
 637
 638   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION_BSP_STORE));
 639   if (Hob == NULL) {
 640     return;
 641   }
 642
 643   CopyGuid (&(Hob->AllocDescriptor.Name), &gEfiHobMemoryAllocBspStoreGuid);
 644   Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
 645   Hob->AllocDescriptor.MemoryLength      = Length;
 646   Hob->AllocDescriptor.MemoryType        = MemoryType;
 647
 648   //
 649   // Zero the reserved space to match HOB spec
 650   //
 651   ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
 652 }
 653
 654 /**
 655   Builds a HOB for the memory allocation.
 656
 657   This function builds a HOB for the memory allocation.
 658   It can only be invoked during PEI phase;
 659   for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
 660
 661   If there is no additional space for HOB creation, then ASSERT().
 662
 663   @param  BaseAddress   The 64 bit physical address of the memory.
 664   @param  Length        The length of the memory allocation in bytes.
 665   @param  MemoryType    The type of memory allocated by this HOB.
 666
 667 **/
 668 VOID
 669 EFIAPI
 670 BuildMemoryAllocationHob (
 671   IN EFI_PHYSICAL_ADDRESS        BaseAddress,
 672   IN UINT64                      Length,
 673   IN EFI_MEMORY_TYPE             MemoryType
 674   )
 675 {
 676   EFI_HOB_MEMORY_ALLOCATION  *Hob;
 677
 678   ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
 679           ((Length & (EFI_PAGE_SIZE - 1)) == 0));
 680
 681   Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION));
 682   if (Hob == NULL) {
 683     return;
 684   }
 685
 686   ZeroMem (&(Hob->AllocDescriptor.Name), sizeof (EFI_GUID));
 687   Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
 688   Hob->AllocDescriptor.MemoryLength      = Length;
 689   Hob->AllocDescriptor.MemoryType        = MemoryType;
 690   //
 691   // Zero the reserved space to match HOB spec
 692   //
 693   ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
 694 }