CorebootModulePkg/Library/CbParseLib/CbParseLib.c

   1 /** @file
   2   This library will parse the coreboot table in memory and extract those required
   3   information.
   4
   5   Copyright (c) 2014 - 2016, Intel Corporation. All rights reserved.<BR>
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include <Uefi/UefiBaseType.h>
  17 #include <Library/BaseLib.h>
  18 #include <Library/BaseMemoryLib.h>
  19 #include <Library/DebugLib.h>
  20 #include <Library/PcdLib.h>
  21 #include <Library/CbParseLib.h>
  22
  23 #include <IndustryStandard/Acpi.h>
  24
  25 #include "Coreboot.h"
  26
  27
  28 /**
  29   Convert a packed value from cbuint64 to a UINT64 value.
  30
  31   @param  val      The pointer to packed data.
  32
  33   @return          the UNIT64 value after convertion.
  34
  35 **/
  36 UINT64
  37 cb_unpack64 (
  38   IN struct cbuint64 val
  39   )
  40 {
  41   return LShiftU64 (val.hi, 32) | val.lo;
  42 }
  43
  44
  45 /**
  46   Returns the sum of all elements in a buffer of 16-bit values.  During
  47   calculation, the carry bits are also been added.
  48
  49   @param  Buffer      The pointer to the buffer to carry out the sum operation.
  50   @param  Length      The size, in bytes, of Buffer.
  51
  52   @return Sum         The sum of Buffer with carry bits included during additions.
  53
  54 **/
  55 UINT16
  56 CbCheckSum16 (
  57   IN UINT16   *Buffer,
  58   IN UINTN    Length
  59   )
  60 {
  61   UINT32 Sum, TmpValue;
  62   UINTN  Idx;
  63   UINT8  *TmpPtr;
  64
  65   Sum = 0;
  66   TmpPtr = (UINT8 *)Buffer;
  67   for(Idx = 0; Idx < Length; Idx++) {
  68     TmpValue  = TmpPtr[Idx];
  69     if (Idx % 2 == 1) {
  70       TmpValue <<= 8;
  71     }
  72
  73     Sum += TmpValue;
  74
  75     // Wrap
  76     if (Sum >= 0x10000) {
  77       Sum = (Sum + (Sum >> 16)) & 0xFFFF;
  78     }
  79   }
  80
  81   return (UINT16)((~Sum) & 0xFFFF);
  82 }
  83
  84
  85 /**
  86   Find coreboot record with given Tag from the memory Start in 4096
  87   bytes range.
  88
  89   @param  Start              The start memory to be searched in
  90   @param  Tag                The tag id to be found
  91
  92   @retval NULL              The Tag is not found.
  93   @retval Others            The poiter to the record found.
  94
  95 **/
  96 VOID *
  97 EFIAPI
  98 FindCbTag (
  99   IN  VOID     *Start,
 100   IN  UINT32   Tag
 101   )
 102 {
 103   struct cb_header   *Header;
 104   struct cb_record   *Record;
 105   UINT8              *TmpPtr;
 106   UINT8              *TagPtr;
 107   UINTN              Idx;
 108   UINT16             CheckSum;
 109
 110   Header = NULL;
 111   TmpPtr = (UINT8 *)Start;
 112   for (Idx = 0; Idx < 4096; Idx += 16, TmpPtr += 16) {
 113     Header = (struct cb_header *)TmpPtr;
 114     if (Header->signature == CB_HEADER_SIGNATURE) {
 115       break;
 116     }
 117   }
 118
 119   if (Idx >= 4096) {
 120     return NULL;
 121   }
 122
 123   if ((Header == NULL) || (Header->table_bytes == 0)) {
 124     return NULL;
 125   }
 126
 127   //
 128   // Check the checksum of the coreboot table header
 129   //
 130   CheckSum = CbCheckSum16 ((UINT16 *)Header, sizeof (*Header));
 131   if (CheckSum != 0) {
 132     DEBUG ((EFI_D_ERROR, "Invalid coreboot table header checksum\n"));
 133     return NULL;
 134   }
 135
 136   CheckSum = CbCheckSum16 ((UINT16 *)(TmpPtr + sizeof (*Header)), Header->table_bytes);
 137   if (CheckSum != Header->table_checksum) {
 138     DEBUG ((EFI_D_ERROR, "Incorrect checksum of all the coreboot table entries\n"));
 139     return NULL;
 140   }
 141
 142   TagPtr = NULL;
 143   TmpPtr += Header->header_bytes;
 144   for (Idx = 0; Idx < Header->table_entries; Idx++) {
 145     Record = (struct cb_record *)TmpPtr;
 146     if (Record->tag == CB_TAG_FORWARD) {
 147       TmpPtr = (VOID *)(UINTN)((struct cb_forward *)(UINTN)Record)->forward;
 148       if (Tag == CB_TAG_FORWARD) {
 149         return TmpPtr;
 150       } else {
 151         return FindCbTag (TmpPtr, Tag);
 152       }
 153     }
 154     if (Record->tag == Tag) {
 155       TagPtr = TmpPtr;
 156       break;
 157     }
 158     TmpPtr += Record->size;
 159   }
 160
 161   return TagPtr;
 162 }
 163
 164
 165 /**
 166   Find the given table with TableId from the given coreboot memory Root.
 167
 168   @param  Root               The coreboot memory table to be searched in
 169   @param  TableId            Table id to be found
 170   @param  pMemTable          To save the base address of the memory table found
 171   @param  pMemTableSize      To save the size of memory table found
 172
 173   @retval RETURN_SUCCESS            Successfully find out the memory table.
 174   @retval RETURN_INVALID_PARAMETER  Invalid input parameters.
 175   @retval RETURN_NOT_FOUND          Failed to find the memory table.
 176
 177 **/
 178 RETURN_STATUS
 179 EFIAPI
 180 FindCbMemTable (
 181   IN  struct cbmem_root  *Root,
 182   IN  UINT32             TableId,
 183   OUT VOID               **pMemTable,
 184   OUT UINT32             *pMemTableSize
 185   )
 186 {
 187   UINTN                Idx;
 188   BOOLEAN              IsImdEntry;
 189   struct cbmem_entry  *Entries;
 190
 191   if ((Root == NULL) || (pMemTable == NULL)) {
 192     return RETURN_INVALID_PARAMETER;
 193   }
 194   //
 195   // Check if the entry is CBMEM or IMD
 196   // and handle them separately
 197   //
 198   Entries = Root->entries;
 199   if (Entries[0].magic == CBMEM_ENTRY_MAGIC) {
 200     IsImdEntry = FALSE;
 201   } else {
 202     Entries = (struct cbmem_entry *)((struct imd_root *)Root)->entries;
 203     if (Entries[0].magic == IMD_ENTRY_MAGIC) {
 204       IsImdEntry = TRUE;
 205     } else {
 206       return RETURN_NOT_FOUND;
 207     }
 208   }
 209
 210   for (Idx = 0; Idx < Root->num_entries; Idx++) {
 211     if (Entries[Idx].id == TableId) {
 212       if (IsImdEntry) {
 213         *pMemTable = (VOID *) ((UINTN)Entries[Idx].start + (UINTN)Root);
 214       } else {
 215         *pMemTable = (VOID *) (UINTN)Entries[Idx].start;
 216       }
 217       if (pMemTableSize != NULL) {
 218         *pMemTableSize = Entries[Idx].size;
 219       }
 220
 221       DEBUG ((EFI_D_INFO, "Find CbMemTable Id 0x%x, base %p, size 0x%x\n",
 222         TableId, *pMemTable, Entries[Idx].size));
 223       return RETURN_SUCCESS;
 224     }
 225   }
 226
 227   return RETURN_NOT_FOUND;
 228 }
 229
 230
 231 /**
 232   Acquire the memory information from the coreboot table in memory.
 233
 234   @param  MemInfoCallback     The callback routine
 235   @param  pParam              Pointer to the callback routine parameter
 236
 237   @retval RETURN_SUCCESS     Successfully find out the memory information.
 238   @retval RETURN_NOT_FOUND   Failed to find the memory information.
 239
 240 **/
 241 RETURN_STATUS
 242 EFIAPI
 243 CbParseMemoryInfo (
 244   IN  CB_MEM_INFO_CALLBACK  MemInfoCallback,
 245   IN  VOID                  *pParam
 246   )
 247 {
 248   struct cb_memory         *rec;
 249   struct cb_memory_range   *Range;
 250   UINT64                   Start;
 251   UINT64                   Size;
 252   UINTN                    Index;
 253
 254   //
 255   // Get the coreboot memory table
 256   //
 257   rec = (struct cb_memory *)FindCbTag (0, CB_TAG_MEMORY);
 258   if (rec == NULL) {
 259     rec = (struct cb_memory *)FindCbTag ((VOID *)(UINTN)PcdGet32 (PcdCbHeaderPointer), CB_TAG_MEMORY);
 260   }
 261
 262   if (rec == NULL) {
 263     return RETURN_NOT_FOUND;
 264   }
 265
 266   for (Index = 0; Index < MEM_RANGE_COUNT(rec); Index++) {
 267     Range = MEM_RANGE_PTR(rec, Index);
 268     Start = cb_unpack64(Range->start);
 269     Size = cb_unpack64(Range->size);
 270     DEBUG ((EFI_D_INFO, "%d. %016lx - %016lx [%02x]\n",
 271             Index, Start, Start + Size - 1, Range->type));
 272
 273     MemInfoCallback (Start, Size, Range->type, pParam);
 274   }
 275
 276   return RETURN_SUCCESS;
 277 }
 278
 279
 280 /**
 281   Acquire the coreboot memory table with the given table id
 282
 283   @param  TableId            Table id to be searched
 284   @param  pMemTable          Pointer to the base address of the memory table
 285   @param  pMemTableSize      Pointer to the size of the memory table
 286
 287   @retval RETURN_SUCCESS     Successfully find out the memory table.
 288   @retval RETURN_INVALID_PARAMETER  Invalid input parameters.
 289   @retval RETURN_NOT_FOUND   Failed to find the memory table.
 290
 291 **/
 292 RETURN_STATUS
 293 EFIAPI
 294 CbParseCbMemTable (
 295   IN  UINT32     TableId,
 296   OUT VOID       **pMemTable,
 297   OUT UINT32     *pMemTableSize
 298   )
 299 {
 300   struct cb_memory         *rec;
 301   struct cb_memory_range   *Range;
 302   UINT64                   Start;
 303   UINT64                   Size;
 304   UINTN                    Index;
 305
 306   if (pMemTable == NULL) {
 307     return RETURN_INVALID_PARAMETER;
 308   }
 309   *pMemTable = NULL;
 310
 311   //
 312   // Get the coreboot memory table
 313   //
 314   rec = (struct cb_memory *)FindCbTag (0, CB_TAG_MEMORY);
 315   if (rec == NULL) {
 316     rec = (struct cb_memory *)FindCbTag ((VOID *)(UINTN)PcdGet32 (PcdCbHeaderPointer), CB_TAG_MEMORY);
 317   }
 318
 319   if (rec == NULL) {
 320     return RETURN_NOT_FOUND;
 321   }
 322
 323   for (Index = 0; Index < MEM_RANGE_COUNT(rec); Index++) {
 324     Range = MEM_RANGE_PTR(rec, Index);
 325     Start = cb_unpack64(Range->start);
 326     Size = cb_unpack64(Range->size);
 327
 328     if ((Range->type == CB_MEM_TABLE) && (Start > 0x1000)) {
 329       if (FindCbMemTable ((struct  cbmem_root *)(UINTN)(Start + Size - DYN_CBMEM_ALIGN_SIZE), TableId, pMemTable, pMemTableSize) == RETURN_SUCCESS)
 330         return RETURN_SUCCESS;
 331     }
 332   }
 333
 334   return RETURN_NOT_FOUND;
 335 }
 336
 337
 338 /**
 339   Acquire the acpi table from coreboot
 340
 341   @param  pMemTable          Pointer to the base address of the memory table
 342   @param  pMemTableSize      Pointer to the size of the memory table
 343
 344   @retval RETURN_SUCCESS     Successfully find out the memory table.
 345   @retval RETURN_INVALID_PARAMETER  Invalid input parameters.
 346   @retval RETURN_NOT_FOUND   Failed to find the memory table.
 347
 348 **/
 349 RETURN_STATUS
 350 EFIAPI
 351 CbParseAcpiTable (
 352   OUT VOID       **pMemTable,
 353   OUT UINT32     *pMemTableSize
 354   )
 355 {
 356   return CbParseCbMemTable (SIGNATURE_32 ('I', 'P', 'C', 'A'), pMemTable, pMemTableSize);
 357 }
 358
 359 /**
 360   Acquire the smbios table from coreboot
 361
 362   @param  pMemTable          Pointer to the base address of the memory table
 363   @param  pMemTableSize      Pointer to the size of the memory table
 364
 365   @retval RETURN_SUCCESS     Successfully find out the memory table.
 366   @retval RETURN_INVALID_PARAMETER  Invalid input parameters.
 367   @retval RETURN_NOT_FOUND   Failed to find the memory table.
 368
 369 **/
 370 RETURN_STATUS
 371 EFIAPI
 372 CbParseSmbiosTable (
 373   OUT VOID       **pMemTable,
 374   OUT UINT32     *pMemTableSize
 375   )
 376 {
 377   return CbParseCbMemTable (SIGNATURE_32 ('T', 'B', 'M', 'S'), pMemTable, pMemTableSize);
 378 }
 379
 380 /**
 381   Find the required fadt information
 382
 383   @param  pPmCtrlReg         Pointer to the address of power management control register
 384   @param  pPmTimerReg        Pointer to the address of power management timer register
 385   @param  pResetReg          Pointer to the address of system reset register
 386   @param  pResetValue        Pointer to the value to be writen to the system reset register
 387   @param  pPmEvtReg          Pointer to the address of power management event register
 388   @param  pPmGpeEnReg        Pointer to the address of power management GPE enable register
 389
 390   @retval RETURN_SUCCESS     Successfully find out all the required fadt information.
 391   @retval RETURN_NOT_FOUND   Failed to find the fadt table.
 392
 393 **/
 394 RETURN_STATUS
 395 EFIAPI
 396 CbParseFadtInfo (
 397   OUT UINTN      *pPmCtrlReg,
 398   OUT UINTN      *pPmTimerReg,
 399   OUT UINTN      *pResetReg,
 400   OUT UINTN      *pResetValue,
 401   OUT UINTN      *pPmEvtReg,
 402   OUT UINTN      *pPmGpeEnReg
 403   )
 404 {
 405   EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER  *Rsdp;
 406   EFI_ACPI_DESCRIPTION_HEADER                   *Rsdt;
 407   UINT32                                        *Entry32;
 408   UINTN                                         Entry32Num;
 409   EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE     *Fadt;
 410   EFI_ACPI_DESCRIPTION_HEADER                   *Xsdt;
 411   UINT64                                        *Entry64;
 412   UINTN                                         Entry64Num;
 413   UINTN                                         Idx;
 414   RETURN_STATUS                                 Status;
 415
 416   Rsdp = NULL;
 417   Status = RETURN_SUCCESS;
 418
 419   Status = CbParseAcpiTable ((VOID **)&Rsdp, NULL);
 420   if (RETURN_ERROR(Status)) {
 421     return Status;
 422   }
 423
 424   if (Rsdp == NULL) {
 425     return RETURN_NOT_FOUND;
 426   }
 427
 428   DEBUG ((EFI_D_INFO, "Find Rsdp at %p\n", Rsdp));
 429   DEBUG ((EFI_D_INFO, "Find Rsdt 0x%x, Xsdt 0x%lx\n", Rsdp->RsdtAddress, Rsdp->XsdtAddress));
 430
 431   //
 432   // Search Rsdt First
 433   //
 434   Rsdt     = (EFI_ACPI_DESCRIPTION_HEADER *)(UINTN)(Rsdp->RsdtAddress);
 435   if (Rsdt != NULL) {
 436     Entry32  = (UINT32 *)(Rsdt + 1);
 437     Entry32Num = (Rsdt->Length - sizeof(EFI_ACPI_DESCRIPTION_HEADER)) >> 2;
 438     for (Idx = 0; Idx < Entry32Num; Idx++) {
 439       if (*(UINT32 *)(UINTN)(Entry32[Idx]) == EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE) {
 440         Fadt = (EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *)(UINTN)(Entry32[Idx]);
 441         if (pPmCtrlReg != NULL) {
 442           *pPmCtrlReg = Fadt->Pm1aCntBlk;
 443         }
 444         DEBUG ((EFI_D_INFO, "PmCtrl Reg 0x%x\n", Fadt->Pm1aCntBlk));
 445
 446         if (pPmTimerReg != NULL) {
 447           *pPmTimerReg = Fadt->PmTmrBlk;
 448         }
 449         DEBUG ((EFI_D_INFO, "PmTimer Reg 0x%x\n", Fadt->PmTmrBlk));
 450
 451         if (pResetReg != NULL) {
 452           *pResetReg = (UINTN)Fadt->ResetReg.Address;
 453         }
 454         DEBUG ((EFI_D_INFO, "Reset Reg 0x%lx\n", Fadt->ResetReg.Address));
 455
 456         if (pResetValue != NULL) {
 457           *pResetValue = Fadt->ResetValue;
 458         }
 459         DEBUG ((EFI_D_INFO, "Reset Value 0x%x\n", Fadt->ResetValue));
 460
 461         if (pPmEvtReg != NULL) {
 462           *pPmEvtReg = Fadt->Pm1aEvtBlk;
 463           DEBUG ((EFI_D_INFO, "PmEvt Reg 0x%x\n", Fadt->Pm1aEvtBlk));
 464         }
 465
 466         if (pPmGpeEnReg != NULL) {
 467           *pPmGpeEnReg = Fadt->Gpe0Blk + Fadt->Gpe0BlkLen / 2;
 468           DEBUG ((EFI_D_INFO, "PmGpeEn Reg 0x%x\n", *pPmGpeEnReg));
 469         }
 470
 471         //
 472         // Verify values for proper operation
 473         //
 474         ASSERT(Fadt->Pm1aCntBlk != 0);
 475         ASSERT(Fadt->PmTmrBlk != 0);
 476         ASSERT(Fadt->ResetReg.Address != 0);
 477         ASSERT(Fadt->Pm1aEvtBlk != 0);
 478         ASSERT(Fadt->Gpe0Blk != 0);
 479
 480         return RETURN_SUCCESS;
 481       }
 482     }
 483   }
 484
 485   //
 486   // Search Xsdt Second
 487   //
 488   Xsdt     = (EFI_ACPI_DESCRIPTION_HEADER *)(UINTN)(Rsdp->XsdtAddress);
 489   if (Xsdt != NULL) {
 490     Entry64  = (UINT64 *)(Xsdt + 1);
 491     Entry64Num = (Xsdt->Length - sizeof(EFI_ACPI_DESCRIPTION_HEADER)) >> 3;
 492     for (Idx = 0; Idx < Entry64Num; Idx++) {
 493       if (*(UINT32 *)(UINTN)(Entry64[Idx]) == EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE) {
 494         Fadt = (EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *)(UINTN)(Entry64[Idx]);
 495         if (pPmCtrlReg)
 496           *pPmCtrlReg = Fadt->Pm1aCntBlk;
 497         DEBUG ((EFI_D_ERROR, "PmCtrl Reg 0x%x\n", Fadt->Pm1aCntBlk));
 498
 499         if (pPmTimerReg)
 500           *pPmTimerReg = Fadt->PmTmrBlk;
 501         DEBUG ((EFI_D_ERROR, "PmTimer Reg 0x%x\n", Fadt->PmTmrBlk));
 502
 503         if (pResetReg)
 504           *pResetReg = (UINTN)Fadt->ResetReg.Address;
 505         DEBUG ((EFI_D_ERROR, "Reset Reg 0x%lx\n", Fadt->ResetReg.Address));
 506
 507         if (pResetValue)
 508           *pResetValue = Fadt->ResetValue;
 509         DEBUG ((EFI_D_ERROR, "Reset Value 0x%x\n", Fadt->ResetValue));
 510
 511         if (pPmEvtReg != NULL) {
 512           *pPmEvtReg = Fadt->Pm1aEvtBlk;
 513            DEBUG ((EFI_D_INFO, "PmEvt Reg 0x%x\n", Fadt->Pm1aEvtBlk));
 514         }
 515
 516         if (pPmGpeEnReg != NULL) {
 517           *pPmGpeEnReg = Fadt->Gpe0Blk + Fadt->Gpe0BlkLen / 2;
 518           DEBUG ((EFI_D_INFO, "PmGpeEn Reg 0x%x\n", *pPmGpeEnReg));
 519         }
 520         return RETURN_SUCCESS;
 521       }
 522     }
 523   }
 524
 525   return RETURN_NOT_FOUND;
 526 }
 527
 528 /**
 529   Find the serial port information
 530
 531   @param  pRegBase           Pointer to the base address of serial port registers
 532   @param  pRegAccessType     Pointer to the access type of serial port registers
 533   @param  pRegWidth          Pointer to the register width in bytes
 534   @param  pBaudrate          Pointer to the serial port baudrate
 535   @param  pInputHertz        Pointer to the input clock frequency
 536   @param  pUartPciAddr       Pointer to the UART PCI bus, dev and func address
 537
 538   @retval RETURN_SUCCESS     Successfully find the serial port information.
 539   @retval RETURN_NOT_FOUND   Failed to find the serial port information .
 540
 541 **/
 542 RETURN_STATUS
 543 EFIAPI
 544 CbParseSerialInfo (
 545   OUT UINT32      *pRegBase,
 546   OUT UINT32      *pRegAccessType,
 547   OUT UINT32      *pRegWidth,
 548   OUT UINT32      *pBaudrate,
 549   OUT UINT32      *pInputHertz,
 550   OUT UINT32      *pUartPciAddr
 551   )
 552 {
 553   struct cb_serial    *CbSerial;
 554
 555   CbSerial = FindCbTag (0, CB_TAG_SERIAL);
 556   if (CbSerial == NULL) {
 557     CbSerial = FindCbTag ((VOID *)(UINTN)PcdGet32 (PcdCbHeaderPointer), CB_TAG_SERIAL);
 558   }
 559
 560   if (CbSerial == NULL) {
 561     return RETURN_NOT_FOUND;
 562   }
 563
 564   if (pRegBase != NULL) {
 565     *pRegBase = CbSerial->baseaddr;
 566   }
 567
 568   if (pRegWidth != NULL) {
 569     *pRegWidth = CbSerial->regwidth;
 570   }
 571
 572   if (pRegAccessType != NULL) {
 573     *pRegAccessType = CbSerial->type;
 574   }
 575
 576   if (pBaudrate != NULL) {
 577     *pBaudrate = CbSerial->baud;
 578   }
 579
 580   if (pInputHertz != NULL) {
 581     *pInputHertz = CbSerial->input_hertz;
 582   }
 583
 584   if (pUartPciAddr != NULL) {
 585     *pUartPciAddr = CbSerial->uart_pci_addr;
 586   }
 587
 588   return RETURN_SUCCESS;
 589 }
 590
 591 /**
 592   Search for the coreboot table header
 593
 594   @param  Level              Level of the search depth
 595   @param  HeaderPtr          Pointer to the pointer of coreboot table header
 596
 597   @retval RETURN_SUCCESS     Successfully find the coreboot table header .
 598   @retval RETURN_NOT_FOUND   Failed to find the coreboot table header .
 599
 600 **/
 601 RETURN_STATUS
 602 EFIAPI
 603 CbParseGetCbHeader (
 604   IN  UINTN  Level,
 605   OUT VOID   **HeaderPtr
 606   )
 607 {
 608   UINTN Index;
 609   VOID  *TempPtr;
 610
 611   if (HeaderPtr == NULL) {
 612     return RETURN_NOT_FOUND;
 613   }
 614
 615   TempPtr = NULL;
 616   for (Index = 0; Index < Level; Index++) {
 617     TempPtr = FindCbTag (TempPtr, CB_TAG_FORWARD);
 618     if (TempPtr == NULL) {
 619       break;
 620     }
 621   }
 622
 623   if ((Index >= Level) && (TempPtr != NULL)) {
 624     *HeaderPtr = TempPtr;
 625     return RETURN_SUCCESS;
 626   }
 627
 628   return RETURN_NOT_FOUND;
 629 }
 630
 631 /**
 632   Find the video frame buffer information
 633
 634   @param  pFbInfo            Pointer to the FRAME_BUFFER_INFO structure
 635
 636   @retval RETURN_SUCCESS     Successfully find the video frame buffer information.
 637   @retval RETURN_NOT_FOUND   Failed to find the video frame buffer information .
 638
 639 **/
 640 RETURN_STATUS
 641 EFIAPI
 642 CbParseFbInfo (
 643   OUT FRAME_BUFFER_INFO       *pFbInfo
 644   )
 645 {
 646   struct cb_framebuffer       *CbFbRec;
 647
 648   if (pFbInfo == NULL) {
 649     return RETURN_INVALID_PARAMETER;
 650   }
 651
 652   CbFbRec = FindCbTag (0, CB_TAG_FRAMEBUFFER);
 653   if (CbFbRec == NULL) {
 654     CbFbRec = FindCbTag ((VOID *)(UINTN)PcdGet32 (PcdCbHeaderPointer), CB_TAG_FRAMEBUFFER);
 655   }
 656
 657   if (CbFbRec == NULL) {
 658     return RETURN_NOT_FOUND;
 659   }
 660
 661   DEBUG ((EFI_D_INFO, "Found coreboot video frame buffer information\n"));
 662   DEBUG ((EFI_D_INFO, "physical_address: 0x%lx\n", CbFbRec->physical_address));
 663   DEBUG ((EFI_D_INFO, "x_resolution: 0x%x\n", CbFbRec->x_resolution));
 664   DEBUG ((EFI_D_INFO, "y_resolution: 0x%x\n", CbFbRec->y_resolution));
 665   DEBUG ((EFI_D_INFO, "bits_per_pixel: 0x%x\n", CbFbRec->bits_per_pixel));
 666   DEBUG ((EFI_D_INFO, "bytes_per_line: 0x%x\n", CbFbRec->bytes_per_line));
 667
 668   DEBUG ((EFI_D_INFO, "red_mask_size: 0x%x\n", CbFbRec->red_mask_size));
 669   DEBUG ((EFI_D_INFO, "red_mask_pos: 0x%x\n", CbFbRec->red_mask_pos));
 670   DEBUG ((EFI_D_INFO, "green_mask_size: 0x%x\n", CbFbRec->green_mask_size));
 671   DEBUG ((EFI_D_INFO, "green_mask_pos: 0x%x\n", CbFbRec->green_mask_pos));
 672   DEBUG ((EFI_D_INFO, "blue_mask_size: 0x%x\n", CbFbRec->blue_mask_size));
 673   DEBUG ((EFI_D_INFO, "blue_mask_pos: 0x%x\n", CbFbRec->blue_mask_pos));
 674   DEBUG ((EFI_D_INFO, "reserved_mask_size: 0x%x\n", CbFbRec->reserved_mask_size));
 675   DEBUG ((EFI_D_INFO, "reserved_mask_pos: 0x%x\n", CbFbRec->reserved_mask_pos));
 676
 677   pFbInfo->LinearFrameBuffer    = CbFbRec->physical_address;
 678   pFbInfo->HorizontalResolution = CbFbRec->x_resolution;
 679   pFbInfo->VerticalResolution   = CbFbRec->y_resolution;
 680   pFbInfo->BitsPerPixel         = CbFbRec->bits_per_pixel;
 681   pFbInfo->BytesPerScanLine     = (UINT16)CbFbRec->bytes_per_line;
 682   pFbInfo->Red.Mask             = (1 << CbFbRec->red_mask_size) - 1;
 683   pFbInfo->Red.Position         = CbFbRec->red_mask_pos;
 684   pFbInfo->Green.Mask           = (1 << CbFbRec->green_mask_size) - 1;
 685   pFbInfo->Green.Position       = CbFbRec->green_mask_pos;
 686   pFbInfo->Blue.Mask            = (1 << CbFbRec->blue_mask_size) - 1;
 687   pFbInfo->Blue.Position        = CbFbRec->blue_mask_pos;
 688   pFbInfo->Reserved.Mask        = (1 << CbFbRec->reserved_mask_size) - 1;
 689   pFbInfo->Reserved.Position    = CbFbRec->reserved_mask_pos;
 690
 691   return RETURN_SUCCESS;
 692 }
 693