Tools/Conf/Migration/R8Lib.c

   1 /** @file
   2   Obsolete library.
   3
   4   Copyright (c) 2006, Intel Corporation
   5   All rights reserved. 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 ////
  16 EFI_STATUS
  17 R8_EfiLibInstallDriverBinding (
  18   IN EFI_HANDLE                   ImageHandle,
  19   IN EFI_SYSTEM_TABLE             *SystemTable,
  20   IN EFI_DRIVER_BINDING_PROTOCOL  *DriverBinding,
  21   IN EFI_HANDLE                   DriverBindingHandle
  22   )
  23 /*++
  24
  25 Routine Description:
  26
  27   Intialize a driver by installing the Driver Binding Protocol onto the
  28   driver's DriverBindingHandle.  This is typically the same as the driver's
  29   ImageHandle, but it can be different if the driver produces multiple
  30   DriverBinding Protocols.  This function also initializes the EFI Driver
  31   Library that initializes the global variables gST, gBS, gRT.
  32
  33 Arguments:
  34
  35   ImageHandle         - The image handle of the driver
  36
  37   SystemTable         - The EFI System Table that was passed to the driver's entry point
  38
  39   DriverBinding       - A Driver Binding Protocol instance that this driver is producing
  40
  41   DriverBindingHandle - The handle that DriverBinding is to be installe onto.  If this
  42                         parameter is NULL, then a new handle is created.
  43
  44 Returns:
  45
  46   EFI_SUCCESS is DriverBinding is installed onto DriverBindingHandle
  47
  48   Otherwise, then return status from gBS->InstallProtocolInterface()
  49
  50 --*/
  51 {
  52   //EfiInitializeDriverLib (ImageHandle, SystemTable);
  53
  54   DriverBinding->ImageHandle          = ImageHandle;
  55
  56   DriverBinding->DriverBindingHandle  = DriverBindingHandle;
  57
  58   return gBS->InstallProtocolInterface (
  59                 &DriverBinding->DriverBindingHandle,
  60                 &gEfiDriverBindingProtocolGuid,
  61                 EFI_NATIVE_INTERFACE,
  62                 DriverBinding
  63                 );
  64 }
  65 ////~
  66
  67 ////
  68 EFI_STATUS
  69 R8_EfiLibInstallAllDriverProtocols (
  70   IN EFI_HANDLE                         ImageHandle,
  71   IN EFI_SYSTEM_TABLE                   * SystemTable,
  72   IN EFI_DRIVER_BINDING_PROTOCOL        * DriverBinding,
  73   IN EFI_HANDLE                         DriverBindingHandle,
  74   IN EFI_COMPONENT_NAME_PROTOCOL        * ComponentName, OPTIONAL
  75   IN EFI_DRIVER_CONFIGURATION_PROTOCOL  * DriverConfiguration, OPTIONAL
  76   IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL    * DriverDiagnostics OPTIONAL
  77   )
  78 /*++
  79
  80 Routine Description:
  81
  82   Intialize a driver by installing the Driver Binding Protocol onto the
  83   driver's DriverBindingHandle.  This is typically the same as the driver's
  84   ImageHandle, but it can be different if the driver produces multiple
  85   DriverBinding Protocols.  This function also initializes the EFI Driver
  86   Library that initializes the global variables gST, gBS, gRT.
  87
  88 Arguments:
  89
  90   ImageHandle         - The image handle of the driver
  91
  92   SystemTable         - The EFI System Table that was passed to the driver's entry point
  93
  94   DriverBinding       - A Driver Binding Protocol instance that this driver is producing
  95
  96   DriverBindingHandle - The handle that DriverBinding is to be installe onto.  If this
  97                         parameter is NULL, then a new handle is created.
  98
  99   ComponentName       - A Component Name Protocol instance that this driver is producing
 100
 101   DriverConfiguration - A Driver Configuration Protocol instance that this driver is producing
 102
 103   DriverDiagnostics   - A Driver Diagnostics Protocol instance that this driver is producing
 104
 105 Returns:
 106
 107   EFI_SUCCESS if all the protocols were installed onto DriverBindingHandle
 108
 109   Otherwise, then return status from gBS->InstallProtocolInterface()
 110
 111 --*/
 112 {
 113   EFI_STATUS  Status;
 114
 115   Status = R8_EfiLibInstallDriverBinding (ImageHandle, SystemTable, DriverBinding, DriverBindingHandle);
 116   if (EFI_ERROR (Status)) {
 117     return Status;
 118   }
 119
 120   if (ComponentName != NULL) {
 121     Status = gBS->InstallProtocolInterface (
 122                     &DriverBinding->DriverBindingHandle,
 123                     &gEfiComponentNameProtocolGuid,
 124                     EFI_NATIVE_INTERFACE,
 125                     ComponentName
 126                     );
 127     if (EFI_ERROR (Status)) {
 128       return Status;
 129     }
 130   }
 131
 132   if (DriverConfiguration != NULL) {
 133     Status = gBS->InstallProtocolInterface (
 134                     &DriverBinding->DriverBindingHandle,
 135                     &gEfiDriverConfigurationProtocolGuid,
 136                     EFI_NATIVE_INTERFACE,
 137                     DriverConfiguration
 138                     );
 139     if (EFI_ERROR (Status)) {
 140       return Status;
 141     }
 142   }
 143
 144   if (DriverDiagnostics != NULL) {
 145     Status = gBS->InstallProtocolInterface (
 146                     &DriverBinding->DriverBindingHandle,
 147                     &gEfiDriverDiagnosticsProtocolGuid,
 148                     EFI_NATIVE_INTERFACE,
 149                     DriverDiagnostics
 150                     );
 151     if (EFI_ERROR (Status)) {
 152       return Status;
 153     }
 154   }
 155
 156   return EFI_SUCCESS;
 157 }
 158 ////~
 159
 160 ////
 161 BOOLEAN
 162 R8_EfiLibCompareLanguage (
 163   IN  CHAR8  *Language1,
 164   IN  CHAR8  *Language2
 165   )
 166 /*++
 167
 168 Routine Description:
 169
 170   Compare whether two names of languages are identical.
 171
 172 Arguments:
 173
 174   Language1 - Name of language 1
 175   Language2 - Name of language 2
 176
 177 Returns:
 178
 179   TRUE      - same
 180   FALSE     - not same
 181
 182 --*/
 183 {
 184   UINTN Index;
 185
 186   for (Index = 0; Index < 3; Index++) {
 187     if (Language1[Index] != Language2[Index]) {
 188       return FALSE;
 189     }
 190   }
 191
 192   return TRUE;
 193 }
 194 ////~
 195
 196 ////#BaseLib
 197 EFI_STATUS
 198 R8_BufToHexString (
 199   IN OUT CHAR16                    *Str,
 200   IN OUT UINTN                     *HexStringBufferLength,
 201   IN     UINT8                     *Buf,
 202   IN     UINTN                      Len
 203   )
 204 /*++
 205
 206   Routine Description:
 207     Converts binary buffer to Unicode string.
 208     At a minimum, any blob of data could be represented as a hex string.
 209
 210   Arguments:
 211     Str - Pointer to the string.
 212     HexStringBufferLength - Length in bytes of buffer to hold the hex string. Includes tailing '\0' character.
 213                                         If routine return with EFI_SUCCESS, containing length of hex string buffer.
 214                                         If routine return with EFI_BUFFER_TOO_SMALL, containg length of hex string buffer desired.
 215     Buf - Buffer to be converted from.
 216     Len - Length in bytes of the buffer to be converted.
 217
 218   Returns:
 219     EFI_SUCCESS: Routine success.
 220     EFI_BUFFER_TOO_SMALL: The hex string buffer is too small.
 221
 222 --*/
 223 {
 224   UINTN       Idx;
 225   UINT8       Byte;
 226   UINTN       StrLen;
 227
 228   //
 229   // Make sure string is either passed or allocate enough.
 230   // It takes 2 Unicode characters (4 bytes) to represent 1 byte of the binary buffer.
 231   // Plus the Unicode termination character.
 232   //
 233   StrLen = Len * 2;
 234   if (StrLen > ((*HexStringBufferLength) - 1)) {
 235     *HexStringBufferLength = StrLen + 1;
 236     return EFI_BUFFER_TOO_SMALL;
 237   }
 238
 239   *HexStringBufferLength = StrLen + 1;
 240   //
 241   // Ends the string.
 242   //
 243   Str[StrLen] = L'\0';
 244
 245   for (Idx = 0; Idx < Len; Idx++) {
 246
 247     Byte = Buf[Idx];
 248     Str[StrLen - 1 - Idx * 2] = NibbleToHexChar (Byte);
 249     Str[StrLen - 2 - Idx * 2] = NibbleToHexChar ((UINT8)(Byte >> 4));
 250   }
 251
 252   return EFI_SUCCESS;
 253 }
 254 ////~
 255
 256 ////
 257 VOID
 258 R8_EfiStrTrim (
 259   IN OUT CHAR16   *str,
 260   IN     CHAR16   CharC
 261   )
 262 /*++
 263
 264 Routine Description:
 265
 266   Removes (trims) specified leading and trailing characters from a string.
 267
 268 Arguments:
 269
 270   str     - Pointer to the null-terminated string to be trimmed. On return,
 271             str will hold the trimmed string.
 272   CharC       - Character will be trimmed from str.
 273
 274 Returns:
 275
 276 --*/
 277 {
 278   CHAR16  *p1;
 279   CHAR16  *p2;
 280
 281   if (*str == 0) {
 282     return;
 283   }
 284
 285   //
 286   // Trim off the leading and trailing characters c
 287   //
 288   for (p1 = str; *p1 && *p1 == CharC; p1++) {
 289     ;
 290   }
 291
 292   p2 = str;
 293   if (p2 == p1) {
 294     while (*p1) {
 295       p2++;
 296       p1++;
 297     }
 298   } else {
 299     while (*p1) {
 300     *p2 = *p1;
 301     p1++;
 302     p2++;
 303     }
 304     *p2 = 0;
 305   }
 306
 307
 308   for (p1 = str + StrLen(str) - 1; p1 >= str && *p1 == CharC; p1--) {
 309     ;
 310   }
 311   if  (p1 !=  str + StrLen(str) - 1) {
 312     *(p1 + 1) = 0;
 313   }
 314 }
 315 ////~
 316
 317 ////#PrintLib
 318 UINTN
 319 R8_EfiValueToHexStr (
 320   IN  OUT CHAR16  *Buffer,
 321   IN  UINT64      Value,
 322   IN  UINTN       Flags,
 323   IN  UINTN       Width
 324   )
 325 /*++
 326
 327 Routine Description:
 328
 329   VSPrint worker function that prints a Value as a hex number in Buffer
 330
 331 Arguments:
 332
 333   Buffer - Location to place ascii hex string of Value.
 334
 335   Value  - Hex value to convert to a string in Buffer.
 336
 337   Flags  - Flags to use in printing Hex string, see file header for details.
 338
 339   Width  - Width of hex value.
 340
 341 Returns:
 342
 343   Number of characters printed.
 344
 345 --*/
 346 {
 347   CHAR16  TempBuffer[MAXIMUM_VALUE_CHARACTERS];
 348   CHAR16  *TempStr;
 349   CHAR16  Prefix;
 350   CHAR16  *BufferPtr;
 351   UINTN   Count;
 352   UINTN   Index;
 353
 354   TempStr = TempBuffer;
 355   BufferPtr = Buffer;
 356
 357   //
 358   // Count starts at one since we will null terminate. Each iteration of the
 359   // loop picks off one nibble. Oh yea TempStr ends up backwards
 360   //
 361   Count = 0;
 362
 363   if (Width > MAXIMUM_VALUE_CHARACTERS - 1) {
 364     Width = MAXIMUM_VALUE_CHARACTERS - 1;
 365   }
 366
 367   do {
 368     //
 369     // If Width == 0, it means no limit.
 370     //
 371     if ((Width != 0) && (Count >= Width)) {
 372       break;
 373     }
 374
 375     Index = ((UINTN)Value & 0xf);
 376     *(TempStr++) = mHexStr[Index];
 377     Value = RShiftU64 (Value, 4);
 378     Count++;
 379   } while (Value != 0);
 380
 381   if (Flags & PREFIX_ZERO) {
 382     Prefix = '0';
 383   } else {
 384     Prefix = ' ';
 385   }
 386
 387   Index = Count;
 388   if (!(Flags & LEFT_JUSTIFY)) {
 389     for (; Index < Width; Index++) {
 390       *(TempStr++) = Prefix;
 391     }
 392   }
 393
 394   //
 395   // Reverse temp string into Buffer.
 396   //
 397   while (TempStr != TempBuffer) {
 398     *(BufferPtr++) = *(--TempStr);
 399   }
 400
 401   *BufferPtr = 0;
 402   return Index;
 403 }
 404 ////~
 405
 406
 407
 408 ////
 409 EFI_STATUS
 410 R8_HexStringToBuf (
 411   IN OUT UINT8                     *Buf,
 412   IN OUT UINTN                    *Len,
 413   IN     CHAR16                    *Str,
 414   OUT    UINTN                     *ConvertedStrLen  OPTIONAL
 415   )
 416 /*++
 417
 418   Routine Description:
 419     Converts Unicode string to binary buffer.
 420     The conversion may be partial.
 421     The first character in the string that is not hex digit stops the conversion.
 422     At a minimum, any blob of data could be represented as a hex string.
 423
 424   Arguments:
 425     Buf    - Pointer to buffer that receives the data.
 426     Len    - Length in bytes of the buffer to hold converted data.
 427                 If routine return with EFI_SUCCESS, containing length of converted data.
 428                 If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
 429     Str    - String to be converted from.
 430     ConvertedStrLen - Length of the Hex String consumed.
 431
 432   Returns:
 433     EFI_SUCCESS: Routine Success.
 434     EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
 435     EFI_
 436
 437 --*/
 438 {
 439   UINTN       HexCnt;
 440   UINTN       Idx;
 441   UINTN       BufferLength;
 442   UINT8       Digit;
 443   UINT8       Byte;
 444
 445   //
 446   // Find out how many hex characters the string has.
 447   //
 448   for (Idx = 0, HexCnt = 0; IsHexDigit (&Digit, Str[Idx]); Idx++, HexCnt++);
 449
 450   if (HexCnt == 0) {
 451     *Len = 0;
 452     return EFI_SUCCESS;
 453   }
 454   //
 455   // Two Unicode characters make up 1 buffer byte. Round up.
 456   //
 457   BufferLength = (HexCnt + 1) / 2;
 458
 459   //
 460   // Test if  buffer is passed enough.
 461   //
 462   if (BufferLength > (*Len)) {
 463     *Len = BufferLength;
 464     return EFI_BUFFER_TOO_SMALL;
 465   }
 466
 467   *Len = BufferLength;
 468
 469   for (Idx = 0; Idx < HexCnt; Idx++) {
 470
 471     IsHexDigit (&Digit, Str[HexCnt - 1 - Idx]);
 472
 473     //
 474     // For odd charaters, write the lower nibble for each buffer byte,
 475     // and for even characters, the upper nibble.
 476     //
 477     if ((Idx & 1) == 0) {
 478       Byte = Digit;
 479     } else {
 480       Byte = Buf[Idx / 2];
 481       Byte &= 0x0F;
 482       Byte |= Digit << 4;
 483     }
 484
 485     Buf[Idx / 2] = Byte;
 486   }
 487
 488   if (ConvertedStrLen != NULL) {
 489     *ConvertedStrLen = HexCnt;
 490   }
 491
 492   return EFI_SUCCESS;
 493 }
 494 ////~
 495
 496 ////
 497 BOOLEAN
 498 R8_IsHexDigit (
 499   OUT UINT8      *Digit,
 500   IN  CHAR16      Char
 501   )
 502 /*++
 503
 504   Routine Description:
 505     Determines if a Unicode character is a hexadecimal digit.
 506     The test is case insensitive.
 507
 508   Arguments:
 509     Digit - Pointer to byte that receives the value of the hex character.
 510     Char  - Unicode character to test.
 511
 512   Returns:
 513     TRUE  - If the character is a hexadecimal digit.
 514     FALSE - Otherwise.
 515
 516 --*/
 517 {
 518   if ((Char >= L'0') && (Char <= L'9')) {
 519     *Digit = (UINT8) (Char - L'0');
 520     return TRUE;
 521   }
 522
 523   if ((Char >= L'A') && (Char <= L'F')) {
 524     *Digit = (UINT8) (Char - L'A' + 0x0A);
 525     return TRUE;
 526   }
 527
 528   if ((Char >= L'a') && (Char <= L'f')) {
 529     *Digit = (UINT8) (Char - L'a' + 0x0A);
 530     return TRUE;
 531   }
 532
 533   return FALSE;
 534 }
 535 ////~
 536
 537 ////
 538 CHAR16
 539 R8_NibbleToHexChar (
 540   IN UINT8      Nibble
 541   )
 542 /*++
 543
 544   Routine Description:
 545     Converts the low nibble of a byte  to hex unicode character.
 546
 547   Arguments:
 548     Nibble - lower nibble of a byte.
 549
 550   Returns:
 551     Hex unicode character.
 552
 553 --*/
 554 {
 555   Nibble &= 0x0F;
 556   if (Nibble <= 0x9) {
 557     return (CHAR16)(Nibble + L'0');
 558   }
 559
 560   return (CHAR16)(Nibble - 0xA + L'A');
 561 }
 562 ////~
 563
 564 ////#HobLib
 565 VOID *
 566 R8_GetHob (
 567   IN UINT16  Type,
 568   IN VOID    *HobStart
 569   )
 570 /*++
 571
 572 Routine Description:
 573
 574   This function returns the first instance of a HOB type in a HOB list.
 575
 576 Arguments:
 577
 578   Type          The HOB type to return.
 579   HobStart      The first HOB in the HOB list.
 580
 581 Returns:
 582
 583   HobStart      There were no HOBs found with the requested type.
 584   else          Returns the first HOB with the matching type.
 585
 586 --*/
 587 {
 588   VOID    *Hob;
 589   //
 590   // Return input if not found
 591   //
 592   if (HobStart == NULL) {
 593     return HobStart;
 594   }
 595   Hob = GetNextHob (Type, HobStart);
 596   if (Hob == NULL) {
 597     return HobStart;
 598   }
 599
 600   return Hob;
 601 }
 602 ////~
 603
 604 ////
 605 UINTN
 606 R8_GetHobListSize (
 607   IN VOID  *HobStart
 608   )
 609 /*++
 610
 611 Routine Description:
 612
 613   Get size of hob list.
 614
 615 Arguments:
 616
 617   HobStart      - Start pointer of hob list
 618
 619 Returns:
 620
 621   Size of hob list.
 622
 623 --*/
 624 {
 625   EFI_PEI_HOB_POINTERS  Hob;
 626   UINTN                 Size;
 627
 628   Hob.Raw = HobStart;
 629   Size    = 0;
 630
 631   while (Hob.Header->HobType != EFI_HOB_TYPE_END_OF_HOB_LIST) {
 632     Size += Hob.Header->HobLength;
 633     Hob.Raw += Hob.Header->HobLength;
 634   }
 635
 636   Size += Hob.Header->HobLength;
 637
 638   return Size;
 639 }
 640 ////~
 641
 642 ////
 643 UINT32
 644 R8_GetHobVersion (
 645   IN VOID  *HobStart
 646   )
 647 /*++
 648
 649 Routine Description:
 650
 651   Get hob version.
 652
 653 Arguments:
 654
 655   HobStart      - Start pointer of hob list
 656
 657 Returns:
 658
 659   Hob version.
 660
 661 --*/
 662 {
 663   EFI_PEI_HOB_POINTERS  Hob;
 664
 665   Hob.Raw = HobStart;
 666   return Hob.HandoffInformationTable->Version;
 667 }
 668 ////~
 669
 670 ////
 671 EFI_STATUS
 672 R8_GetHobBootMode (
 673   IN  VOID           *HobStart,
 674   OUT EFI_BOOT_MODE  *BootMode
 675   )
 676 /*++
 677
 678 Routine Description:
 679
 680   Get current boot mode.
 681
 682 Arguments:
 683
 684   HobStart      - Start pointer of hob list
 685
 686   BootMode      - Current boot mode recorded in PHIT hob
 687
 688 Returns:
 689
 690   EFI_NOT_FOUND     - Invalid hob header
 691
 692   EFI_SUCCESS       - Boot mode found
 693
 694 --*/
 695 {
 696   EFI_PEI_HOB_POINTERS  Hob;
 697
 698   Hob.Raw = HobStart;
 699   if (Hob.Header->HobType != EFI_HOB_TYPE_HANDOFF) {
 700     return EFI_NOT_FOUND;
 701   }
 702
 703   *BootMode = Hob.HandoffInformationTable->BootMode;
 704   return EFI_SUCCESS;
 705 }
 706 ////~
 707
 708
 709 ////#HobLib
 710 EFI_STATUS
 711 R8_GetCpuHobInfo (
 712   IN  VOID   *HobStart,
 713   OUT UINT8  *SizeOfMemorySpace,
 714   OUT UINT8  *SizeOfIoSpace
 715   )
 716 /*++
 717
 718 Routine Description:
 719
 720   Get information recorded in CPU hob (Memory space size, Io space size)
 721
 722 Arguments:
 723
 724   HobStart            - Start pointer of hob list
 725
 726   SizeOfMemorySpace   - Size of memory size
 727
 728   SizeOfIoSpace       - Size of IO size
 729
 730 Returns:
 731
 732   EFI_NOT_FOUND     - CPU hob not found
 733
 734   EFI_SUCCESS       - CPU hob found and information got.
 735
 736 --*/
 737 {
 738   EFI_HOB_CPU  *CpuHob;
 739
 740   CpuHob = GetHob (EFI_HOB_TYPE_CPU, HobStart);
 741   if (CpuHob == NULL) {
 742     return EFI_NOT_FOUND;
 743   }
 744
 745   *SizeOfMemorySpace  = CpuHob->SizeOfMemorySpace;
 746   *SizeOfIoSpace      = CpuHob->SizeOfIoSpace;
 747   return EFI_SUCCESS;
 748 }
 749 ////~
 750
 751 ////#HobLib
 752 EFI_STATUS
 753 R8_GetDxeCoreHobInfo (
 754   IN  VOID                  *HobStart,
 755   OUT EFI_PHYSICAL_ADDRESS  *BaseAddress,
 756   OUT UINT64                *Length,
 757   OUT VOID                  **EntryPoint,
 758   OUT EFI_GUID              **FileName
 759   )
 760 /*++
 761
 762 Routine Description:
 763
 764   Get memory allocation hob created for DXE core and extract its information
 765
 766 Arguments:
 767
 768   HobStart        - Start pointer of the hob list
 769   BaseAddress     - Start address of memory allocated for DXE core
 770   Length          - Length of memory allocated for DXE core
 771   EntryPoint      - DXE core file name
 772   FileName        - File Name
 773
 774 Returns:
 775
 776   EFI_NOT_FOUND   - DxeCoreHob not found
 777   EFI_SUCCESS     - DxeCoreHob found and information got
 778
 779 --*/
 780 {
 781   EFI_PEI_HOB_POINTERS  DxeCoreHob;
 782
 783   DxeCoreHob.Raw  = HobStart;
 784   DxeCoreHob.Raw  = GetHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, DxeCoreHob.Raw);
 785   while (DxeCoreHob.Header->HobType == EFI_HOB_TYPE_MEMORY_ALLOCATION &&
 786          !EfiCompareGuid (&DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.Name,
 787                           &gEfiHobMemeryAllocModuleGuid)) {
 788
 789     DxeCoreHob.Raw  = GET_NEXT_HOB (DxeCoreHob);
 790     DxeCoreHob.Raw  = GetHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, DxeCoreHob.Raw);
 791
 792   }
 793
 794   if (DxeCoreHob.Header->HobType != EFI_HOB_TYPE_MEMORY_ALLOCATION) {
 795     return EFI_NOT_FOUND;
 796   }
 797
 798   *BaseAddress  = DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.MemoryBaseAddress;
 799   *Length       = DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.MemoryLength;
 800   *EntryPoint   = (VOID *) (UINTN) DxeCoreHob.MemoryAllocationModule->EntryPoint;
 801   *FileName     = &DxeCoreHob.MemoryAllocationModule->ModuleName;
 802
 803   return EFI_SUCCESS;
 804 }
 805 ////~
 806
 807 ////#HobLib
 808 EFI_STATUS
 809 R8_GetNextFirmwareVolumeHob (
 810   IN OUT VOID                  **HobStart,
 811   OUT    EFI_PHYSICAL_ADDRESS  *BaseAddress,
 812   OUT    UINT64                *Length
 813   )
 814 /*++
 815
 816 Routine Description:
 817
 818   Get next firmware volume hob from HobStart
 819
 820 Arguments:
 821
 822   HobStart        - Start pointer of hob list
 823
 824   BaseAddress     - Start address of next firmware volume
 825
 826   Length          - Length of next firmware volume
 827
 828 Returns:
 829
 830   EFI_NOT_FOUND   - Next firmware volume not found
 831
 832   EFI_SUCCESS     - Next firmware volume found with address information
 833
 834 --*/
 835 {
 836   EFI_PEI_HOB_POINTERS  FirmwareVolumeHob;
 837
 838   FirmwareVolumeHob.Raw = GetNextHob (EFI_HOB_TYPE_FV, *HobStart);
 839   if (FirmwareVolumeHob.Raw != NULL) {
 840     return EFI_NOT_FOUND;
 841   }
 842
 843   *BaseAddress  = FirmwareVolumeHob.FirmwareVolume->BaseAddress;
 844   *Length       = FirmwareVolumeHob.FirmwareVolume->Length;
 845
 846   *HobStart     = GET_NEXT_HOB (FirmwareVolumeHob);
 847
 848   return EFI_SUCCESS;
 849 }
 850 ////~
 851
 852 ////#HobLib
 853 EFI_STATUS
 854 R8_GetNextGuidHob (
 855   IN OUT VOID      **HobStart,
 856   IN     EFI_GUID  * Guid,
 857   OUT    VOID      **Buffer,
 858   OUT    UINTN     *BufferSize OPTIONAL
 859   )
 860 /*++
 861
 862 Routine Description:
 863   Get the next guid hob.
 864
 865 Arguments:
 866   HobStart        A pointer to the start hob.
 867   Guid            A pointer to a guid.
 868   Buffer          A pointer to the buffer.
 869   BufferSize      Buffer size.
 870
 871 Returns:
 872   Status code.
 873
 874   EFI_NOT_FOUND          - Next Guid hob not found
 875
 876   EFI_SUCCESS            - Next Guid hob found and data for this Guid got
 877
 878   EFI_INVALID_PARAMETER  - invalid parameter
 879
 880 --*/
 881 {
 882   EFI_PEI_HOB_POINTERS  GuidHob;
 883
 884   if (Buffer == NULL) {
 885     return EFI_INVALID_PARAMETER;
 886   }
 887
 888   GuidHob.Raw = GetNextGuidHob (Guid, *HobStart);
 889   if (GuidHob == NULL) {
 890     return EFI_NOT_FOUND;
 891   }
 892
 893   *Buffer = GET_GUID_HOB_DATA (GuidHob.Guid);
 894   if (BufferSize != NULL) {
 895     *BufferSize = GET_GUID_HOB_DATA_SIZE (GuidHob.Guid);
 896   }
 897
 898   *HobStart = GET_NEXT_HOB (GuidHob);
 899
 900   return EFI_SUCCESS;
 901 }
 902 ////~
 903
 904 ////#HobLib
 905 EFI_STATUS
 906 R8_GetPalEntryHobInfo (
 907   IN  VOID                  *HobStart,
 908   OUT EFI_PHYSICAL_ADDRESS  *PalEntry
 909   )
 910 /*++
 911
 912 Routine Description:
 913
 914   Get PAL entry from PalEntryHob
 915
 916 Arguments:
 917
 918   HobStart      - Start pointer of hob list
 919
 920   PalEntry      - Pointer to PAL entry
 921
 922 Returns:
 923
 924   Status code.
 925
 926 --*/
 927 {
 928   EFI_HOB_GUID_TYPE   *GuidHob;
 929
 930   GuidHob = GetNextGuidHob (&gPalEntryHob, HobStart);
 931
 932   if (GuidHob == NULL) {
 933     return EFI_NOT_FOUND;
 934   }
 935
 936   *PalEntry = *((EFI_PHYSICAL_ADDRESS *) GET_GUID_HOB_DATA (GuidHob));
 937   return EFI_SUCCESS;
 938 }
 939 ////~
 940
 941 ////#HobLib
 942 EFI_STATUS
 943 R8_GetIoPortSpaceAddressHobInfo (
 944   IN  VOID                  *HobStart,
 945   OUT EFI_PHYSICAL_ADDRESS  *IoPortSpaceAddress
 946   )
 947 /*++
 948
 949 Routine Description:
 950
 951   Get IO port space address from IoBaseHob.
 952
 953 Arguments:
 954
 955   HobStart              - Start pointer of hob list
 956
 957   IoPortSpaceAddress    - IO port space address
 958
 959 Returns:
 960
 961   Status code
 962
 963 --*/
 964 {
 965   EFI_HOB_GUID_TYPE   *GuidHob;
 966
 967   GuidHob = GetNextGuidHob (&gEfiIoBaseHobGuid, HobStart);
 968
 969   if (GuidHob == NULL) {
 970     return EFI_NOT_FOUND;
 971   }
 972
 973   *IoPortSpaceAddress = *((EFI_PHYSICAL_ADDRESS *) GET_GUID_HOB_DATA (GuidHob));
 974   return EFI_SUCCESS;
 975 }
 976 ////~
 977