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