OvmfPkg/QemuVideoDxe/Driver.c

   1 /** @file
   2   This driver is a sample implementation of the Graphics Output Protocol for
   3   the QEMU (Cirrus Logic 5446) video controller.
   4
   5   Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
   6
   7   This program and the accompanying materials
   8   are licensed and made available under the terms and conditions of the BSD License
   9   which accompanies this distribution. The 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 "Qemu.h"
  18 #include <IndustryStandard/Acpi.h>
  19
  20 EFI_DRIVER_BINDING_PROTOCOL gQemuVideoDriverBinding = {
  21   QemuVideoControllerDriverSupported,
  22   QemuVideoControllerDriverStart,
  23   QemuVideoControllerDriverStop,
  24   0x10,
  25   NULL,
  26   NULL
  27 };
  28
  29 QEMU_VIDEO_CARD gQemuVideoCardList[] = {
  30     {
  31         CIRRUS_LOGIC_VENDOR_ID,
  32         CIRRUS_LOGIC_5430_DEVICE_ID,
  33         QEMU_VIDEO_CIRRUS_5430,
  34         L"Cirrus 5430"
  35     },{
  36         CIRRUS_LOGIC_VENDOR_ID,
  37         CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID,
  38         QEMU_VIDEO_CIRRUS_5430,
  39         L"Cirrus 5430"
  40     },{
  41         CIRRUS_LOGIC_VENDOR_ID,
  42         CIRRUS_LOGIC_5446_DEVICE_ID,
  43         QEMU_VIDEO_CIRRUS_5446,
  44         L"Cirrus 5446"
  45     },{
  46         0x1234,
  47         0x1111,
  48         QEMU_VIDEO_BOCHS_MMIO,
  49         L"QEMU Standard VGA"
  50     },{
  51         0x1b36,
  52         0x0100,
  53         QEMU_VIDEO_BOCHS,
  54         L"QEMU QXL VGA"
  55     },{
  56         0x1af4,
  57         0x1050,
  58         QEMU_VIDEO_BOCHS_MMIO,
  59         L"QEMU VirtIO VGA"
  60     },{
  61         0 /* end of list */
  62     }
  63 };
  64
  65 static QEMU_VIDEO_CARD*
  66 QemuVideoDetect(
  67   IN UINT16 VendorId,
  68   IN UINT16 DeviceId
  69   )
  70 {
  71   UINTN Index = 0;
  72
  73   while (gQemuVideoCardList[Index].VendorId != 0) {
  74     if (gQemuVideoCardList[Index].VendorId == VendorId &&
  75         gQemuVideoCardList[Index].DeviceId == DeviceId) {
  76       return gQemuVideoCardList + Index;
  77     }
  78     Index++;
  79   }
  80   return NULL;
  81 }
  82
  83 /**
  84   Check if this device is supported.
  85
  86   @param  This                   The driver binding protocol.
  87   @param  Controller             The controller handle to check.
  88   @param  RemainingDevicePath    The remaining device path.
  89
  90   @retval EFI_SUCCESS            The bus supports this controller.
  91   @retval EFI_UNSUPPORTED        This device isn't supported.
  92
  93 **/
  94 EFI_STATUS
  95 EFIAPI
  96 QemuVideoControllerDriverSupported (
  97   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  98   IN EFI_HANDLE                     Controller,
  99   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 100   )
 101 {
 102   EFI_STATUS          Status;
 103   EFI_PCI_IO_PROTOCOL *PciIo;
 104   PCI_TYPE00          Pci;
 105   QEMU_VIDEO_CARD     *Card;
 106
 107   //
 108   // Open the PCI I/O Protocol
 109   //
 110   Status = gBS->OpenProtocol (
 111                   Controller,
 112                   &gEfiPciIoProtocolGuid,
 113                   (VOID **) &PciIo,
 114                   This->DriverBindingHandle,
 115                   Controller,
 116                   EFI_OPEN_PROTOCOL_BY_DRIVER
 117                   );
 118   if (EFI_ERROR (Status)) {
 119     return Status;
 120   }
 121
 122   //
 123   // Read the PCI Configuration Header from the PCI Device
 124   //
 125   Status = PciIo->Pci.Read (
 126                         PciIo,
 127                         EfiPciIoWidthUint32,
 128                         0,
 129                         sizeof (Pci) / sizeof (UINT32),
 130                         &Pci
 131                         );
 132   if (EFI_ERROR (Status)) {
 133     goto Done;
 134   }
 135
 136   Status = EFI_UNSUPPORTED;
 137   if (!IS_PCI_VGA (&Pci)) {
 138     goto Done;
 139   }
 140   Card = QemuVideoDetect(Pci.Hdr.VendorId, Pci.Hdr.DeviceId);
 141   if (Card != NULL) {
 142     DEBUG ((EFI_D_INFO, "QemuVideo: %s detected\n", Card->Name));
 143     Status = EFI_SUCCESS;
 144   }
 145
 146 Done:
 147   //
 148   // Close the PCI I/O Protocol
 149   //
 150   gBS->CloseProtocol (
 151         Controller,
 152         &gEfiPciIoProtocolGuid,
 153         This->DriverBindingHandle,
 154         Controller
 155         );
 156
 157   return Status;
 158 }
 159
 160 /**
 161   Start to process the controller.
 162
 163   @param  This                   The USB bus driver binding instance.
 164   @param  Controller             The controller to check.
 165   @param  RemainingDevicePath    The remaining device patch.
 166
 167   @retval EFI_SUCCESS            The controller is controlled by the usb bus.
 168   @retval EFI_ALREADY_STARTED    The controller is already controlled by the usb
 169                                  bus.
 170   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources.
 171
 172 **/
 173 EFI_STATUS
 174 EFIAPI
 175 QemuVideoControllerDriverStart (
 176   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 177   IN EFI_HANDLE                     Controller,
 178   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 179   )
 180 {
 181   EFI_TPL                           OldTpl;
 182   EFI_STATUS                        Status;
 183   QEMU_VIDEO_PRIVATE_DATA           *Private;
 184   BOOLEAN                           IsQxl;
 185   EFI_DEVICE_PATH_PROTOCOL          *ParentDevicePath;
 186   ACPI_ADR_DEVICE_PATH              AcpiDeviceNode;
 187   PCI_TYPE00                        Pci;
 188   QEMU_VIDEO_CARD                   *Card;
 189   EFI_PCI_IO_PROTOCOL               *ChildPciIo;
 190
 191   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 192
 193   //
 194   // Allocate Private context data for GOP inteface.
 195   //
 196   Private = AllocateZeroPool (sizeof (QEMU_VIDEO_PRIVATE_DATA));
 197   if (Private == NULL) {
 198     Status = EFI_OUT_OF_RESOURCES;
 199     goto RestoreTpl;
 200   }
 201
 202   //
 203   // Set up context record
 204   //
 205   Private->Signature  = QEMU_VIDEO_PRIVATE_DATA_SIGNATURE;
 206
 207   //
 208   // Open PCI I/O Protocol
 209   //
 210   Status = gBS->OpenProtocol (
 211                   Controller,
 212                   &gEfiPciIoProtocolGuid,
 213                   (VOID **) &Private->PciIo,
 214                   This->DriverBindingHandle,
 215                   Controller,
 216                   EFI_OPEN_PROTOCOL_BY_DRIVER
 217                   );
 218   if (EFI_ERROR (Status)) {
 219     goto FreePrivate;
 220   }
 221
 222   //
 223   // Read the PCI Configuration Header from the PCI Device
 224   //
 225   Status = Private->PciIo->Pci.Read (
 226                         Private->PciIo,
 227                         EfiPciIoWidthUint32,
 228                         0,
 229                         sizeof (Pci) / sizeof (UINT32),
 230                         &Pci
 231                         );
 232   if (EFI_ERROR (Status)) {
 233     goto ClosePciIo;
 234   }
 235
 236   //
 237   // Determine card variant.
 238   //
 239   Card = QemuVideoDetect(Pci.Hdr.VendorId, Pci.Hdr.DeviceId);
 240   if (Card == NULL) {
 241     Status = EFI_DEVICE_ERROR;
 242     goto ClosePciIo;
 243   }
 244   Private->Variant = Card->Variant;
 245
 246   //
 247   // IsQxl is based on the detected Card->Variant, which at a later point might
 248   // not match Private->Variant.
 249   //
 250   IsQxl = (BOOLEAN)(Card->Variant == QEMU_VIDEO_BOCHS);
 251
 252   //
 253   // Save original PCI attributes
 254   //
 255   Status = Private->PciIo->Attributes (
 256                     Private->PciIo,
 257                     EfiPciIoAttributeOperationGet,
 258                     0,
 259                     &Private->OriginalPciAttributes
 260                     );
 261
 262   if (EFI_ERROR (Status)) {
 263     goto ClosePciIo;
 264   }
 265
 266   //
 267   // Set new PCI attributes
 268   //
 269   Status = Private->PciIo->Attributes (
 270                             Private->PciIo,
 271                             EfiPciIoAttributeOperationEnable,
 272                             EFI_PCI_DEVICE_ENABLE | EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY | EFI_PCI_IO_ATTRIBUTE_VGA_IO,
 273                             NULL
 274                             );
 275   if (EFI_ERROR (Status)) {
 276     goto ClosePciIo;
 277   }
 278
 279   //
 280   // Check whenever the qemu stdvga mmio bar is present (qemu 1.3+).
 281   //
 282   if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
 283     EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *MmioDesc;
 284
 285     Status = Private->PciIo->GetBarAttributes (
 286                         Private->PciIo,
 287                         PCI_BAR_IDX2,
 288                         NULL,
 289                         (VOID**) &MmioDesc
 290                         );
 291     if (EFI_ERROR (Status) ||
 292         MmioDesc->ResType != ACPI_ADDRESS_SPACE_TYPE_MEM) {
 293       DEBUG ((EFI_D_INFO, "QemuVideo: No mmio bar, fallback to port io\n"));
 294       Private->Variant = QEMU_VIDEO_BOCHS;
 295     } else {
 296       DEBUG ((EFI_D_INFO, "QemuVideo: Using mmio bar @ 0x%lx\n",
 297               MmioDesc->AddrRangeMin));
 298     }
 299
 300     if (!EFI_ERROR (Status)) {
 301       FreePool (MmioDesc);
 302     }
 303   }
 304
 305   //
 306   // Check if accessing the bochs interface works.
 307   //
 308   if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO ||
 309       Private->Variant == QEMU_VIDEO_BOCHS) {
 310     UINT16 BochsId;
 311     BochsId = BochsRead(Private, VBE_DISPI_INDEX_ID);
 312     if ((BochsId & 0xFFF0) != VBE_DISPI_ID0) {
 313       DEBUG ((EFI_D_INFO, "QemuVideo: BochsID mismatch (got 0x%x)\n", BochsId));
 314       Status = EFI_DEVICE_ERROR;
 315       goto RestoreAttributes;
 316     }
 317   }
 318
 319   //
 320   // Get ParentDevicePath
 321   //
 322   Status = gBS->HandleProtocol (
 323                   Controller,
 324                   &gEfiDevicePathProtocolGuid,
 325                   (VOID **) &ParentDevicePath
 326                   );
 327   if (EFI_ERROR (Status)) {
 328     goto RestoreAttributes;
 329   }
 330
 331   //
 332   // Set Gop Device Path
 333   //
 334   ZeroMem (&AcpiDeviceNode, sizeof (ACPI_ADR_DEVICE_PATH));
 335   AcpiDeviceNode.Header.Type = ACPI_DEVICE_PATH;
 336   AcpiDeviceNode.Header.SubType = ACPI_ADR_DP;
 337   AcpiDeviceNode.ADR = ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA, 0, 0);
 338   SetDevicePathNodeLength (&AcpiDeviceNode.Header, sizeof (ACPI_ADR_DEVICE_PATH));
 339
 340   Private->GopDevicePath = AppendDevicePathNode (
 341                                       ParentDevicePath,
 342                                       (EFI_DEVICE_PATH_PROTOCOL *) &AcpiDeviceNode
 343                                       );
 344   if (Private->GopDevicePath == NULL) {
 345     Status = EFI_OUT_OF_RESOURCES;
 346     goto RestoreAttributes;
 347   }
 348
 349   //
 350   // Create new child handle and install the device path protocol on it.
 351   //
 352   Status = gBS->InstallMultipleProtocolInterfaces (
 353                   &Private->Handle,
 354                   &gEfiDevicePathProtocolGuid,
 355                   Private->GopDevicePath,
 356                   NULL
 357                   );
 358   if (EFI_ERROR (Status)) {
 359     goto FreeGopDevicePath;
 360   }
 361
 362   //
 363   // Construct video mode buffer
 364   //
 365   switch (Private->Variant) {
 366   case QEMU_VIDEO_CIRRUS_5430:
 367   case QEMU_VIDEO_CIRRUS_5446:
 368     Status = QemuVideoCirrusModeSetup (Private);
 369     break;
 370   case QEMU_VIDEO_BOCHS_MMIO:
 371   case QEMU_VIDEO_BOCHS:
 372     Status = QemuVideoBochsModeSetup (Private, IsQxl);
 373     break;
 374   default:
 375     ASSERT (FALSE);
 376     Status = EFI_DEVICE_ERROR;
 377     break;
 378   }
 379   if (EFI_ERROR (Status)) {
 380     goto UninstallGopDevicePath;
 381   }
 382
 383   //
 384   // Start the GOP software stack.
 385   //
 386   Status = QemuVideoGraphicsOutputConstructor (Private);
 387   if (EFI_ERROR (Status)) {
 388     goto FreeModeData;
 389   }
 390
 391   Status = gBS->InstallMultipleProtocolInterfaces (
 392                   &Private->Handle,
 393                   &gEfiGraphicsOutputProtocolGuid,
 394                   &Private->GraphicsOutput,
 395                   NULL
 396                   );
 397   if (EFI_ERROR (Status)) {
 398     goto DestructQemuVideoGraphics;
 399   }
 400
 401   //
 402   // Reference parent handle from child handle.
 403   //
 404   Status = gBS->OpenProtocol (
 405                 Controller,
 406                 &gEfiPciIoProtocolGuid,
 407                 (VOID **) &ChildPciIo,
 408                 This->DriverBindingHandle,
 409                 Private->Handle,
 410                 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 411                 );
 412   if (EFI_ERROR (Status)) {
 413     goto UninstallGop;
 414   }
 415
 416 #if defined MDE_CPU_IA32 || defined MDE_CPU_X64
 417   if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO ||
 418       Private->Variant == QEMU_VIDEO_BOCHS) {
 419     InstallVbeShim (Card->Name, Private->GraphicsOutput.Mode->FrameBufferBase);
 420   }
 421 #endif
 422
 423   gBS->RestoreTPL (OldTpl);
 424   return EFI_SUCCESS;
 425
 426 UninstallGop:
 427   gBS->UninstallProtocolInterface (Private->Handle,
 428          &gEfiGraphicsOutputProtocolGuid, &Private->GraphicsOutput);
 429
 430 DestructQemuVideoGraphics:
 431   QemuVideoGraphicsOutputDestructor (Private);
 432
 433 FreeModeData:
 434   FreePool (Private->ModeData);
 435
 436 UninstallGopDevicePath:
 437   gBS->UninstallProtocolInterface (Private->Handle,
 438          &gEfiDevicePathProtocolGuid, Private->GopDevicePath);
 439
 440 FreeGopDevicePath:
 441   FreePool (Private->GopDevicePath);
 442
 443 RestoreAttributes:
 444   Private->PciIo->Attributes (Private->PciIo, EfiPciIoAttributeOperationSet,
 445                     Private->OriginalPciAttributes, NULL);
 446
 447 ClosePciIo:
 448   gBS->CloseProtocol (Controller, &gEfiPciIoProtocolGuid,
 449          This->DriverBindingHandle, Controller);
 450
 451 FreePrivate:
 452   FreePool (Private);
 453
 454 RestoreTpl:
 455   gBS->RestoreTPL (OldTpl);
 456
 457   return Status;
 458 }
 459
 460 /**
 461   Stop this device
 462
 463   @param  This                   The USB bus driver binding protocol.
 464   @param  Controller             The controller to release.
 465   @param  NumberOfChildren       The number of children of this device that
 466                                  opened the controller BY_CHILD.
 467   @param  ChildHandleBuffer      The array of child handle.
 468
 469   @retval EFI_SUCCESS            The controller or children are stopped.
 470   @retval EFI_DEVICE_ERROR       Failed to stop the driver.
 471
 472 **/
 473 EFI_STATUS
 474 EFIAPI
 475 QemuVideoControllerDriverStop (
 476   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 477   IN EFI_HANDLE                     Controller,
 478   IN UINTN                          NumberOfChildren,
 479   IN EFI_HANDLE                     *ChildHandleBuffer
 480   )
 481 {
 482   EFI_GRAPHICS_OUTPUT_PROTOCOL    *GraphicsOutput;
 483
 484   EFI_STATUS                      Status;
 485   QEMU_VIDEO_PRIVATE_DATA  *Private;
 486
 487   if (NumberOfChildren == 0) {
 488     //
 489     // Close the PCI I/O Protocol
 490     //
 491     gBS->CloseProtocol (
 492           Controller,
 493           &gEfiPciIoProtocolGuid,
 494           This->DriverBindingHandle,
 495           Controller
 496           );
 497     return EFI_SUCCESS;
 498   }
 499
 500   //
 501   // free all resources for whose access we need the child handle, because the
 502   // child handle is going away
 503   //
 504   ASSERT (NumberOfChildren == 1);
 505   Status = gBS->OpenProtocol (
 506                   ChildHandleBuffer[0],
 507                   &gEfiGraphicsOutputProtocolGuid,
 508                   (VOID **) &GraphicsOutput,
 509                   This->DriverBindingHandle,
 510                   Controller,
 511                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 512                   );
 513   if (EFI_ERROR (Status)) {
 514     return Status;
 515   }
 516
 517   //
 518   // Get our private context information
 519   //
 520   Private = QEMU_VIDEO_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput);
 521   ASSERT (Private->Handle == ChildHandleBuffer[0]);
 522
 523   QemuVideoGraphicsOutputDestructor (Private);
 524   //
 525   // Remove the GOP protocol interface from the system
 526   //
 527   Status = gBS->UninstallMultipleProtocolInterfaces (
 528                   Private->Handle,
 529                   &gEfiGraphicsOutputProtocolGuid,
 530                   &Private->GraphicsOutput,
 531                   NULL
 532                   );
 533
 534   if (EFI_ERROR (Status)) {
 535     return Status;
 536   }
 537
 538   //
 539   // Restore original PCI attributes
 540   //
 541   Private->PciIo->Attributes (
 542                   Private->PciIo,
 543                   EfiPciIoAttributeOperationSet,
 544                   Private->OriginalPciAttributes,
 545                   NULL
 546                   );
 547
 548   gBS->CloseProtocol (
 549         Controller,
 550         &gEfiPciIoProtocolGuid,
 551         This->DriverBindingHandle,
 552         Private->Handle
 553         );
 554
 555   FreePool (Private->ModeData);
 556   gBS->UninstallProtocolInterface (Private->Handle,
 557          &gEfiDevicePathProtocolGuid, Private->GopDevicePath);
 558   FreePool (Private->GopDevicePath);
 559
 560   //
 561   // Free our instance data
 562   //
 563   gBS->FreePool (Private);
 564
 565   return EFI_SUCCESS;
 566 }
 567
 568 /**
 569   TODO: Add function description
 570
 571   @param  Private TODO: add argument description
 572   @param  Address TODO: add argument description
 573   @param  Data TODO: add argument description
 574
 575   TODO: add return values
 576
 577 **/
 578 VOID
 579 outb (
 580   QEMU_VIDEO_PRIVATE_DATA  *Private,
 581   UINTN                           Address,
 582   UINT8                           Data
 583   )
 584 {
 585   Private->PciIo->Io.Write (
 586                       Private->PciIo,
 587                       EfiPciIoWidthUint8,
 588                       EFI_PCI_IO_PASS_THROUGH_BAR,
 589                       Address,
 590                       1,
 591                       &Data
 592                       );
 593 }
 594
 595 /**
 596   TODO: Add function description
 597
 598   @param  Private TODO: add argument description
 599   @param  Address TODO: add argument description
 600   @param  Data TODO: add argument description
 601
 602   TODO: add return values
 603
 604 **/
 605 VOID
 606 outw (
 607   QEMU_VIDEO_PRIVATE_DATA  *Private,
 608   UINTN                           Address,
 609   UINT16                          Data
 610   )
 611 {
 612   Private->PciIo->Io.Write (
 613                       Private->PciIo,
 614                       EfiPciIoWidthUint16,
 615                       EFI_PCI_IO_PASS_THROUGH_BAR,
 616                       Address,
 617                       1,
 618                       &Data
 619                       );
 620 }
 621
 622 /**
 623   TODO: Add function description
 624
 625   @param  Private TODO: add argument description
 626   @param  Address TODO: add argument description
 627
 628   TODO: add return values
 629
 630 **/
 631 UINT8
 632 inb (
 633   QEMU_VIDEO_PRIVATE_DATA  *Private,
 634   UINTN                           Address
 635   )
 636 {
 637   UINT8 Data;
 638
 639   Private->PciIo->Io.Read (
 640                       Private->PciIo,
 641                       EfiPciIoWidthUint8,
 642                       EFI_PCI_IO_PASS_THROUGH_BAR,
 643                       Address,
 644                       1,
 645                       &Data
 646                       );
 647   return Data;
 648 }
 649
 650 /**
 651   TODO: Add function description
 652
 653   @param  Private TODO: add argument description
 654   @param  Address TODO: add argument description
 655
 656   TODO: add return values
 657
 658 **/
 659 UINT16
 660 inw (
 661   QEMU_VIDEO_PRIVATE_DATA  *Private,
 662   UINTN                           Address
 663   )
 664 {
 665   UINT16  Data;
 666
 667   Private->PciIo->Io.Read (
 668                       Private->PciIo,
 669                       EfiPciIoWidthUint16,
 670                       EFI_PCI_IO_PASS_THROUGH_BAR,
 671                       Address,
 672                       1,
 673                       &Data
 674                       );
 675   return Data;
 676 }
 677
 678 /**
 679   TODO: Add function description
 680
 681   @param  Private TODO: add argument description
 682   @param  Index TODO: add argument description
 683   @param  Red TODO: add argument description
 684   @param  Green TODO: add argument description
 685   @param  Blue TODO: add argument description
 686
 687   TODO: add return values
 688
 689 **/
 690 VOID
 691 SetPaletteColor (
 692   QEMU_VIDEO_PRIVATE_DATA  *Private,
 693   UINTN                           Index,
 694   UINT8                           Red,
 695   UINT8                           Green,
 696   UINT8                           Blue
 697   )
 698 {
 699   VgaOutb (Private, PALETTE_INDEX_REGISTER, (UINT8) Index);
 700   VgaOutb (Private, PALETTE_DATA_REGISTER, (UINT8) (Red >> 2));
 701   VgaOutb (Private, PALETTE_DATA_REGISTER, (UINT8) (Green >> 2));
 702   VgaOutb (Private, PALETTE_DATA_REGISTER, (UINT8) (Blue >> 2));
 703 }
 704
 705 /**
 706   TODO: Add function description
 707
 708   @param  Private TODO: add argument description
 709
 710   TODO: add return values
 711
 712 **/
 713 VOID
 714 SetDefaultPalette (
 715   QEMU_VIDEO_PRIVATE_DATA  *Private
 716   )
 717 {
 718   UINTN Index;
 719   UINTN RedIndex;
 720   UINTN GreenIndex;
 721   UINTN BlueIndex;
 722
 723   Index = 0;
 724   for (RedIndex = 0; RedIndex < 8; RedIndex++) {
 725     for (GreenIndex = 0; GreenIndex < 8; GreenIndex++) {
 726       for (BlueIndex = 0; BlueIndex < 4; BlueIndex++) {
 727         SetPaletteColor (Private, Index, (UINT8) (RedIndex << 5), (UINT8) (GreenIndex << 5), (UINT8) (BlueIndex << 6));
 728         Index++;
 729       }
 730     }
 731   }
 732 }
 733
 734 /**
 735   TODO: Add function description
 736
 737   @param  Private TODO: add argument description
 738
 739   TODO: add return values
 740
 741 **/
 742 VOID
 743 ClearScreen (
 744   QEMU_VIDEO_PRIVATE_DATA  *Private
 745   )
 746 {
 747   UINT32  Color;
 748
 749   Color = 0;
 750   Private->PciIo->Mem.Write (
 751                         Private->PciIo,
 752                         EfiPciIoWidthFillUint32,
 753                         0,
 754                         0,
 755                         0x400000 >> 2,
 756                         &Color
 757                         );
 758 }
 759
 760 /**
 761   TODO: Add function description
 762
 763   @param  Private TODO: add argument description
 764
 765   TODO: add return values
 766
 767 **/
 768 VOID
 769 DrawLogo (
 770   QEMU_VIDEO_PRIVATE_DATA  *Private,
 771   UINTN                           ScreenWidth,
 772   UINTN                           ScreenHeight
 773   )
 774 {
 775 }
 776
 777 /**
 778   TODO: Add function description
 779
 780   @param  Private TODO: add argument description
 781   @param  ModeData TODO: add argument description
 782
 783   TODO: add return values
 784
 785 **/
 786 VOID
 787 InitializeCirrusGraphicsMode (
 788   QEMU_VIDEO_PRIVATE_DATA  *Private,
 789   QEMU_VIDEO_CIRRUS_MODES  *ModeData
 790   )
 791 {
 792   UINT8 Byte;
 793   UINTN Index;
 794
 795   outw (Private, SEQ_ADDRESS_REGISTER, 0x1206);
 796   outw (Private, SEQ_ADDRESS_REGISTER, 0x0012);
 797
 798   for (Index = 0; Index < 15; Index++) {
 799     outw (Private, SEQ_ADDRESS_REGISTER, ModeData->SeqSettings[Index]);
 800   }
 801
 802   if (Private->Variant == QEMU_VIDEO_CIRRUS_5430) {
 803     outb (Private, SEQ_ADDRESS_REGISTER, 0x0f);
 804     Byte = (UINT8) ((inb (Private, SEQ_DATA_REGISTER) & 0xc7) ^ 0x30);
 805     outb (Private, SEQ_DATA_REGISTER, Byte);
 806   }
 807
 808   outb (Private, MISC_OUTPUT_REGISTER, ModeData->MiscSetting);
 809   outw (Private, GRAPH_ADDRESS_REGISTER, 0x0506);
 810   outw (Private, SEQ_ADDRESS_REGISTER, 0x0300);
 811   outw (Private, CRTC_ADDRESS_REGISTER, 0x2011);
 812
 813   for (Index = 0; Index < 28; Index++) {
 814     outw (Private, CRTC_ADDRESS_REGISTER, (UINT16) ((ModeData->CrtcSettings[Index] << 8) | Index));
 815   }
 816
 817   for (Index = 0; Index < 9; Index++) {
 818     outw (Private, GRAPH_ADDRESS_REGISTER, (UINT16) ((GraphicsController[Index] << 8) | Index));
 819   }
 820
 821   inb (Private, INPUT_STATUS_1_REGISTER);
 822
 823   for (Index = 0; Index < 21; Index++) {
 824     outb (Private, ATT_ADDRESS_REGISTER, (UINT8) Index);
 825     outb (Private, ATT_ADDRESS_REGISTER, AttributeController[Index]);
 826   }
 827
 828   outb (Private, ATT_ADDRESS_REGISTER, 0x20);
 829
 830   outw (Private, GRAPH_ADDRESS_REGISTER, 0x0009);
 831   outw (Private, GRAPH_ADDRESS_REGISTER, 0x000a);
 832   outw (Private, GRAPH_ADDRESS_REGISTER, 0x000b);
 833   outb (Private, DAC_PIXEL_MASK_REGISTER, 0xff);
 834
 835   SetDefaultPalette (Private);
 836   ClearScreen (Private);
 837 }
 838
 839 VOID
 840 BochsWrite (
 841   QEMU_VIDEO_PRIVATE_DATA  *Private,
 842   UINT16                   Reg,
 843   UINT16                   Data
 844   )
 845 {
 846   EFI_STATUS   Status;
 847
 848   if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
 849     Status = Private->PciIo->Mem.Write (
 850         Private->PciIo,
 851         EfiPciIoWidthUint16,
 852         PCI_BAR_IDX2,
 853         0x500 + (Reg << 1),
 854         1,
 855         &Data
 856         );
 857     ASSERT_EFI_ERROR (Status);
 858   } else {
 859     outw (Private, VBE_DISPI_IOPORT_INDEX, Reg);
 860     outw (Private, VBE_DISPI_IOPORT_DATA,  Data);
 861   }
 862 }
 863
 864 UINT16
 865 BochsRead (
 866   QEMU_VIDEO_PRIVATE_DATA  *Private,
 867   UINT16                   Reg
 868   )
 869 {
 870   EFI_STATUS   Status;
 871   UINT16       Data;
 872
 873   if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
 874     Status = Private->PciIo->Mem.Read (
 875         Private->PciIo,
 876         EfiPciIoWidthUint16,
 877         PCI_BAR_IDX2,
 878         0x500 + (Reg << 1),
 879         1,
 880         &Data
 881         );
 882     ASSERT_EFI_ERROR (Status);
 883   } else {
 884     outw (Private, VBE_DISPI_IOPORT_INDEX, Reg);
 885     Data = inw (Private, VBE_DISPI_IOPORT_DATA);
 886   }
 887   return Data;
 888 }
 889
 890 VOID
 891 VgaOutb (
 892   QEMU_VIDEO_PRIVATE_DATA  *Private,
 893   UINTN                    Reg,
 894   UINT8                    Data
 895   )
 896 {
 897   EFI_STATUS   Status;
 898
 899   if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
 900     Status = Private->PciIo->Mem.Write (
 901         Private->PciIo,
 902         EfiPciIoWidthUint8,
 903         PCI_BAR_IDX2,
 904         0x400 - 0x3c0 + Reg,
 905         1,
 906         &Data
 907         );
 908     ASSERT_EFI_ERROR (Status);
 909   } else {
 910     outb (Private, Reg, Data);
 911   }
 912 }
 913
 914 VOID
 915 InitializeBochsGraphicsMode (
 916   QEMU_VIDEO_PRIVATE_DATA  *Private,
 917   QEMU_VIDEO_BOCHS_MODES  *ModeData
 918   )
 919 {
 920   DEBUG ((EFI_D_INFO, "InitializeBochsGraphicsMode: %dx%d @ %d\n",
 921           ModeData->Width, ModeData->Height, ModeData->ColorDepth));
 922
 923   /* unblank */
 924   VgaOutb (Private, ATT_ADDRESS_REGISTER, 0x20);
 925
 926   BochsWrite (Private, VBE_DISPI_INDEX_ENABLE,      0);
 927   BochsWrite (Private, VBE_DISPI_INDEX_BANK,        0);
 928   BochsWrite (Private, VBE_DISPI_INDEX_X_OFFSET,    0);
 929   BochsWrite (Private, VBE_DISPI_INDEX_Y_OFFSET,    0);
 930
 931   BochsWrite (Private, VBE_DISPI_INDEX_BPP,         (UINT16) ModeData->ColorDepth);
 932   BochsWrite (Private, VBE_DISPI_INDEX_XRES,        (UINT16) ModeData->Width);
 933   BochsWrite (Private, VBE_DISPI_INDEX_VIRT_WIDTH,  (UINT16) ModeData->Width);
 934   BochsWrite (Private, VBE_DISPI_INDEX_YRES,        (UINT16) ModeData->Height);
 935   BochsWrite (Private, VBE_DISPI_INDEX_VIRT_HEIGHT, (UINT16) ModeData->Height);
 936
 937   BochsWrite (Private, VBE_DISPI_INDEX_ENABLE,
 938               VBE_DISPI_ENABLED | VBE_DISPI_LFB_ENABLED);
 939
 940   SetDefaultPalette (Private);
 941   ClearScreen (Private);
 942 }
 943
 944 EFI_STATUS
 945 EFIAPI
 946 InitializeQemuVideo (
 947   IN EFI_HANDLE           ImageHandle,
 948   IN EFI_SYSTEM_TABLE     *SystemTable
 949   )
 950 {
 951   EFI_STATUS              Status;
 952
 953   Status = EfiLibInstallDriverBindingComponentName2 (
 954              ImageHandle,
 955              SystemTable,
 956              &gQemuVideoDriverBinding,
 957              ImageHandle,
 958              &gQemuVideoComponentName,
 959              &gQemuVideoComponentName2
 960              );
 961   ASSERT_EFI_ERROR (Status);
 962
 963   //
 964   // Install EFI Driver Supported EFI Version Protocol required for
 965   // EFI drivers that are on PCI and other plug in cards.
 966   //
 967   gQemuVideoDriverSupportedEfiVersion.FirmwareVersion = PcdGet32 (PcdDriverSupportedEfiVersion);
 968   Status = gBS->InstallMultipleProtocolInterfaces (
 969                   &ImageHandle,
 970                   &gEfiDriverSupportedEfiVersionProtocolGuid,
 971                   &gQemuVideoDriverSupportedEfiVersion,
 972                   NULL
 973                   );
 974   ASSERT_EFI_ERROR (Status);
 975
 976   return Status;
 977 }