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