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 - 2015, 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  pLowMemorySize     Pointer to the variable of low memory size
 233   @param  pHighMemorySize    Pointer to the variable of high memory size
 234
 235   @retval RETURN_SUCCESS     Successfully find out the memory information.
 236   @retval RETURN_INVALID_PARAMETER    Invalid input parameters.
 237   @retval RETURN_NOT_FOUND   Failed to find the memory information.
 238
 239 **/
 240 RETURN_STATUS
 241 CbParseMemoryInfo (
 242   OUT UINT64     *pLowMemorySize,
 243   OUT UINT64     *pHighMemorySize
 244   )
 245 {
 246   struct cb_memory         *rec;
 247   struct cb_memory_range   *Range;
 248   UINT64                   Start;
 249   UINT64                   Size;
 250   UINTN                    Index;
 251
 252   if ((pLowMemorySize == NULL) || (pHighMemorySize == NULL)) {
 253     return RETURN_INVALID_PARAMETER;
 254   }
 255
 256   //
 257   // Get the coreboot memory table
 258   //
 259   rec = (struct cb_memory *)FindCbTag (0, CB_TAG_MEMORY);
 260   if (rec == NULL) {
 261     rec = (struct cb_memory *)FindCbTag ((VOID *)(UINTN)PcdGet32 (PcdCbHeaderPointer), CB_TAG_MEMORY);
 262   }
 263
 264   if (rec == NULL) {
 265     return RETURN_NOT_FOUND;
 266   }
 267
 268   *pLowMemorySize = 0;
 269   *pHighMemorySize = 0;
 270
 271   for (Index = 0; Index < MEM_RANGE_COUNT(rec); Index++) {
 272     Range = MEM_RANGE_PTR(rec, Index);
 273     Start = cb_unpack64(Range->start);
 274     Size = cb_unpack64(Range->size);
 275     DEBUG ((EFI_D_INFO, "%d. %016lx - %016lx [%02x]\n",
 276             Index, Start, Start + Size - 1, Range->type));
 277
 278     if (Range->type != CB_MEM_RAM) {
 279       continue;
 280     }
 281
 282     if (Start + Size < 0x100000000ULL) {
 283       *pLowMemorySize = Start + Size;
 284     } else {
 285       *pHighMemorySize = Start + Size - 0x100000000ULL;
 286     }
 287   }
 288
 289   DEBUG ((EFI_D_INFO, "Low memory 0x%lx, High Memory 0x%lx\n", *pLowMemorySize, *pHighMemorySize));
 290
 291   return RETURN_SUCCESS;
 292 }
 293
 294
 295 /**
 296   Acquire the coreboot memory table with the given table id
 297
 298   @param  TableId            Table id to be searched
 299   @param  pMemTable          Pointer to the base address of the memory table
 300   @param  pMemTableSize      Pointer to the size of the memory table
 301
 302   @retval RETURN_SUCCESS     Successfully find out the memory table.
 303   @retval RETURN_INVALID_PARAMETER  Invalid input parameters.
 304   @retval RETURN_NOT_FOUND   Failed to find the memory table.
 305
 306 **/
 307 RETURN_STATUS
 308 CbParseCbMemTable (
 309   IN  UINT32     TableId,
 310   OUT VOID       **pMemTable,
 311   OUT UINT32     *pMemTableSize
 312   )
 313 {
 314   struct cb_memory         *rec;
 315   struct cb_memory_range   *Range;
 316   UINT64                   Start;
 317   UINT64                   Size;
 318   UINTN                    Index;
 319
 320   if (pMemTable == NULL) {
 321     return RETURN_INVALID_PARAMETER;
 322   }
 323   *pMemTable = NULL;
 324
 325   //
 326   // Get the coreboot memory table
 327   //
 328   rec = (struct cb_memory *)FindCbTag (0, CB_TAG_MEMORY);
 329   if (rec == NULL) {
 330     rec = (struct cb_memory *)FindCbTag ((VOID *)(UINTN)PcdGet32 (PcdCbHeaderPointer), CB_TAG_MEMORY);
 331   }
 332
 333   if (rec == NULL) {
 334     return RETURN_NOT_FOUND;
 335   }
 336
 337   for (Index = 0; Index < MEM_RANGE_COUNT(rec); Index++) {
 338     Range = MEM_RANGE_PTR(rec, Index);
 339     Start = cb_unpack64(Range->start);
 340     Size = cb_unpack64(Range->size);
 341
 342     if ((Range->type == CB_MEM_TABLE) && (Start > 0x1000)) {
 343       if (FindCbMemTable ((struct  cbmem_root *)(UINTN)(Start + Size - DYN_CBMEM_ALIGN_SIZE), TableId, pMemTable, pMemTableSize) == RETURN_SUCCESS)
 344         return RETURN_SUCCESS;
 345     }
 346   }
 347
 348   return RETURN_NOT_FOUND;
 349 }
 350
 351
 352 /**
 353   Acquire the acpi table from coreboot
 354
 355   @param  pMemTable          Pointer to the base address of the memory table
 356   @param  pMemTableSize      Pointer to the size of the memory table
 357
 358   @retval RETURN_SUCCESS     Successfully find out the memory table.
 359   @retval RETURN_INVALID_PARAMETER  Invalid input parameters.
 360   @retval RETURN_NOT_FOUND   Failed to find the memory table.
 361
 362 **/
 363 RETURN_STATUS
 364 CbParseAcpiTable (
 365   OUT VOID       **pMemTable,
 366   OUT UINT32     *pMemTableSize
 367   )
 368 {
 369   return CbParseCbMemTable (SIGNATURE_32 ('I', 'P', 'C', 'A'), pMemTable, pMemTableSize);
 370 }
 371
 372 /**
 373   Acquire the smbios table from coreboot
 374
 375   @param  pMemTable          Pointer to the base address of the memory table
 376   @param  pMemTableSize      Pointer to the size of the memory table
 377
 378   @retval RETURN_SUCCESS     Successfully find out the memory table.
 379   @retval RETURN_INVALID_PARAMETER  Invalid input parameters.
 380   @retval RETURN_NOT_FOUND   Failed to find the memory table.
 381
 382 **/
 383 RETURN_STATUS
 384 CbParseSmbiosTable (
 385   OUT VOID       **pMemTable,
 386   OUT UINT32     *pMemTableSize
 387   )
 388 {
 389   return CbParseCbMemTable (SIGNATURE_32 ('T', 'B', 'M', 'S'), pMemTable, pMemTableSize);
 390 }
 391
 392 /**
 393   Find the required fadt information
 394
 395   @param  pPmCtrlReg         Pointer to the address of power management control register
 396   @param  pPmTimerReg        Pointer to the address of power management timer register
 397   @param  pResetReg          Pointer to the address of system reset register
 398   @param  pResetValue        Pointer to the value to be writen to the system reset register
 399   @param  pPmEvtReg          Pointer to the address of power management event register
 400   @param  pPmGpeEnReg        Pointer to the address of power management GPE enable register
 401
 402   @retval RETURN_SUCCESS     Successfully find out all the required fadt information.
 403   @retval RETURN_NOT_FOUND   Failed to find the fadt table.
 404
 405 **/
 406 RETURN_STATUS
 407 CbParseFadtInfo (
 408   OUT UINTN      *pPmCtrlReg,
 409   OUT UINTN      *pPmTimerReg,
 410   OUT UINTN      *pResetReg,
 411   OUT UINTN      *pResetValue,
 412   OUT UINTN      *pPmEvtReg,
 413   OUT UINTN      *pPmGpeEnReg
 414   )
 415 {
 416   EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER  *Rsdp;
 417   EFI_ACPI_DESCRIPTION_HEADER                   *Rsdt;
 418   UINT32                                        *Entry32;
 419   UINTN                                         Entry32Num;
 420   EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE     *Fadt;
 421   EFI_ACPI_DESCRIPTION_HEADER                   *Xsdt;
 422   UINT64                                        *Entry64;
 423   UINTN                                         Entry64Num;
 424   UINTN                                         Idx;
 425   RETURN_STATUS                                 Status;
 426
 427   Rsdp = NULL;
 428   Status = RETURN_SUCCESS;
 429
 430   Status = CbParseAcpiTable ((VOID **)&Rsdp, NULL);
 431   if (RETURN_ERROR(Status)) {
 432     return Status;
 433   }
 434
 435   if (Rsdp == NULL) {
 436     return RETURN_NOT_FOUND;
 437   }
 438
 439   DEBUG ((EFI_D_INFO, "Find Rsdp at %p\n", Rsdp));
 440   DEBUG ((EFI_D_INFO, "Find Rsdt 0x%x, Xsdt 0x%lx\n", Rsdp->RsdtAddress, Rsdp->XsdtAddress));
 441
 442   //
 443   // Search Rsdt First
 444   //
 445   Rsdt     = (EFI_ACPI_DESCRIPTION_HEADER *)(UINTN)(Rsdp->RsdtAddress);
 446   if (Rsdt != NULL) {
 447     Entry32  = (UINT32 *)(Rsdt + 1);
 448     Entry32Num = (Rsdt->Length - sizeof(EFI_ACPI_DESCRIPTION_HEADER)) >> 2;
 449     for (Idx = 0; Idx < Entry32Num; Idx++) {
 450       if (*(UINT32 *)(UINTN)(Entry32[Idx]) == EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE) {
 451         Fadt = (EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *)(UINTN)(Entry32[Idx]);
 452         if (pPmCtrlReg != NULL) {
 453           *pPmCtrlReg = Fadt->Pm1aCntBlk;
 454         }
 455         DEBUG ((EFI_D_INFO, "PmCtrl Reg 0x%x\n", Fadt->Pm1aCntBlk));
 456
 457         if (pPmTimerReg != NULL) {
 458           *pPmTimerReg = Fadt->PmTmrBlk;
 459         }
 460         DEBUG ((EFI_D_INFO, "PmTimer Reg 0x%x\n", Fadt->PmTmrBlk));
 461
 462         if (pResetReg != NULL) {
 463           *pResetReg = (UINTN)Fadt->ResetReg.Address;
 464         }
 465         DEBUG ((EFI_D_INFO, "Reset Reg 0x%lx\n", Fadt->ResetReg.Address));
 466
 467         if (pResetValue != NULL) {
 468           *pResetValue = Fadt->ResetValue;
 469         }
 470         DEBUG ((EFI_D_INFO, "Reset Value 0x%x\n", Fadt->ResetValue));
 471
 472         if (pPmEvtReg != NULL) {
 473           *pPmEvtReg = Fadt->Pm1aEvtBlk;
 474           DEBUG ((EFI_D_INFO, "PmEvt Reg 0x%x\n", Fadt->Pm1aEvtBlk));
 475         }
 476
 477         if (pPmGpeEnReg != NULL) {
 478           *pPmGpeEnReg = Fadt->Gpe0Blk + Fadt->Gpe0BlkLen / 2;
 479           DEBUG ((EFI_D_INFO, "PmGpeEn Reg 0x%x\n", *pPmGpeEnReg));
 480         }
 481
 482         //
 483         // Verify values for proper operation
 484         //
 485         ASSERT(Fadt->Pm1aCntBlk != 0);
 486         ASSERT(Fadt->PmTmrBlk != 0);
 487         ASSERT(Fadt->ResetReg.Address != 0);
 488         ASSERT(Fadt->Pm1aEvtBlk != 0);
 489         ASSERT(Fadt->Gpe0Blk != 0);
 490
 491         return RETURN_SUCCESS;
 492       }
 493     }
 494   }
 495
 496   //
 497   // Search Xsdt Second
 498   //
 499   Xsdt     = (EFI_ACPI_DESCRIPTION_HEADER *)(UINTN)(Rsdp->XsdtAddress);
 500   if (Xsdt != NULL) {
 501     Entry64  = (UINT64 *)(Xsdt + 1);
 502     Entry64Num = (Xsdt->Length - sizeof(EFI_ACPI_DESCRIPTION_HEADER)) >> 3;
 503     for (Idx = 0; Idx < Entry64Num; Idx++) {
 504       if (*(UINT32 *)(UINTN)(Entry64[Idx]) == EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE) {
 505         Fadt = (EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *)(UINTN)(Entry64[Idx]);
 506         if (pPmCtrlReg)
 507           *pPmCtrlReg = Fadt->Pm1aCntBlk;
 508         DEBUG ((EFI_D_ERROR, "PmCtrl Reg 0x%x\n", Fadt->Pm1aCntBlk));
 509
 510         if (pPmTimerReg)
 511           *pPmTimerReg = Fadt->PmTmrBlk;
 512         DEBUG ((EFI_D_ERROR, "PmTimer Reg 0x%x\n", Fadt->PmTmrBlk));
 513
 514         if (pResetReg)
 515           *pResetReg = (UINTN)Fadt->ResetReg.Address;
 516         DEBUG ((EFI_D_ERROR, "Reset Reg 0x%lx\n", Fadt->ResetReg.Address));
 517
 518         if (pResetValue)
 519           *pResetValue = Fadt->ResetValue;
 520         DEBUG ((EFI_D_ERROR, "Reset Value 0x%x\n", Fadt->ResetValue));
 521
 522         if (pPmEvtReg != NULL) {
 523           *pPmEvtReg = Fadt->Pm1aEvtBlk;
 524            DEBUG ((EFI_D_INFO, "PmEvt Reg 0x%x\n", Fadt->Pm1aEvtBlk));
 525         }
 526
 527         if (pPmGpeEnReg != NULL) {
 528           *pPmGpeEnReg = Fadt->Gpe0Blk + Fadt->Gpe0BlkLen / 2;
 529           DEBUG ((EFI_D_INFO, "PmGpeEn Reg 0x%x\n", *pPmGpeEnReg));
 530         }
 531         return RETURN_SUCCESS;
 532       }
 533     }
 534   }
 535
 536   return RETURN_NOT_FOUND;
 537 }
 538
 539 /**
 540   Find the serial port information
 541
 542   @param  pRegBase           Pointer to the base address of serial port registers
 543   @param  pRegAccessType     Pointer to the access type of serial port registers
 544   @param  pRegWidth          Pointer to the register width in bytes
 545   @param  pBaudrate          Pointer to the serial port baudrate
 546   @param  pInputHertz        Pointer to the input clock frequency
 547   @param  pUartPciAddr       Pointer to the UART PCI bus, dev and func address
 548
 549   @retval RETURN_SUCCESS     Successfully find the serial port information.
 550   @retval RETURN_NOT_FOUND   Failed to find the serial port information .
 551
 552 **/
 553 RETURN_STATUS
 554 CbParseSerialInfo (
 555   OUT UINT32      *pRegBase,
 556   OUT UINT32      *pRegAccessType,
 557   OUT UINT32      *pRegWidth,
 558   OUT UINT32      *pBaudrate,
 559   OUT UINT32      *pInputHertz,
 560   OUT UINT32      *pUartPciAddr
 561   )
 562 {
 563   struct cb_serial    *CbSerial;
 564
 565   CbSerial = FindCbTag (0, CB_TAG_SERIAL);
 566   if (CbSerial == NULL) {
 567     CbSerial = FindCbTag ((VOID *)(UINTN)PcdGet32 (PcdCbHeaderPointer), CB_TAG_SERIAL);
 568   }
 569
 570   if (CbSerial == NULL) {
 571     return RETURN_NOT_FOUND;
 572   }
 573
 574   if (pRegBase != NULL) {
 575     *pRegBase = CbSerial->baseaddr;
 576   }
 577
 578   if (pRegWidth != NULL) {
 579     *pRegWidth = CbSerial->regwidth;
 580   }
 581
 582   if (pRegAccessType != NULL) {
 583     *pRegAccessType = CbSerial->type;
 584   }
 585
 586   if (pBaudrate != NULL) {
 587     *pBaudrate = CbSerial->baud;
 588   }
 589
 590   if (pInputHertz != NULL) {
 591     *pInputHertz = CbSerial->input_hertz;
 592   }
 593
 594   if (pUartPciAddr != NULL) {
 595     *pUartPciAddr = CbSerial->uart_pci_addr;
 596   }
 597
 598   return RETURN_SUCCESS;
 599 }
 600
 601 /**
 602   Search for the coreboot table header
 603
 604   @param  Level              Level of the search depth
 605   @param  HeaderPtr          Pointer to the pointer of coreboot table header
 606
 607   @retval RETURN_SUCCESS     Successfully find the coreboot table header .
 608   @retval RETURN_NOT_FOUND   Failed to find the coreboot table header .
 609
 610 **/
 611 RETURN_STATUS
 612 CbParseGetCbHeader (
 613   IN  UINTN  Level,
 614   OUT VOID   **HeaderPtr
 615   )
 616 {
 617   UINTN Index;
 618   VOID  *TempPtr;
 619
 620   if (HeaderPtr == NULL) {
 621     return RETURN_NOT_FOUND;
 622   }
 623
 624   TempPtr = NULL;
 625   for (Index = 0; Index < Level; Index++) {
 626     TempPtr = FindCbTag (TempPtr, CB_TAG_FORWARD);
 627     if (TempPtr == NULL) {
 628       break;
 629     }
 630   }
 631
 632   if ((Index >= Level) && (TempPtr != NULL)) {
 633     *HeaderPtr = TempPtr;
 634     return RETURN_SUCCESS;
 635   }
 636
 637   return RETURN_NOT_FOUND;
 638 }
 639
 640 /**
 641   Find the video frame buffer information
 642
 643   @param  pFbInfo            Pointer to the FRAME_BUFFER_INFO structure
 644
 645   @retval RETURN_SUCCESS     Successfully find the video frame buffer information.
 646   @retval RETURN_NOT_FOUND   Failed to find the video frame buffer information .
 647
 648 **/
 649 RETURN_STATUS
 650 CbParseFbInfo (
 651   OUT FRAME_BUFFER_INFO       *pFbInfo
 652   )
 653 {
 654   struct cb_framebuffer       *CbFbRec;
 655
 656   if (pFbInfo == NULL) {
 657     return RETURN_INVALID_PARAMETER;
 658   }
 659
 660   CbFbRec = FindCbTag (0, CB_TAG_FRAMEBUFFER);
 661   if (CbFbRec == NULL) {
 662     CbFbRec = FindCbTag ((VOID *)(UINTN)PcdGet32 (PcdCbHeaderPointer), CB_TAG_FRAMEBUFFER);
 663   }
 664
 665   if (CbFbRec == NULL) {
 666     return RETURN_NOT_FOUND;
 667   }
 668
 669   DEBUG ((EFI_D_INFO, "Found coreboot video frame buffer information\n"));
 670   DEBUG ((EFI_D_INFO, "physical_address: 0x%lx\n", CbFbRec->physical_address));
 671   DEBUG ((EFI_D_INFO, "x_resolution: 0x%x\n", CbFbRec->x_resolution));
 672   DEBUG ((EFI_D_INFO, "y_resolution: 0x%x\n", CbFbRec->y_resolution));
 673   DEBUG ((EFI_D_INFO, "bits_per_pixel: 0x%x\n", CbFbRec->bits_per_pixel));
 674   DEBUG ((EFI_D_INFO, "bytes_per_line: 0x%x\n", CbFbRec->bytes_per_line));
 675
 676   DEBUG ((EFI_D_INFO, "red_mask_size: 0x%x\n", CbFbRec->red_mask_size));
 677   DEBUG ((EFI_D_INFO, "red_mask_pos: 0x%x\n", CbFbRec->red_mask_pos));
 678   DEBUG ((EFI_D_INFO, "green_mask_size: 0x%x\n", CbFbRec->green_mask_size));
 679   DEBUG ((EFI_D_INFO, "green_mask_pos: 0x%x\n", CbFbRec->green_mask_pos));
 680   DEBUG ((EFI_D_INFO, "blue_mask_size: 0x%x\n", CbFbRec->blue_mask_size));
 681   DEBUG ((EFI_D_INFO, "blue_mask_pos: 0x%x\n", CbFbRec->blue_mask_pos));
 682   DEBUG ((EFI_D_INFO, "reserved_mask_size: 0x%x\n", CbFbRec->reserved_mask_size));
 683   DEBUG ((EFI_D_INFO, "reserved_mask_pos: 0x%x\n", CbFbRec->reserved_mask_pos));
 684
 685   pFbInfo->LinearFrameBuffer    = CbFbRec->physical_address;
 686   pFbInfo->HorizontalResolution = CbFbRec->x_resolution;
 687   pFbInfo->VerticalResolution   = CbFbRec->y_resolution;
 688   pFbInfo->BitsPerPixel         = CbFbRec->bits_per_pixel;
 689   pFbInfo->BytesPerScanLine     = (UINT16)CbFbRec->bytes_per_line;
 690   pFbInfo->Red.Mask             = (1 << CbFbRec->red_mask_size) - 1;
 691   pFbInfo->Red.Position         = CbFbRec->red_mask_pos;
 692   pFbInfo->Green.Mask           = (1 << CbFbRec->green_mask_size) - 1;
 693   pFbInfo->Green.Position       = CbFbRec->green_mask_pos;
 694   pFbInfo->Blue.Mask            = (1 << CbFbRec->blue_mask_size) - 1;
 695   pFbInfo->Blue.Position        = CbFbRec->blue_mask_pos;
 696   pFbInfo->Reserved.Mask        = (1 << CbFbRec->reserved_mask_size) - 1;
 697   pFbInfo->Reserved.Position    = CbFbRec->reserved_mask_pos;
 698
 699   return RETURN_SUCCESS;
 700 }
 701