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