CorebootPayloadPkg/FbGop/FbGop.c

   1 /** @file
   2   ConsoleOut Routines that speak VGA.
   3
   4 Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>
   5
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions
   8 of the BSD License which accompanies this distribution.  The
   9 full text of the license may be found at
  10 http://opensource.org/licenses/bsd-license.php
  11
  12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "FbGop.h"
  18
  19 EFI_PIXEL_BITMASK  mPixelBitMask = {0x0000FF, 0x00FF00, 0xFF0000, 0x000000};
  20
  21 //
  22 // Save controller attributes during first start
  23 //
  24 UINT64                         mOriginalPciAttributes;
  25 BOOLEAN                        mPciAttributesSaved = FALSE;
  26
  27
  28 //
  29 // EFI Driver Binding Protocol Instance
  30 //
  31 EFI_DRIVER_BINDING_PROTOCOL gFbGopDriverBinding = {
  32   FbGopDriverBindingSupported,
  33   FbGopDriverBindingStart,
  34   FbGopDriverBindingStop,
  35   0x3,
  36   NULL,
  37   NULL
  38 };
  39
  40 //
  41 // Native resolution in EDID DetailedTiming[0]
  42 //
  43 UINT32    mNativeModeHorizontal;
  44 UINT32    mNativeModeVertical;
  45
  46 /**
  47   Supported.
  48
  49   @param  This                   Pointer to driver binding protocol
  50   @param  Controller             Controller handle to connect
  51   @param  RemainingDevicePath    A pointer to the remaining portion of a device
  52                                  path
  53
  54   @retval EFI_STATUS             EFI_SUCCESS:This controller can be managed by this
  55                                  driver, Otherwise, this controller cannot be
  56                                  managed by this driver
  57
  58 **/
  59 EFI_STATUS
  60 EFIAPI
  61 FbGopDriverBindingSupported (
  62   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  63   IN EFI_HANDLE                   Controller,
  64   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  65   )
  66 {
  67   EFI_STATUS                Status;
  68   EFI_PCI_IO_PROTOCOL       *PciIo;
  69   PCI_TYPE00                Pci;
  70   EFI_DEV_PATH              *Node;
  71
  72   //
  73   // Open the IO Abstraction(s) needed to perform the supported test
  74   //
  75   Status = gBS->OpenProtocol (
  76                   Controller,
  77                   &gEfiPciIoProtocolGuid,
  78                   (VOID **) &PciIo,
  79                   This->DriverBindingHandle,
  80                   Controller,
  81                   EFI_OPEN_PROTOCOL_BY_DRIVER
  82                   );
  83   if (EFI_ERROR (Status)) {
  84     return Status;
  85   }
  86
  87   //
  88   // See if this is a PCI Graphics Controller by looking at the Command register and
  89   // Class Code Register
  90   //
  91   Status = PciIo->Pci.Read (
  92                         PciIo,
  93                         EfiPciIoWidthUint32,
  94                         0,
  95                         sizeof (Pci) / sizeof (UINT32),
  96                         &Pci
  97                         );
  98   if (EFI_ERROR (Status)) {
  99     Status = EFI_UNSUPPORTED;
 100     goto Done;
 101   }
 102
 103   Status = EFI_UNSUPPORTED;
 104   if (Pci.Hdr.ClassCode[2] == 0x03 || (Pci.Hdr.ClassCode[2] == 0x00 && Pci.Hdr.ClassCode[1] == 0x01)) {
 105
 106     Status = EFI_SUCCESS;
 107     //
 108     // If this is a graphics controller,
 109     // go further check RemainingDevicePath validation
 110     //
 111     if (RemainingDevicePath != NULL) {
 112       Node = (EFI_DEV_PATH *) RemainingDevicePath;
 113       //
 114       // Check if RemainingDevicePath is the End of Device Path Node,
 115       // if yes, return EFI_SUCCESS
 116       //
 117       if (!IsDevicePathEnd (Node)) {
 118         //
 119         // If RemainingDevicePath isn't the End of Device Path Node,
 120         // check its validation
 121         //
 122         if (Node->DevPath.Type != ACPI_DEVICE_PATH ||
 123             Node->DevPath.SubType != ACPI_ADR_DP ||
 124             DevicePathNodeLength(&Node->DevPath) < sizeof(ACPI_ADR_DEVICE_PATH)) {
 125           Status = EFI_UNSUPPORTED;
 126         }
 127       }
 128     }
 129   }
 130
 131 Done:
 132   gBS->CloseProtocol (
 133          Controller,
 134          &gEfiPciIoProtocolGuid,
 135          This->DriverBindingHandle,
 136          Controller
 137          );
 138
 139   return Status;
 140 }
 141
 142
 143 /**
 144   Install Graphics Output Protocol onto VGA device handles.
 145
 146   @param  This                   Pointer to driver binding protocol
 147   @param  Controller             Controller handle to connect
 148   @param  RemainingDevicePath    A pointer to the remaining portion of a device
 149                                  path
 150
 151   @return EFI_STATUS
 152
 153 **/
 154 EFI_STATUS
 155 EFIAPI
 156 FbGopDriverBindingStart (
 157   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 158   IN EFI_HANDLE                   Controller,
 159   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 160   )
 161 {
 162   EFI_STATUS                Status;
 163   EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;
 164   EFI_PCI_IO_PROTOCOL       *PciIo;
 165   UINT64                    Supports;
 166
 167   DEBUG ((EFI_D_INFO, "GOP START\n"));
 168
 169   //
 170   // Initialize local variables
 171   //
 172   PciIo            = NULL;
 173   ParentDevicePath = NULL;
 174
 175   //
 176   // Prepare for status code
 177   //
 178   Status = gBS->HandleProtocol (
 179                   Controller,
 180                   &gEfiDevicePathProtocolGuid,
 181                   (VOID **) &ParentDevicePath
 182                   );
 183   if (EFI_ERROR (Status)) {
 184     return Status;
 185   }
 186
 187   //
 188   // Open the IO Abstraction(s) needed
 189   //
 190   Status = gBS->OpenProtocol (
 191                   Controller,
 192                   &gEfiPciIoProtocolGuid,
 193                   (VOID **) &PciIo,
 194                   This->DriverBindingHandle,
 195                   Controller,
 196                   EFI_OPEN_PROTOCOL_BY_DRIVER
 197                   );
 198   if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) {
 199     return Status;
 200   }
 201
 202   //
 203   // Save original PCI attributes
 204   //
 205   if (!mPciAttributesSaved) {
 206     Status = PciIo->Attributes (
 207                       PciIo,
 208                       EfiPciIoAttributeOperationGet,
 209                       0,
 210                       &mOriginalPciAttributes
 211                       );
 212
 213     if (EFI_ERROR (Status)) {
 214       goto Done;
 215     }
 216     mPciAttributesSaved = TRUE;
 217   }
 218
 219   //
 220   // Get supported PCI attributes
 221   //
 222   Status = PciIo->Attributes (
 223                     PciIo,
 224                     EfiPciIoAttributeOperationSupported,
 225                     0,
 226                     &Supports
 227                     );
 228   if (EFI_ERROR (Status)) {
 229     goto Done;
 230   }
 231
 232   Supports &= (EFI_PCI_IO_ATTRIBUTE_VGA_IO | EFI_PCI_IO_ATTRIBUTE_VGA_IO_16);
 233   if (Supports == 0 || Supports == (EFI_PCI_IO_ATTRIBUTE_VGA_IO | EFI_PCI_IO_ATTRIBUTE_VGA_IO_16)) {
 234     Status = EFI_UNSUPPORTED;
 235     goto Done;
 236   }
 237
 238   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 239     EFI_PROGRESS_CODE,
 240     EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_PC_ENABLE,
 241     ParentDevicePath
 242     );
 243   //
 244   // Enable the device and make sure VGA cycles are being forwarded to this VGA device
 245   //
 246   Status = PciIo->Attributes (
 247              PciIo,
 248              EfiPciIoAttributeOperationEnable,
 249              EFI_PCI_DEVICE_ENABLE,
 250              NULL
 251              );
 252   if (EFI_ERROR (Status)) {
 253     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 254       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 255       EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_EC_RESOURCE_CONFLICT,
 256       ParentDevicePath
 257       );
 258     goto Done;
 259   }
 260
 261   if (RemainingDevicePath != NULL) {
 262     if (IsDevicePathEnd (RemainingDevicePath)) {
 263       //
 264       // If RemainingDevicePath is the End of Device Path Node,
 265       // don't create any child device and return EFI_SUCESS
 266       Status = EFI_SUCCESS;
 267       goto Done;
 268     }
 269   }
 270
 271   //
 272   // Create child handle and install GraphicsOutputProtocol on it
 273   //
 274   Status = FbGopChildHandleInstall (
 275              This,
 276              Controller,
 277              PciIo,
 278              NULL,
 279              ParentDevicePath,
 280              RemainingDevicePath
 281              );
 282
 283 Done:
 284   if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) {
 285
 286     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 287       EFI_PROGRESS_CODE,
 288       EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_PC_DISABLE,
 289       ParentDevicePath
 290       );
 291
 292     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 293       EFI_PROGRESS_CODE,
 294       EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_EC_NOT_DETECTED,
 295       ParentDevicePath
 296       );
 297     if (!HasChildHandle (Controller)) {
 298       if (mPciAttributesSaved) {
 299         //
 300         // Restore original PCI attributes
 301         //
 302         PciIo->Attributes (
 303                         PciIo,
 304                         EfiPciIoAttributeOperationSet,
 305                         mOriginalPciAttributes,
 306                         NULL
 307                         );
 308       }
 309     }
 310     //
 311     // Release PCI I/O Protocols on the controller handle.
 312     //
 313     gBS->CloseProtocol (
 314            Controller,
 315            &gEfiPciIoProtocolGuid,
 316            This->DriverBindingHandle,
 317            Controller
 318            );
 319   }
 320
 321   return Status;
 322 }
 323
 324
 325 /**
 326   Stop.
 327
 328   @param  This                   Pointer to driver binding protocol
 329   @param  Controller             Controller handle to connect
 330   @param  NumberOfChildren       Number of children handle created by this driver
 331   @param  ChildHandleBuffer      Buffer containing child handle created
 332
 333   @retval EFI_SUCCESS            Driver disconnected successfully from controller
 334   @retval EFI_UNSUPPORTED        Cannot find FB_VIDEO_DEV structure
 335
 336 **/
 337 EFI_STATUS
 338 EFIAPI
 339 FbGopDriverBindingStop (
 340   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 341   IN  EFI_HANDLE                      Controller,
 342   IN  UINTN                           NumberOfChildren,
 343   IN  EFI_HANDLE                      *ChildHandleBuffer
 344   )
 345 {
 346   EFI_STATUS                   Status;
 347   BOOLEAN                      AllChildrenStopped;
 348   UINTN                        Index;
 349   EFI_PCI_IO_PROTOCOL          *PciIo;
 350
 351   AllChildrenStopped = TRUE;
 352
 353   if (NumberOfChildren == 0) {
 354     //
 355     // Close PCI I/O protocol on the controller handle
 356     //
 357     gBS->CloseProtocol (
 358            Controller,
 359            &gEfiPciIoProtocolGuid,
 360            This->DriverBindingHandle,
 361            Controller
 362            );
 363
 364     return EFI_SUCCESS;
 365   }
 366
 367   for (Index = 0; Index < NumberOfChildren; Index++) {
 368
 369     Status = EFI_SUCCESS;
 370
 371     FbGopChildHandleUninstall (This, Controller, ChildHandleBuffer[Index]);
 372
 373     if (EFI_ERROR (Status)) {
 374       AllChildrenStopped = FALSE;
 375     }
 376   }
 377
 378   if (!AllChildrenStopped) {
 379     return EFI_DEVICE_ERROR;
 380   }
 381
 382   if (!HasChildHandle (Controller)) {
 383     if (mPciAttributesSaved) {
 384       Status = gBS->HandleProtocol (
 385                       Controller,
 386                       &gEfiPciIoProtocolGuid,
 387                       (VOID **) &PciIo
 388                       );
 389       ASSERT_EFI_ERROR (Status);
 390
 391       //
 392       // Restore original PCI attributes
 393       //
 394       Status = PciIo->Attributes (
 395                         PciIo,
 396                         EfiPciIoAttributeOperationSet,
 397                         mOriginalPciAttributes,
 398                         NULL
 399                         );
 400       ASSERT_EFI_ERROR (Status);
 401     }
 402   }
 403
 404
 405   return EFI_SUCCESS;
 406 }
 407
 408
 409 /**
 410   Install child handles if the Handle supports MBR format.
 411
 412   @param  This                   Calling context.
 413   @param  ParentHandle           Parent Handle
 414   @param  ParentPciIo            Parent PciIo interface
 415   @param  ParentLegacyBios       Parent LegacyBios interface
 416   @param  ParentDevicePath       Parent Device Path
 417   @param  RemainingDevicePath    Remaining Device Path
 418
 419   @retval EFI_SUCCESS            If a child handle was added
 420   @retval other                  A child handle was not added
 421
 422 **/
 423 EFI_STATUS
 424 FbGopChildHandleInstall (
 425   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 426   IN  EFI_HANDLE                   ParentHandle,
 427   IN  EFI_PCI_IO_PROTOCOL          *ParentPciIo,
 428   IN  VOID                         *ParentLegacyBios,
 429   IN  EFI_DEVICE_PATH_PROTOCOL     *ParentDevicePath,
 430   IN  EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 431   )
 432 {
 433   EFI_STATUS               Status;
 434   FB_VIDEO_DEV            *FbGopPrivate;
 435   PCI_TYPE00               Pci;
 436   ACPI_ADR_DEVICE_PATH     AcpiDeviceNode;
 437   BOOLEAN                  ProtocolInstalled;
 438
 439   //
 440   // Allocate the private device structure for video device
 441   //
 442   FbGopPrivate = (FB_VIDEO_DEV *) AllocateZeroPool (
 443                                                                                                                                                                         sizeof (FB_VIDEO_DEV)
 444                                                                                                                                                                         );
 445   if (NULL == FbGopPrivate) {
 446                 Status = EFI_OUT_OF_RESOURCES;
 447     goto Done;
 448   }
 449
 450   //
 451   // See if this is a VGA compatible controller or not
 452   //
 453   Status = ParentPciIo->Pci.Read (
 454                           ParentPciIo,
 455                           EfiPciIoWidthUint32,
 456                           0,
 457                           sizeof (Pci) / sizeof (UINT32),
 458                           &Pci
 459                           );
 460   if (EFI_ERROR (Status)) {
 461     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 462       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 463       EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_EC_CONTROLLER_ERROR,
 464       ParentDevicePath
 465       );
 466     goto Done;
 467   }
 468
 469   //
 470   // Initialize the child private structure
 471   //
 472   FbGopPrivate->Signature = FB_VIDEO_DEV_SIGNATURE;
 473
 474   //
 475   // Fill in Graphics Output specific mode structures
 476   //
 477   FbGopPrivate->ModeData              = NULL;
 478
 479   FbGopPrivate->VbeFrameBuffer        = NULL;
 480
 481   FbGopPrivate->EdidDiscovered.SizeOfEdid  = 0;
 482   FbGopPrivate->EdidDiscovered.Edid        = NULL;
 483   FbGopPrivate->EdidActive.SizeOfEdid      = 0;
 484   FbGopPrivate->EdidActive.Edid            = NULL;
 485
 486   //
 487   // Fill in the Graphics Output Protocol
 488   //
 489   FbGopPrivate->GraphicsOutput.QueryMode = FbGopGraphicsOutputQueryMode;
 490   FbGopPrivate->GraphicsOutput.SetMode   = FbGopGraphicsOutputSetMode;
 491
 492
 493   //
 494   // Allocate buffer for Graphics Output Protocol mode information
 495   //
 496   FbGopPrivate->GraphicsOutput.Mode = (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *) AllocatePool (
 497                                              sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE)
 498                                              );
 499   if (NULL == FbGopPrivate->GraphicsOutput.Mode) {
 500     Status = EFI_OUT_OF_RESOURCES;
 501     goto Done;
 502   }
 503
 504   FbGopPrivate->GraphicsOutput.Mode->Info = (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *) AllocatePool (
 505                                              sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)
 506                                              );
 507   if (NULL ==  FbGopPrivate->GraphicsOutput.Mode->Info) {
 508     Status = EFI_OUT_OF_RESOURCES;
 509     goto Done;
 510   }
 511
 512   //
 513   // Set Gop Device Path, here RemainingDevicePath will not be one End of Device Path Node.
 514   //
 515   if ((RemainingDevicePath == NULL) || (!IsDevicePathEnd (RemainingDevicePath))) {
 516     if (RemainingDevicePath == NULL) {
 517       ZeroMem (&AcpiDeviceNode, sizeof (ACPI_ADR_DEVICE_PATH));
 518       AcpiDeviceNode.Header.Type = ACPI_DEVICE_PATH;
 519       AcpiDeviceNode.Header.SubType = ACPI_ADR_DP;
 520       AcpiDeviceNode.ADR = ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA, 0, 0);
 521       SetDevicePathNodeLength (&AcpiDeviceNode.Header, sizeof (ACPI_ADR_DEVICE_PATH));
 522
 523       FbGopPrivate->GopDevicePath = AppendDevicePathNode (
 524                                           ParentDevicePath,
 525                                           (EFI_DEVICE_PATH_PROTOCOL *) &AcpiDeviceNode
 526                                           );
 527     } else {
 528       FbGopPrivate->GopDevicePath = AppendDevicePathNode (ParentDevicePath, RemainingDevicePath);
 529     }
 530
 531     //
 532     // Creat child handle and device path protocol firstly
 533     //
 534     FbGopPrivate->Handle = NULL;
 535     Status = gBS->InstallMultipleProtocolInterfaces (
 536                     &FbGopPrivate->Handle,
 537                     &gEfiDevicePathProtocolGuid,
 538                     FbGopPrivate->GopDevicePath,
 539                     NULL
 540                     );
 541     if (EFI_ERROR (Status)) {
 542       goto Done;
 543     }
 544   }
 545
 546   //
 547   // When check for VBE, PCI I/O protocol is needed, so use parent's protocol interface temporally
 548   //
 549   FbGopPrivate->PciIo                 = ParentPciIo;
 550
 551   //
 552   // Check for VESA BIOS Extensions for modes that are compatible with Graphics Output
 553   //
 554   Status = FbGopCheckForVbe (FbGopPrivate);
 555   DEBUG ((EFI_D_INFO, "FbGopCheckForVbe - %r\n", Status));
 556
 557   if (EFI_ERROR (Status)) {
 558     Status = EFI_UNSUPPORTED;
 559     //goto Done;
 560   }
 561
 562   ProtocolInstalled = FALSE;
 563
 564   //
 565   // Creat child handle and install Graphics Output Protocol,EDID Discovered/Active Protocol
 566   //
 567   Status = gBS->InstallMultipleProtocolInterfaces (
 568                   &FbGopPrivate->Handle,
 569                   &gEfiGraphicsOutputProtocolGuid,
 570                   &FbGopPrivate->GraphicsOutput,
 571                   &gEfiEdidDiscoveredProtocolGuid,
 572                   &FbGopPrivate->EdidDiscovered,
 573                   &gEfiEdidActiveProtocolGuid,
 574                   &FbGopPrivate->EdidActive,
 575                   NULL
 576                   );
 577
 578   if (!EFI_ERROR (Status)) {
 579     //
 580     // Open the Parent Handle for the child
 581     //
 582     Status = gBS->OpenProtocol (
 583                     ParentHandle,
 584                     &gEfiPciIoProtocolGuid,
 585                     (VOID **) &FbGopPrivate->PciIo,
 586                     This->DriverBindingHandle,
 587                     FbGopPrivate->Handle,
 588                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 589                     );
 590     if (EFI_ERROR (Status)) {
 591       goto Done;
 592     }
 593     ProtocolInstalled = TRUE;
 594   }
 595
 596 Done:
 597   if (EFI_ERROR (Status)) {
 598     //
 599     // Free private data structure
 600     //
 601     FbGopDeviceReleaseResource (FbGopPrivate);
 602   }
 603
 604   return Status;
 605 }
 606
 607
 608 /**
 609   Deregister an video child handle and free resources.
 610
 611   @param  This                   Protocol instance pointer.
 612   @param  Controller             Video controller handle
 613   @param  Handle                 Video child handle
 614
 615   @return EFI_STATUS
 616
 617 **/
 618 EFI_STATUS
 619 FbGopChildHandleUninstall (
 620   EFI_DRIVER_BINDING_PROTOCOL    *This,
 621   EFI_HANDLE                     Controller,
 622   EFI_HANDLE                     Handle
 623   )
 624 {
 625   EFI_STATUS                    Status;
 626   EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
 627   FB_VIDEO_DEV                 *FbGopPrivate;
 628   EFI_PCI_IO_PROTOCOL          *PciIo;
 629
 630   FbGopPrivate     = NULL;
 631   GraphicsOutput   = NULL;
 632   PciIo            = NULL;
 633   Status           = EFI_UNSUPPORTED;
 634
 635   Status = gBS->OpenProtocol (
 636                   Handle,
 637                   &gEfiGraphicsOutputProtocolGuid,
 638                   (VOID **) &GraphicsOutput,
 639                   This->DriverBindingHandle,
 640                   Handle,
 641                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 642                   );
 643   if (!EFI_ERROR (Status)) {
 644       FbGopPrivate = FB_VIDEO_DEV_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput);
 645   }
 646
 647   if (FbGopPrivate == NULL) {
 648     return EFI_UNSUPPORTED;
 649   }
 650
 651   //
 652   // Close PCI I/O protocol that opened by child handle
 653   //
 654   Status = gBS->CloseProtocol (
 655                   Controller,
 656                   &gEfiPciIoProtocolGuid,
 657                   This->DriverBindingHandle,
 658                   Handle
 659                   );
 660
 661   //
 662   // Uninstall protocols on child handle
 663   //
 664   Status = gBS->UninstallMultipleProtocolInterfaces (
 665                     FbGopPrivate->Handle,
 666                     &gEfiDevicePathProtocolGuid,
 667                     FbGopPrivate->GopDevicePath,
 668                     &gEfiGraphicsOutputProtocolGuid,
 669                     &FbGopPrivate->GraphicsOutput,
 670                     NULL
 671                     );
 672
 673   if (EFI_ERROR (Status)) {
 674     gBS->OpenProtocol (
 675            Controller,
 676            &gEfiPciIoProtocolGuid,
 677            (VOID **) &PciIo,
 678            This->DriverBindingHandle,
 679            Handle,
 680            EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 681            );
 682     return Status;
 683   }
 684
 685   //
 686   // Release all allocated resources
 687   //
 688   FbGopDeviceReleaseResource (FbGopPrivate);
 689
 690   return EFI_SUCCESS;
 691 }
 692
 693
 694 /**
 695   Release resource for biso video instance.
 696
 697   @param  FbGopPrivate       Video child device private data structure
 698
 699 **/
 700 VOID
 701 FbGopDeviceReleaseResource (
 702   FB_VIDEO_DEV  *FbGopPrivate
 703   )
 704 {
 705   if (FbGopPrivate == NULL) {
 706     return ;
 707   }
 708
 709   //
 710   // Release all the resourses occupied by the FB_VIDEO_DEV
 711   //
 712
 713   //
 714   // Free VBE Frame Buffer
 715   //
 716   if (FbGopPrivate->VbeFrameBuffer != NULL) {
 717     FreePool (FbGopPrivate->VbeFrameBuffer);
 718   }
 719
 720   //
 721   // Free mode data
 722   //
 723   if (FbGopPrivate->ModeData != NULL) {
 724     FreePool (FbGopPrivate->ModeData);
 725   }
 726
 727   //
 728   // Free graphics output protocol occupied resource
 729   //
 730   if (FbGopPrivate->GraphicsOutput.Mode != NULL) {
 731     if (FbGopPrivate->GraphicsOutput.Mode->Info != NULL) {
 732         FreePool (FbGopPrivate->GraphicsOutput.Mode->Info);
 733         FbGopPrivate->GraphicsOutput.Mode->Info = NULL;
 734     }
 735     FreePool (FbGopPrivate->GraphicsOutput.Mode);
 736     FbGopPrivate->GraphicsOutput.Mode = NULL;
 737   }
 738
 739   if (FbGopPrivate->GopDevicePath!= NULL) {
 740     FreePool (FbGopPrivate->GopDevicePath);
 741   }
 742
 743   FreePool (FbGopPrivate);
 744
 745   return ;
 746 }
 747
 748
 749
 750 /**
 751   Check if all video child handles have been uninstalled.
 752
 753   @param  Controller             Video controller handle
 754
 755   @return TRUE                   Child handles exist.
 756   @return FALSE                  All video child handles have been uninstalled.
 757
 758 **/
 759 BOOLEAN
 760 HasChildHandle (
 761   IN EFI_HANDLE  Controller
 762   )
 763 {
 764   UINTN                                Index;
 765   EFI_OPEN_PROTOCOL_INFORMATION_ENTRY  *OpenInfoBuffer;
 766   UINTN                                EntryCount;
 767   BOOLEAN                              HasChild;
 768   EFI_STATUS                           Status;
 769
 770   EntryCount = 0;
 771   HasChild   = FALSE;
 772   Status = gBS->OpenProtocolInformation (
 773                   Controller,
 774                   &gEfiPciIoProtocolGuid,
 775                   &OpenInfoBuffer,
 776                   &EntryCount
 777                   );
 778   for (Index = 0; Index < EntryCount; Index++) {
 779     if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
 780       HasChild = TRUE;
 781     }
 782   }
 783
 784   return HasChild;
 785 }
 786
 787 /**
 788   Check for VBE device.
 789
 790   @param  FbGopPrivate       Pointer to FB_VIDEO_DEV structure
 791
 792   @retval EFI_SUCCESS            VBE device found
 793
 794 **/
 795 EFI_STATUS
 796 FbGopCheckForVbe (
 797   IN OUT FB_VIDEO_DEV  *FbGopPrivate
 798   )
 799 {
 800   EFI_STATUS                             Status;
 801   FB_VIDEO_MODE_DATA                     *ModeBuffer;
 802   FB_VIDEO_MODE_DATA                     *CurrentModeData;
 803   UINTN                                  ModeNumber;
 804   UINTN                                  BitsPerPixel;
 805   UINTN                                  BytesPerScanLine;
 806   UINT32                                 HorizontalResolution;
 807   UINT32                                 VerticalResolution;
 808   EFI_GRAPHICS_OUTPUT_BLT_PIXEL          *VbeFrameBuffer;
 809   EFI_HOB_GUID_TYPE                      *GuidHob;
 810   FRAME_BUFFER_INFO                      *pFbInfo;
 811
 812   Status = EFI_SUCCESS;
 813   //
 814   // Find the frame buffer information guid hob
 815   //
 816   GuidHob = GetFirstGuidHob (&gUefiFrameBufferInfoGuid);
 817   ASSERT (GuidHob != NULL);
 818   pFbInfo = (FRAME_BUFFER_INFO *)GET_GUID_HOB_DATA (GuidHob);
 819
 820   //
 821   // Add mode to the list of available modes
 822   //
 823   VbeFrameBuffer = NULL;
 824   ModeBuffer     = NULL;
 825
 826   ModeNumber           = 1;
 827   BitsPerPixel         = pFbInfo->BitsPerPixel;
 828   HorizontalResolution = pFbInfo->HorizontalResolution;
 829   VerticalResolution   = pFbInfo->VerticalResolution;
 830   BytesPerScanLine     = HorizontalResolution * (BitsPerPixel / 8);
 831
 832   ModeBuffer = (FB_VIDEO_MODE_DATA *) AllocatePool (
 833                                                                                                                                                                                 ModeNumber * sizeof (FB_VIDEO_MODE_DATA)
 834                                                                                                                                                         );
 835   if (NULL == ModeBuffer) {
 836           Status = EFI_OUT_OF_RESOURCES;
 837     goto Done;
 838   }
 839
 840   VbeFrameBuffer =
 841                         (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) AllocatePool (
 842                                                                                                                                                                         BytesPerScanLine * VerticalResolution
 843                                                                                                                                                                   );
 844   if (NULL == VbeFrameBuffer) {
 845           Status = EFI_OUT_OF_RESOURCES;
 846     goto Done;
 847   }
 848
 849   if (FbGopPrivate->ModeData != NULL) {
 850     FreePool (FbGopPrivate->ModeData);
 851   }
 852
 853   if (FbGopPrivate->VbeFrameBuffer != NULL) {
 854     FreePool (FbGopPrivate->VbeFrameBuffer);
 855   }
 856
 857   CurrentModeData = &ModeBuffer[ModeNumber - 1];
 858   CurrentModeData->BytesPerScanLine = (UINT16)BytesPerScanLine;
 859
 860   CurrentModeData->Red      = *(FB_VIDEO_COLOR_PLACEMENT *)&(pFbInfo->Red);
 861   CurrentModeData->Blue     = *(FB_VIDEO_COLOR_PLACEMENT *)&(pFbInfo->Blue);
 862   CurrentModeData->Green    = *(FB_VIDEO_COLOR_PLACEMENT *)&(pFbInfo->Green);
 863   CurrentModeData->Reserved = *(FB_VIDEO_COLOR_PLACEMENT *)&(pFbInfo->Reserved);
 864
 865   CurrentModeData->BitsPerPixel    = (UINT32)BitsPerPixel;
 866   CurrentModeData->HorizontalResolution = HorizontalResolution;
 867   CurrentModeData->VerticalResolution   = VerticalResolution;
 868   CurrentModeData->FrameBufferSize = CurrentModeData->BytesPerScanLine * CurrentModeData->VerticalResolution;
 869   CurrentModeData->LinearFrameBuffer = (VOID *) (UINTN) pFbInfo->LinearFrameBuffer;
 870   CurrentModeData->VbeModeNumber        = 0;
 871   CurrentModeData->ColorDepth           = 32;
 872   CurrentModeData->RefreshRate          = 60;
 873
 874   CurrentModeData->PixelFormat = PixelBitMask;
 875   if ((CurrentModeData->BitsPerPixel == 32) &&
 876       (CurrentModeData->Red.Mask == 0xff) && (CurrentModeData->Green.Mask == 0xff) && (CurrentModeData->Blue.Mask == 0xff)) {
 877     if ((CurrentModeData->Red.Position == 0) && (CurrentModeData->Green.Position == 8) && (CurrentModeData->Blue.Position == 16)) {
 878       CurrentModeData->PixelFormat = PixelRedGreenBlueReserved8BitPerColor;
 879     } else if ((CurrentModeData->Blue.Position == 0) && (CurrentModeData->Green.Position == 8) && (CurrentModeData->Red.Position == 16)) {
 880       CurrentModeData->PixelFormat = PixelBlueGreenRedReserved8BitPerColor;
 881     }
 882   }
 883
 884   CopyMem (&(CurrentModeData->PixelBitMask), &mPixelBitMask, sizeof (EFI_PIXEL_BITMASK));
 885
 886   FbGopPrivate->ModeData       = ModeBuffer;
 887   FbGopPrivate->VbeFrameBuffer = VbeFrameBuffer;
 888
 889   //
 890   // Assign Gop's Blt function
 891   //
 892   FbGopPrivate->GraphicsOutput.Blt     = FbGopGraphicsOutputVbeBlt;
 893
 894   FbGopPrivate->GraphicsOutput.Mode->MaxMode = 1;
 895   FbGopPrivate->GraphicsOutput.Mode->Mode    = 0;
 896   FbGopPrivate->GraphicsOutput.Mode->Info->Version = 0;
 897   FbGopPrivate->GraphicsOutput.Mode->Info->HorizontalResolution = HorizontalResolution;
 898   FbGopPrivate->GraphicsOutput.Mode->Info->VerticalResolution   = VerticalResolution;
 899   FbGopPrivate->GraphicsOutput.Mode->Info->PixelFormat = CurrentModeData->PixelFormat;
 900   CopyMem (&(FbGopPrivate->GraphicsOutput.Mode->Info->PixelInformation), &mPixelBitMask, sizeof (EFI_PIXEL_BITMASK));
 901   FbGopPrivate->GraphicsOutput.Mode->Info->PixelsPerScanLine = HorizontalResolution;
 902   FbGopPrivate->GraphicsOutput.Mode->SizeOfInfo = sizeof(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
 903   FbGopPrivate->GraphicsOutput.Mode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS) (UINTN) CurrentModeData->LinearFrameBuffer;
 904   FbGopPrivate->GraphicsOutput.Mode->FrameBufferSize =  CurrentModeData->FrameBufferSize;
 905
 906   //
 907   // Find the best mode to initialize
 908   //
 909
 910 Done:
 911   //
 912   // If there was an error, then free the mode structure
 913   //
 914   if (EFI_ERROR (Status)) {
 915
 916     if (VbeFrameBuffer != NULL) {
 917       FreePool (VbeFrameBuffer);
 918     }
 919
 920     if (ModeBuffer != NULL) {
 921       FreePool (ModeBuffer);
 922     }
 923   }
 924
 925   return Status;
 926 }
 927
 928
 929 //
 930 // Graphics Output Protocol Member Functions for VESA BIOS Extensions
 931 //
 932
 933 /**
 934   Graphics Output protocol interface to get video mode.
 935
 936   @param  This                   Protocol instance pointer.
 937   @param  ModeNumber             The mode number to return information on.
 938   @param  SizeOfInfo             A pointer to the size, in bytes, of the Info
 939                                  buffer.
 940   @param  Info                   Caller allocated buffer that returns information
 941                                  about ModeNumber.
 942
 943   @retval EFI_SUCCESS            Mode information returned.
 944   @retval EFI_DEVICE_ERROR       A hardware error occurred trying to retrieve the
 945                                  video mode.
 946   @retval EFI_NOT_STARTED        Video display is not initialized. Call SetMode ()
 947   @retval EFI_INVALID_PARAMETER  One of the input args was NULL.
 948
 949 **/
 950 EFI_STATUS
 951 EFIAPI
 952 FbGopGraphicsOutputQueryMode (
 953   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,
 954   IN  UINT32                                ModeNumber,
 955   OUT UINTN                                 *SizeOfInfo,
 956   OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info
 957   )
 958 {
 959   FB_VIDEO_DEV        *FbGopPrivate;
 960   FB_VIDEO_MODE_DATA  *ModeData;
 961
 962   FbGopPrivate = FB_VIDEO_DEV_FROM_GRAPHICS_OUTPUT_THIS (This);
 963
 964   if (This == NULL || Info == NULL || SizeOfInfo == NULL || ModeNumber >= This->Mode->MaxMode) {
 965     return EFI_INVALID_PARAMETER;
 966   }
 967
 968   *Info = (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *) AllocatePool (
 969                                                                                                                                                                                                                 sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)
 970                                                                                                                                                                                                                 );
 971   if (NULL == *Info) {
 972     return EFI_OUT_OF_RESOURCES;
 973   }
 974
 975   *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
 976
 977   ModeData = &FbGopPrivate->ModeData[ModeNumber];
 978   (*Info)->Version = 0;
 979   (*Info)->HorizontalResolution = ModeData->HorizontalResolution;
 980   (*Info)->VerticalResolution   = ModeData->VerticalResolution;
 981   (*Info)->PixelFormat = ModeData->PixelFormat;
 982   CopyMem (&((*Info)->PixelInformation), &(ModeData->PixelBitMask), sizeof(ModeData->PixelBitMask));
 983
 984   (*Info)->PixelsPerScanLine =  (ModeData->BytesPerScanLine * 8) / ModeData->BitsPerPixel;
 985
 986   return EFI_SUCCESS;
 987 }
 988
 989 /**
 990   Graphics Output protocol interface to set video mode.
 991
 992   @param  This                   Protocol instance pointer.
 993   @param  ModeNumber             The mode number to be set.
 994
 995   @retval EFI_SUCCESS            Graphics mode was changed.
 996   @retval EFI_DEVICE_ERROR       The device had an error and could not complete the
 997                                  request.
 998   @retval EFI_UNSUPPORTED        ModeNumber is not supported by this device.
 999
1000 **/
1001 EFI_STATUS
1002 EFIAPI
1003 FbGopGraphicsOutputSetMode (
1004   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL * This,
1005   IN  UINT32                       ModeNumber
1006   )
1007 {
1008   FB_VIDEO_DEV          *FbGopPrivate;
1009   FB_VIDEO_MODE_DATA    *ModeData;
1010   EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background;
1011
1012   if (This == NULL) {
1013     return EFI_INVALID_PARAMETER;
1014   }
1015
1016   FbGopPrivate = FB_VIDEO_DEV_FROM_GRAPHICS_OUTPUT_THIS (This);
1017
1018   ModeData = &FbGopPrivate->ModeData[ModeNumber];
1019
1020   if (ModeNumber >= This->Mode->MaxMode) {
1021     return EFI_UNSUPPORTED;
1022   }
1023
1024   if (ModeNumber == This->Mode->Mode) {
1025     //
1026     // Clear screen to black
1027     //
1028     ZeroMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
1029     FbGopGraphicsOutputVbeBlt (
1030                         This,
1031                         &Background,
1032                         EfiBltVideoFill,
1033                         0,
1034                         0,
1035                         0,
1036                         0,
1037                         ModeData->HorizontalResolution,
1038                         ModeData->VerticalResolution,
1039                         0
1040     );
1041     return EFI_SUCCESS;
1042   } else {
1043     return EFI_UNSUPPORTED;
1044   }
1045
1046 }
1047
1048 /**
1049   Update physical frame buffer, copy 4 bytes block, then copy remaining bytes.
1050
1051   @param   PciIo              The pointer of EFI_PCI_IO_PROTOCOL
1052   @param   VbeBuffer          The data to transfer to screen
1053   @param   MemAddress         Physical frame buffer base address
1054   @param   DestinationX       The X coordinate of the destination for BltOperation
1055   @param   DestinationY       The Y coordinate of the destination for BltOperation
1056   @param   TotalBytes         The total bytes of copy
1057   @param   VbePixelWidth      Bytes per pixel
1058   @param   BytesPerScanLine   Bytes per scan line
1059
1060 **/
1061 VOID
1062 CopyVideoBuffer (
1063   IN  EFI_PCI_IO_PROTOCOL   *PciIo,
1064   IN  UINT8                 *VbeBuffer,
1065   IN  VOID                  *MemAddress,
1066   IN  UINTN                 DestinationX,
1067   IN  UINTN                 DestinationY,
1068   IN  UINTN                 TotalBytes,
1069   IN  UINT32                VbePixelWidth,
1070   IN  UINTN                 BytesPerScanLine
1071   )
1072 {
1073   UINTN                 FrameBufferAddr;
1074   UINTN                 CopyBlockNum;
1075   UINTN                 RemainingBytes;
1076   UINTN                 UnalignedBytes;
1077   EFI_STATUS            Status;
1078
1079   FrameBufferAddr = (UINTN) MemAddress + (DestinationY * BytesPerScanLine) + DestinationX * VbePixelWidth;
1080
1081   //
1082   // If TotalBytes is less than 4 bytes, only start byte copy.
1083   //
1084   if (TotalBytes < 4) {
1085     Status = PciIo->Mem.Write (
1086                      PciIo,
1087                      EfiPciIoWidthUint8,
1088                      EFI_PCI_IO_PASS_THROUGH_BAR,
1089                      (UINT64) FrameBufferAddr,
1090                      TotalBytes,
1091                      VbeBuffer
1092                      );
1093     ASSERT_EFI_ERROR (Status);
1094     return;
1095   }
1096
1097   //
1098   // If VbeBuffer is not 4-byte aligned, start byte copy.
1099   //
1100   UnalignedBytes  = (4 - ((UINTN) VbeBuffer & 0x3)) & 0x3;
1101
1102   if (UnalignedBytes != 0) {
1103     Status = PciIo->Mem.Write (
1104                      PciIo,
1105                      EfiPciIoWidthUint8,
1106                      EFI_PCI_IO_PASS_THROUGH_BAR,
1107                      (UINT64) FrameBufferAddr,
1108                      UnalignedBytes,
1109                      VbeBuffer
1110                      );
1111     ASSERT_EFI_ERROR (Status);
1112     FrameBufferAddr += UnalignedBytes;
1113     VbeBuffer       += UnalignedBytes;
1114   }
1115
1116   //
1117   // Calculate 4-byte block count and remaining bytes.
1118   //
1119   CopyBlockNum   = (TotalBytes - UnalignedBytes) >> 2;
1120   RemainingBytes = (TotalBytes - UnalignedBytes) &  3;
1121
1122   //
1123   // Copy 4-byte block and remaining bytes to physical frame buffer.
1124   //
1125   if (CopyBlockNum != 0) {
1126     Status = PciIo->Mem.Write (
1127                     PciIo,
1128                     EfiPciIoWidthUint32,
1129                     EFI_PCI_IO_PASS_THROUGH_BAR,
1130                     (UINT64) FrameBufferAddr,
1131                     CopyBlockNum,
1132                     VbeBuffer
1133                     );
1134     ASSERT_EFI_ERROR (Status);
1135   }
1136
1137   if (RemainingBytes != 0) {
1138     FrameBufferAddr += (CopyBlockNum << 2);
1139     VbeBuffer       += (CopyBlockNum << 2);
1140     Status = PciIo->Mem.Write (
1141                     PciIo,
1142                     EfiPciIoWidthUint8,
1143                     EFI_PCI_IO_PASS_THROUGH_BAR,
1144                     (UINT64) FrameBufferAddr,
1145                     RemainingBytes,
1146                     VbeBuffer
1147                     );
1148     ASSERT_EFI_ERROR (Status);
1149   }
1150 }
1151
1152 /**
1153   Worker function to block transfer for VBE device.
1154
1155   @param  FbGopPrivate       Instance of FB_VIDEO_DEV
1156   @param  BltBuffer              The data to transfer to screen
1157   @param  BltOperation           The operation to perform
1158   @param  SourceX                The X coordinate of the source for BltOperation
1159   @param  SourceY                The Y coordinate of the source for BltOperation
1160   @param  DestinationX           The X coordinate of the destination for
1161                                  BltOperation
1162   @param  DestinationY           The Y coordinate of the destination for
1163                                  BltOperation
1164   @param  Width                  The width of a rectangle in the blt rectangle in
1165                                  pixels
1166   @param  Height                 The height of a rectangle in the blt rectangle in
1167                                  pixels
1168   @param  Delta                  Not used for EfiBltVideoFill and
1169                                  EfiBltVideoToVideo operation. If a Delta of 0 is
1170                                  used, the entire BltBuffer will be operated on. If
1171                                  a subrectangle of the BltBuffer is used, then
1172                                  Delta represents the number of bytes in a row of
1173                                  the BltBuffer.
1174   @param  Mode                   Mode data.
1175
1176   @retval EFI_INVALID_PARAMETER  Invalid parameter passed in
1177   @retval EFI_SUCCESS            Blt operation success
1178
1179 **/
1180 EFI_STATUS
1181 FbGopVbeBltWorker (
1182   IN  FB_VIDEO_DEV                       *FbGopPrivate,
1183   IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL      *BltBuffer, OPTIONAL
1184   IN  EFI_GRAPHICS_OUTPUT_BLT_OPERATION  BltOperation,
1185   IN  UINTN                              SourceX,
1186   IN  UINTN                              SourceY,
1187   IN  UINTN                              DestinationX,
1188   IN  UINTN                              DestinationY,
1189   IN  UINTN                              Width,
1190   IN  UINTN                              Height,
1191   IN  UINTN                              Delta,
1192   IN  FB_VIDEO_MODE_DATA               *Mode
1193   )
1194 {
1195   EFI_PCI_IO_PROTOCOL            *PciIo;
1196   EFI_TPL                        OriginalTPL;
1197   UINTN                          DstY;
1198   UINTN                          SrcY;
1199   UINTN                          DstX;
1200   EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *Blt;
1201   VOID                           *MemAddress;
1202   EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *VbeFrameBuffer;
1203   UINTN                          BytesPerScanLine;
1204   UINTN                          Index;
1205   UINT8                          *VbeBuffer;
1206   UINT8                          *VbeBuffer1;
1207   UINT8                          *BltUint8;
1208   UINT32                         VbePixelWidth;
1209   UINT32                         Pixel;
1210   UINTN                          TotalBytes;
1211
1212   PciIo             = FbGopPrivate->PciIo;
1213
1214   VbeFrameBuffer    = FbGopPrivate->VbeFrameBuffer;
1215   MemAddress        = Mode->LinearFrameBuffer;
1216   BytesPerScanLine  = Mode->BytesPerScanLine;
1217   VbePixelWidth     = Mode->BitsPerPixel / 8;
1218   BltUint8          = (UINT8 *) BltBuffer;
1219   TotalBytes        = Width * VbePixelWidth;
1220
1221   if (((UINTN) BltOperation) >= EfiGraphicsOutputBltOperationMax) {
1222     return EFI_INVALID_PARAMETER;
1223   }
1224
1225   if (Width == 0 || Height == 0) {
1226     return EFI_INVALID_PARAMETER;
1227   }
1228   //
1229   // We need to fill the Virtual Screen buffer with the blt data.
1230   // The virtual screen is upside down, as the first row is the bootom row of
1231   // the image.
1232   //
1233   if (BltOperation == EfiBltVideoToBltBuffer) {
1234     //
1235     // Video to BltBuffer: Source is Video, destination is BltBuffer
1236     //
1237     if (SourceY + Height > Mode->VerticalResolution) {
1238       return EFI_INVALID_PARAMETER;
1239     }
1240
1241     if (SourceX + Width > Mode->HorizontalResolution) {
1242       return EFI_INVALID_PARAMETER;
1243     }
1244   } else {
1245     //
1246     // BltBuffer to Video: Source is BltBuffer, destination is Video
1247     //
1248     if (DestinationY + Height > Mode->VerticalResolution) {
1249       return EFI_INVALID_PARAMETER;
1250     }
1251
1252     if (DestinationX + Width > Mode->HorizontalResolution) {
1253       return EFI_INVALID_PARAMETER;
1254     }
1255   }
1256   //
1257   // If Delta is zero, then the entire BltBuffer is being used, so Delta
1258   // is the number of bytes in each row of BltBuffer.  Since BltBuffer is Width pixels size,
1259   // the number of bytes in each row can be computed.
1260   //
1261   if (Delta == 0) {
1262     Delta = Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
1263   }
1264   //
1265   // We have to raise to TPL Notify, so we make an atomic write the frame buffer.
1266   // We would not want a timer based event (Cursor, ...) to come in while we are
1267   // doing this operation.
1268   //
1269   OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY);
1270
1271   switch (BltOperation) {
1272   case EfiBltVideoToBltBuffer:
1273     for (SrcY = SourceY, DstY = DestinationY; DstY < (Height + DestinationY); SrcY++, DstY++) {
1274       Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) (BltUint8 + DstY * Delta + DestinationX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
1275       //
1276       // Shuffle the packed bytes in the hardware buffer to match EFI_GRAPHICS_OUTPUT_BLT_PIXEL
1277       //
1278       VbeBuffer = ((UINT8 *) VbeFrameBuffer + (SrcY * BytesPerScanLine + SourceX * VbePixelWidth));
1279       for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
1280         Pixel         = VbeBuffer[0] | VbeBuffer[1] << 8 | VbeBuffer[2] << 16 | VbeBuffer[3] << 24;
1281         Blt->Red      = (UINT8) ((Pixel >> Mode->Red.Position) & Mode->Red.Mask);
1282         Blt->Blue     = (UINT8) ((Pixel >> Mode->Blue.Position) & Mode->Blue.Mask);
1283         Blt->Green    = (UINT8) ((Pixel >> Mode->Green.Position) & Mode->Green.Mask);
1284         Blt->Reserved = 0;
1285         Blt++;
1286         VbeBuffer += VbePixelWidth;
1287       }
1288
1289     }
1290     break;
1291
1292   case EfiBltVideoToVideo:
1293     for (Index = 0; Index < Height; Index++) {
1294       if (DestinationY <= SourceY) {
1295         SrcY  = SourceY + Index;
1296         DstY  = DestinationY + Index;
1297       } else {
1298         SrcY  = SourceY + Height - Index - 1;
1299         DstY  = DestinationY + Height - Index - 1;
1300       }
1301
1302       VbeBuffer   = ((UINT8 *) VbeFrameBuffer + DstY * BytesPerScanLine + DestinationX * VbePixelWidth);
1303       VbeBuffer1  = ((UINT8 *) VbeFrameBuffer + SrcY * BytesPerScanLine + SourceX * VbePixelWidth);
1304
1305       gBS->CopyMem (
1306             VbeBuffer,
1307             VbeBuffer1,
1308             TotalBytes
1309             );
1310
1311       //
1312       // Update physical frame buffer.
1313       //
1314       CopyVideoBuffer (
1315         PciIo,
1316         VbeBuffer,
1317         MemAddress,
1318         DestinationX,
1319         DstY,
1320         TotalBytes,
1321         VbePixelWidth,
1322         BytesPerScanLine
1323         );
1324     }
1325     break;
1326
1327   case EfiBltVideoFill:
1328     VbeBuffer = (UINT8 *) ((UINTN) VbeFrameBuffer + (DestinationY * BytesPerScanLine) + DestinationX * VbePixelWidth);
1329     Blt       = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) BltUint8;
1330     //
1331     // Shuffle the RGB fields in EFI_GRAPHICS_OUTPUT_BLT_PIXEL to match the hardware buffer
1332     //
1333     Pixel = ((Blt->Red & Mode->Red.Mask) << Mode->Red.Position) |
1334       (
1335         (Blt->Green & Mode->Green.Mask) <<
1336         Mode->Green.Position
1337       ) |
1338           ((Blt->Blue & Mode->Blue.Mask) << Mode->Blue.Position);
1339
1340     for (Index = 0; Index < Width; Index++) {
1341       gBS->CopyMem (
1342             VbeBuffer,
1343             &Pixel,
1344             VbePixelWidth
1345             );
1346       VbeBuffer += VbePixelWidth;
1347     }
1348
1349     VbeBuffer = (UINT8 *) ((UINTN) VbeFrameBuffer + (DestinationY * BytesPerScanLine) + DestinationX * VbePixelWidth);
1350     for (DstY = DestinationY + 1; DstY < (Height + DestinationY); DstY++) {
1351       gBS->CopyMem (
1352             (VOID *) ((UINTN) VbeFrameBuffer + (DstY * BytesPerScanLine) + DestinationX * VbePixelWidth),
1353             VbeBuffer,
1354             TotalBytes
1355             );
1356     }
1357
1358     for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) {
1359       //
1360       // Update physical frame buffer.
1361       //
1362       CopyVideoBuffer (
1363         PciIo,
1364         VbeBuffer,
1365         MemAddress,
1366         DestinationX,
1367         DstY,
1368         TotalBytes,
1369         VbePixelWidth,
1370         BytesPerScanLine
1371         );
1372     }
1373     break;
1374
1375   case EfiBltBufferToVideo:
1376     for (SrcY = SourceY, DstY = DestinationY; SrcY < (Height + SourceY); SrcY++, DstY++) {
1377       Blt       = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) (BltUint8 + (SrcY * Delta) + (SourceX) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
1378       VbeBuffer = ((UINT8 *) VbeFrameBuffer + (DstY * BytesPerScanLine + DestinationX * VbePixelWidth));
1379       for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
1380         //
1381         // Shuffle the RGB fields in EFI_GRAPHICS_OUTPUT_BLT_PIXEL to match the hardware buffer
1382         //
1383         Pixel = ((Blt->Red & Mode->Red.Mask) << Mode->Red.Position) |
1384           ((Blt->Green & Mode->Green.Mask) << Mode->Green.Position) |
1385             ((Blt->Blue & Mode->Blue.Mask) << Mode->Blue.Position);
1386         gBS->CopyMem (
1387               VbeBuffer,
1388               &Pixel,
1389               VbePixelWidth
1390               );
1391         Blt++;
1392         VbeBuffer += VbePixelWidth;
1393       }
1394
1395       VbeBuffer = ((UINT8 *) VbeFrameBuffer + (DstY * BytesPerScanLine + DestinationX * VbePixelWidth));
1396
1397       //
1398       // Update physical frame buffer.
1399       //
1400       CopyVideoBuffer (
1401         PciIo,
1402         VbeBuffer,
1403         MemAddress,
1404         DestinationX,
1405         DstY,
1406         TotalBytes,
1407         VbePixelWidth,
1408         BytesPerScanLine
1409         );
1410     }
1411     break;
1412
1413     default: ;
1414   }
1415
1416   gBS->RestoreTPL (OriginalTPL);
1417
1418   return EFI_SUCCESS;
1419 }
1420
1421 /**
1422   Graphics Output protocol instance to block transfer for VBE device.
1423
1424   @param  This                   Pointer to Graphics Output protocol instance
1425   @param  BltBuffer              The data to transfer to screen
1426   @param  BltOperation           The operation to perform
1427   @param  SourceX                The X coordinate of the source for BltOperation
1428   @param  SourceY                The Y coordinate of the source for BltOperation
1429   @param  DestinationX           The X coordinate of the destination for
1430                                  BltOperation
1431   @param  DestinationY           The Y coordinate of the destination for
1432                                  BltOperation
1433   @param  Width                  The width of a rectangle in the blt rectangle in
1434                                  pixels
1435   @param  Height                 The height of a rectangle in the blt rectangle in
1436                                  pixels
1437   @param  Delta                  Not used for EfiBltVideoFill and
1438                                  EfiBltVideoToVideo operation. If a Delta of 0 is
1439                                  used, the entire BltBuffer will be operated on. If
1440                                  a subrectangle of the BltBuffer is used, then
1441                                  Delta represents the number of bytes in a row of
1442                                  the BltBuffer.
1443
1444   @retval EFI_INVALID_PARAMETER  Invalid parameter passed in
1445   @retval EFI_SUCCESS            Blt operation success
1446
1447 **/
1448 EFI_STATUS
1449 EFIAPI
1450 FbGopGraphicsOutputVbeBlt (
1451   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL       *This,
1452   IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL      *BltBuffer, OPTIONAL
1453   IN  EFI_GRAPHICS_OUTPUT_BLT_OPERATION  BltOperation,
1454   IN  UINTN                              SourceX,
1455   IN  UINTN                              SourceY,
1456   IN  UINTN                              DestinationX,
1457   IN  UINTN                              DestinationY,
1458   IN  UINTN                              Width,
1459   IN  UINTN                              Height,
1460   IN  UINTN                              Delta
1461   )
1462 {
1463   FB_VIDEO_DEV                 *FbGopPrivate;
1464   FB_VIDEO_MODE_DATA           *Mode;
1465
1466   if (This == NULL) {
1467     return EFI_INVALID_PARAMETER;
1468   }
1469
1470   FbGopPrivate  = FB_VIDEO_DEV_FROM_GRAPHICS_OUTPUT_THIS (This);
1471   Mode          = &FbGopPrivate->ModeData[This->Mode->Mode];
1472
1473   return FbGopVbeBltWorker (
1474            FbGopPrivate,
1475            BltBuffer,
1476            BltOperation,
1477            SourceX,
1478            SourceY,
1479            DestinationX,
1480            DestinationY,
1481            Width,
1482            Height,
1483            Delta,
1484            Mode
1485            );
1486 }
1487
1488
1489 /**
1490   The user Entry Point for module UefiFbGop. The user code starts with this function.
1491
1492   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
1493   @param[in] SystemTable    A pointer to the EFI System Table.
1494
1495   @retval EFI_SUCCESS       The entry point is executed successfully.
1496   @retval other             Some error occurs when executing this entry point.
1497
1498 **/
1499 EFI_STATUS
1500 EFIAPI
1501 FbGopEntryPoint(
1502   IN EFI_HANDLE           ImageHandle,
1503   IN EFI_SYSTEM_TABLE     *SystemTable
1504   )
1505 {
1506   EFI_STATUS  Status;
1507   EFI_HOB_GUID_TYPE  *GuidHob;
1508
1509   //
1510   // Find the frame buffer information guid hob
1511   //
1512   GuidHob = GetFirstGuidHob (&gUefiFrameBufferInfoGuid);
1513   if (GuidHob != NULL) {
1514     //
1515     // Install driver model protocol(s).
1516     //
1517     Status = EfiLibInstallDriverBindingComponentName2 (
1518                ImageHandle,
1519                SystemTable,
1520                &gFbGopDriverBinding,
1521                ImageHandle,
1522                &gFbGopComponentName,
1523                &gFbGopComponentName2
1524                );
1525     ASSERT_EFI_ERROR (Status);
1526   } else {
1527     DEBUG ((EFI_D_ERROR, "No FrameBuffer information from coreboot.  NO GOP driver !!!\n"));
1528     Status = EFI_ABORTED;
1529   }
1530   return Status;
1531 }
1532