OptionRomPkg/CirrusLogic5430Dxe/CirrusLogic5430.c

   1 /** @file
   2   Cirrus Logic 5430 Controller Driver.
   3   This driver is a sample implementation of the UGA Draw and Graphics Output
   4   Protocols for the Cirrus Logic 5430 family of PCI video controllers.
   5   This driver is only usable in the EFI pre-boot environment.
   6   This sample is intended to show how the UGA Draw and Graphics output Protocol
   7   is able to function.
   8   The UGA I/O Protocol is not implemented in this sample.
   9   A fully compliant EFI UGA driver requires both
  10   the UGA Draw and the UGA I/O Protocol.  Please refer to Microsoft's
  11   documentation on UGA for details on how to write a UGA driver that is able
  12   to function both in the EFI pre-boot environment and from the OS runtime.
  13
  14   Copyright (c) 2006, Intel Corporation
  15   All rights reserved. This program and the accompanying materials
  16   are licensed and made available under the terms and conditions of the BSD License
  17   which accompanies this distribution.  The full text of the license may be found at
  18   http://opensource.org/licenses/bsd-license.php
  19
  20   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  21   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  22
  23 **/
  24
  25 //
  26 // Cirrus Logic 5430 Controller Driver
  27 //
  28 #include "CirrusLogic5430.h"
  29
  30 EFI_DRIVER_BINDING_PROTOCOL gCirrusLogic5430DriverBinding = {
  31   CirrusLogic5430ControllerDriverSupported,
  32   CirrusLogic5430ControllerDriverStart,
  33   CirrusLogic5430ControllerDriverStop,
  34   0x10,
  35   NULL,
  36   NULL
  37 };
  38
  39 ///
  40 /// Generic Attribute Controller Register Settings
  41 ///
  42 UINT8  AttributeController[21] = {
  43   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  44   0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
  45   0x41, 0x00, 0x0F, 0x00, 0x00
  46 };
  47
  48 ///
  49 /// Generic Graphics Controller Register Settings
  50 ///
  51 UINT8 GraphicsController[9] = {
  52   0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF
  53 };
  54
  55 //
  56 // 640 x 480 x 256 color @ 60 Hertz
  57 //
  58 UINT8 Crtc_640_480_256_60[28] = {
  59   0x5d, 0x4f, 0x50, 0x82, 0x53, 0x9f, 0x00, 0x3e,
  60   0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  61   0xe1, 0x83, 0xdf, 0x50, 0x00, 0xe7, 0x04, 0xe3,
  62   0xff, 0x00, 0x00, 0x22
  63 };
  64
  65 UINT16 Seq_640_480_256_60[15] = {
  66   0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
  67   0x5b0c, 0x450d, 0x7e0e, 0x2b1b, 0x2f1c, 0x301d, 0x331e
  68 };
  69
  70 //
  71 // 800 x 600 x 256 color @ 60 Hertz
  72 //
  73 UINT8 Crtc_800_600_256_60[28] = {
  74   0x7F, 0x63, 0x64, 0x80, 0x6B, 0x1B, 0x72, 0xF0,
  75   0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  76   0x58, 0x8C, 0x57, 0x64, 0x00, 0x5F, 0x91, 0xE3,
  77   0xFF, 0x00, 0x00, 0x22
  78 };
  79
  80 UINT16 Seq_800_600_256_60[15] = {
  81   0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
  82   0x5b0c, 0x450d, 0x510e, 0x2b1b, 0x2f1c, 0x301d, 0x3a1e
  83 };
  84
  85 //
  86 // 1024 x 768 x 256 color @ 60 Hertz
  87 //
  88 UINT8 Crtc_1024_768_256_60[28] = {
  89   0xA3, 0x7F, 0x80, 0x86, 0x85, 0x96, 0x24, 0xFD,
  90   0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  91   0x02, 0x88, 0xFF, 0x80, 0x00, 0x00, 0x24, 0xE3,
  92   0xFF, 0x4A, 0x00, 0x22
  93 };
  94
  95 UINT16 Seq_1024_768_256_60[15] = {
  96   0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
  97   0x5b0c, 0x450d, 0x760e, 0x2b1b, 0x2f1c, 0x301d, 0x341e
  98 };
  99
 100 ///
 101 /// Table of supported video modes
 102 ///
 103 CIRRUS_LOGIC_5430_VIDEO_MODES  CirrusLogic5430VideoModes[] = {
 104   {  640, 480, 8, 60, Crtc_640_480_256_60,  Seq_640_480_256_60,  0xe3 },
 105   {  800, 600, 8, 60, Crtc_800_600_256_60,  Seq_800_600_256_60,  0xef },
 106   { 1024, 768, 8, 60, Crtc_1024_768_256_60, Seq_1024_768_256_60, 0xef }
 107 };
 108
 109 /**
 110   CirrusLogic5430ControllerDriverSupported
 111
 112   TODO:    This - add argument and description to function comment
 113   TODO:    Controller - add argument and description to function comment
 114   TODO:    RemainingDevicePath - add argument and description to function comment
 115 **/
 116 EFI_STATUS
 117 EFIAPI
 118 CirrusLogic5430ControllerDriverSupported (
 119   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 120   IN EFI_HANDLE                     Controller,
 121   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 122   )
 123 {
 124   EFI_STATUS          Status;
 125   EFI_PCI_IO_PROTOCOL *PciIo;
 126   PCI_TYPE00          Pci;
 127
 128   //
 129   // Open the PCI I/O Protocol
 130   //
 131   Status = gBS->OpenProtocol (
 132                   Controller,
 133                   &gEfiPciIoProtocolGuid,
 134                   (VOID **) &PciIo,
 135                   This->DriverBindingHandle,
 136                   Controller,
 137                   EFI_OPEN_PROTOCOL_BY_DRIVER
 138                   );
 139   if (EFI_ERROR (Status)) {
 140     return Status;
 141   }
 142
 143   //
 144   // Read the PCI Configuration Header from the PCI Device
 145   //
 146   Status = PciIo->Pci.Read (
 147                         PciIo,
 148                         EfiPciIoWidthUint32,
 149                         0,
 150                         sizeof (Pci) / sizeof (UINT32),
 151                         &Pci
 152                         );
 153   if (EFI_ERROR (Status)) {
 154     goto Done;
 155   }
 156
 157   Status = EFI_UNSUPPORTED;
 158   //
 159   // See if the I/O enable is on.  Most systems only allow one VGA device to be turned on
 160   // at a time, so see if this is one that is turned on.
 161   //
 162   //  if (((Pci.Hdr.Command & 0x01) == 0x01)) {
 163   //
 164   // See if this is a Cirrus Logic PCI controller
 165   //
 166   if (Pci.Hdr.VendorId == CIRRUS_LOGIC_VENDOR_ID) {
 167     //
 168     // See if this is a 5430 or a 5446 PCI controller
 169     //
 170     if (Pci.Hdr.DeviceId == CIRRUS_LOGIC_5430_DEVICE_ID) {
 171       Status = EFI_SUCCESS;
 172     }
 173
 174     if (Pci.Hdr.DeviceId == CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID) {
 175       Status = EFI_SUCCESS;
 176     }
 177
 178     if (Pci.Hdr.DeviceId == CIRRUS_LOGIC_5446_DEVICE_ID) {
 179       Status = EFI_SUCCESS;
 180     }
 181   }
 182
 183 Done:
 184   //
 185   // Close the PCI I/O Protocol
 186   //
 187   gBS->CloseProtocol (
 188         Controller,
 189         &gEfiPciIoProtocolGuid,
 190         This->DriverBindingHandle,
 191         Controller
 192         );
 193
 194   return Status;
 195 }
 196
 197 /**
 198   CirrusLogic5430ControllerDriverStart
 199
 200   TODO:    This - add argument and description to function comment
 201   TODO:    Controller - add argument and description to function comment
 202   TODO:    RemainingDevicePath - add argument and description to function comment
 203 **/
 204 EFI_STATUS
 205 EFIAPI
 206 CirrusLogic5430ControllerDriverStart (
 207   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 208   IN EFI_HANDLE                     Controller,
 209   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 210   )
 211 {
 212   EFI_STATUS                      Status;
 213   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private;
 214
 215   //
 216   // Allocate Private context data for UGA Draw inteface.
 217   //
 218   Private = AllocateZeroPool (sizeof (CIRRUS_LOGIC_5430_PRIVATE_DATA));
 219   if (Private == NULL) {
 220     Status = EFI_OUT_OF_RESOURCES;
 221     goto Error;
 222   }
 223
 224   //
 225   // Set up context record
 226   //
 227   Private->Signature  = CIRRUS_LOGIC_5430_PRIVATE_DATA_SIGNATURE;
 228   Private->Handle     = Controller;
 229
 230   //
 231   // Open PCI I/O Protocol
 232   //
 233   Status = gBS->OpenProtocol (
 234                   Private->Handle,
 235                   &gEfiPciIoProtocolGuid,
 236                   (VOID **) &Private->PciIo,
 237                   This->DriverBindingHandle,
 238                   Private->Handle,
 239                   EFI_OPEN_PROTOCOL_BY_DRIVER
 240                   );
 241   if (EFI_ERROR (Status)) {
 242     goto Error;
 243   }
 244
 245   //
 246   // Save original PCI attributes
 247   //
 248   Status = Private->PciIo->Attributes (
 249                     Private->PciIo,
 250                     EfiPciIoAttributeOperationGet,
 251                     0,
 252                     &Private->OriginalPciAttributes
 253                     );
 254
 255   if (EFI_ERROR (Status)) {
 256     goto Error;
 257   }
 258
 259   Status = Private->PciIo->Attributes (
 260                             Private->PciIo,
 261                             EfiPciIoAttributeOperationEnable,
 262                             EFI_PCI_DEVICE_ENABLE | EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY | EFI_PCI_IO_ATTRIBUTE_VGA_IO,
 263                             NULL
 264                             );
 265   if (EFI_ERROR (Status)) {
 266     goto Error;
 267   }
 268
 269   if (FeaturePcdGet (PcdSupportUga)) {
 270     //
 271     // Start the UGA Draw software stack.
 272     //
 273     Status = CirrusLogic5430UgaDrawConstructor (Private);
 274     ASSERT_EFI_ERROR (Status);
 275     if (FeaturePcdGet (PcdSupportGop)) {
 276       Status = CirrusLogic5430GraphicsOutputConstructor (Private);
 277       ASSERT_EFI_ERROR (Status);
 278
 279       Status = gBS->InstallMultipleProtocolInterfaces (
 280                       &Private->Handle,
 281                       &gEfiUgaDrawProtocolGuid,
 282                       &Private->UgaDraw,
 283                       &gEfiGraphicsOutputProtocolGuid,
 284                       &Private->GraphicsOutput,
 285                       NULL
 286                       );
 287     } else {
 288       Status = gBS->InstallMultipleProtocolInterfaces (
 289                       &Private->Handle,
 290                       &gEfiUgaDrawProtocolGuid,
 291                       &Private->UgaDraw,
 292                       NULL
 293                       );
 294
 295     }
 296   } else {
 297     if (FeaturePcdGet (PcdSupportGop)) {
 298       Status = CirrusLogic5430GraphicsOutputConstructor (Private);
 299       ASSERT_EFI_ERROR (Status);
 300
 301       Status = gBS->InstallMultipleProtocolInterfaces (
 302                       &Private->Handle,
 303                       &gEfiGraphicsOutputProtocolGuid,
 304                       &Private->GraphicsOutput,
 305                       NULL
 306                       );
 307
 308     } else {
 309       //
 310       // This driver must support eithor GOP or UGA or both.
 311       //
 312       ASSERT (FALSE);
 313       Status = EFI_UNSUPPORTED;
 314     }
 315   }
 316
 317
 318 Error:
 319   if (EFI_ERROR (Status)) {
 320     if (Private) {
 321       if (Private->PciIo) {
 322         //
 323         // Restore original PCI attributes
 324         //
 325         Private->PciIo->Attributes (
 326                         Private->PciIo,
 327                         EfiPciIoAttributeOperationSet,
 328                         Private->OriginalPciAttributes,
 329                         NULL
 330                         );
 331
 332         //
 333         // Close the PCI I/O Protocol
 334         //
 335         gBS->CloseProtocol (
 336               Private->Handle,
 337               &gEfiPciIoProtocolGuid,
 338               This->DriverBindingHandle,
 339               Private->Handle
 340               );
 341       }
 342
 343       gBS->FreePool (Private);
 344     }
 345   }
 346
 347   return Status;
 348 }
 349
 350 /**
 351   CirrusLogic5430ControllerDriverStop
 352
 353   TODO:    This - add argument and description to function comment
 354   TODO:    Controller - add argument and description to function comment
 355   TODO:    NumberOfChildren - add argument and description to function comment
 356   TODO:    ChildHandleBuffer - add argument and description to function comment
 357   TODO:    EFI_SUCCESS - add return value to function comment
 358 **/
 359 EFI_STATUS
 360 EFIAPI
 361 CirrusLogic5430ControllerDriverStop (
 362   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 363   IN EFI_HANDLE                     Controller,
 364   IN UINTN                          NumberOfChildren,
 365   IN EFI_HANDLE                     *ChildHandleBuffer
 366   )
 367 {
 368   EFI_UGA_DRAW_PROTOCOL           *UgaDraw;
 369   EFI_GRAPHICS_OUTPUT_PROTOCOL    *GraphicsOutput;
 370
 371   EFI_STATUS                      Status;
 372   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private;
 373
 374   if (FeaturePcdGet (PcdSupportUga)) {
 375     Status = gBS->OpenProtocol (
 376                     Controller,
 377                     &gEfiUgaDrawProtocolGuid,
 378                     (VOID **) &UgaDraw,
 379                     This->DriverBindingHandle,
 380                     Controller,
 381                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 382                     );
 383     if (EFI_ERROR (Status)) {
 384       return Status;
 385     }
 386     //
 387     // Get our private context information
 388     //
 389     Private = CIRRUS_LOGIC_5430_PRIVATE_DATA_FROM_UGA_DRAW_THIS (UgaDraw);
 390     CirrusLogic5430UgaDrawDestructor (Private);
 391
 392     if (FeaturePcdGet (PcdSupportGop)) {
 393       CirrusLogic5430GraphicsOutputDestructor (Private);
 394       //
 395       // Remove the UGA and GOP protocol interface from the system
 396       //
 397       Status = gBS->UninstallMultipleProtocolInterfaces (
 398                       Private->Handle,
 399                       &gEfiUgaDrawProtocolGuid,
 400                       &Private->UgaDraw,
 401                       &gEfiGraphicsOutputProtocolGuid,
 402                       &Private->GraphicsOutput,
 403                       NULL
 404                       );
 405     } else {
 406       //
 407       // Remove the UGA Draw interface from the system
 408       //
 409       Status = gBS->UninstallMultipleProtocolInterfaces (
 410                       Private->Handle,
 411                       &gEfiUgaDrawProtocolGuid,
 412                       &Private->UgaDraw,
 413                       NULL
 414                       );
 415     }
 416   } else {
 417     Status = gBS->OpenProtocol (
 418                     Controller,
 419                     &gEfiGraphicsOutputProtocolGuid,
 420                     (VOID **) &GraphicsOutput,
 421                     This->DriverBindingHandle,
 422                     Controller,
 423                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 424                     );
 425     if (EFI_ERROR (Status)) {
 426       return Status;
 427     }
 428
 429     //
 430     // Get our private context information
 431     //
 432     Private = CIRRUS_LOGIC_5430_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput);
 433
 434     CirrusLogic5430GraphicsOutputDestructor (Private);
 435     //
 436     // Remove the GOP protocol interface from the system
 437     //
 438     Status = gBS->UninstallMultipleProtocolInterfaces (
 439                     Private->Handle,
 440                     &gEfiUgaDrawProtocolGuid,
 441                     &Private->UgaDraw,
 442                     &gEfiGraphicsOutputProtocolGuid,
 443                     &Private->GraphicsOutput,
 444                     NULL
 445                     );
 446   }
 447
 448   if (EFI_ERROR (Status)) {
 449     return Status;
 450   }
 451
 452   //
 453   // Restore original PCI attributes
 454   //
 455   Private->PciIo->Attributes (
 456                   Private->PciIo,
 457                   EfiPciIoAttributeOperationSet,
 458                   Private->OriginalPciAttributes,
 459                   NULL
 460                   );
 461
 462   //
 463   // Close the PCI I/O Protocol
 464   //
 465   gBS->CloseProtocol (
 466         Controller,
 467         &gEfiPciIoProtocolGuid,
 468         This->DriverBindingHandle,
 469         Controller
 470         );
 471
 472   //
 473   // Free our instance data
 474   //
 475   gBS->FreePool (Private);
 476
 477   return EFI_SUCCESS;
 478 }
 479
 480 /**
 481   CirrusLogic5430UgaDrawDestructor
 482
 483   TODO:    Private - add argument and description to function comment
 484   TODO:    EFI_SUCCESS - add return value to function comment
 485 **/
 486 EFI_STATUS
 487 CirrusLogic5430UgaDrawDestructor (
 488   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private
 489   )
 490 {
 491   return EFI_SUCCESS;
 492 }
 493
 494 /**
 495   TODO: Add function description
 496
 497   @param  Private TODO: add argument description
 498   @param  Address TODO: add argument description
 499   @param  Data TODO: add argument description
 500
 501   TODO: add return values
 502
 503 **/
 504 VOID
 505 outb (
 506   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 507   UINTN                           Address,
 508   UINT8                           Data
 509   )
 510 {
 511   Private->PciIo->Io.Write (
 512                       Private->PciIo,
 513                       EfiPciIoWidthUint8,
 514                       EFI_PCI_IO_PASS_THROUGH_BAR,
 515                       Address,
 516                       1,
 517                       &Data
 518                       );
 519 }
 520
 521 /**
 522   TODO: Add function description
 523
 524   @param  Private TODO: add argument description
 525   @param  Address TODO: add argument description
 526   @param  Data TODO: add argument description
 527
 528   TODO: add return values
 529
 530 **/
 531 VOID
 532 outw (
 533   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 534   UINTN                           Address,
 535   UINT16                          Data
 536   )
 537 {
 538   Private->PciIo->Io.Write (
 539                       Private->PciIo,
 540                       EfiPciIoWidthUint16,
 541                       EFI_PCI_IO_PASS_THROUGH_BAR,
 542                       Address,
 543                       1,
 544                       &Data
 545                       );
 546 }
 547
 548 /**
 549   TODO: Add function description
 550
 551   @param  Private TODO: add argument description
 552   @param  Address TODO: add argument description
 553
 554   TODO: add return values
 555
 556 **/
 557 UINT8
 558 inb (
 559   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 560   UINTN                           Address
 561   )
 562 {
 563   UINT8 Data;
 564
 565   Private->PciIo->Io.Read (
 566                       Private->PciIo,
 567                       EfiPciIoWidthUint8,
 568                       EFI_PCI_IO_PASS_THROUGH_BAR,
 569                       Address,
 570                       1,
 571                       &Data
 572                       );
 573   return Data;
 574 }
 575
 576 /**
 577   TODO: Add function description
 578
 579   @param  Private TODO: add argument description
 580   @param  Address TODO: add argument description
 581
 582   TODO: add return values
 583
 584 **/
 585 UINT16
 586 inw (
 587   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 588   UINTN                           Address
 589   )
 590 {
 591   UINT16  Data;
 592
 593   Private->PciIo->Io.Read (
 594                       Private->PciIo,
 595                       EfiPciIoWidthUint16,
 596                       EFI_PCI_IO_PASS_THROUGH_BAR,
 597                       Address,
 598                       1,
 599                       &Data
 600                       );
 601   return Data;
 602 }
 603
 604 /**
 605   TODO: Add function description
 606
 607   @param  Private TODO: add argument description
 608   @param  Index TODO: add argument description
 609   @param  Red TODO: add argument description
 610   @param  Green TODO: add argument description
 611   @param  Blue TODO: add argument description
 612
 613   TODO: add return values
 614
 615 **/
 616 VOID
 617 SetPaletteColor (
 618   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 619   UINTN                           Index,
 620   UINT8                           Red,
 621   UINT8                           Green,
 622   UINT8                           Blue
 623   )
 624 {
 625   outb (Private, PALETTE_INDEX_REGISTER, (UINT8) Index);
 626   outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Red >> 2));
 627   outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Green >> 2));
 628   outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Blue >> 2));
 629 }
 630
 631 /**
 632   TODO: Add function description
 633
 634   @param  Private TODO: add argument description
 635
 636   TODO: add return values
 637
 638 **/
 639 VOID
 640 SetDefaultPalette (
 641   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private
 642   )
 643 {
 644   UINTN Index;
 645   UINTN RedIndex;
 646   UINTN GreenIndex;
 647   UINTN BlueIndex;
 648
 649   Index = 0;
 650   for (RedIndex = 0; RedIndex < 8; RedIndex++) {
 651     for (GreenIndex = 0; GreenIndex < 8; GreenIndex++) {
 652       for (BlueIndex = 0; BlueIndex < 4; BlueIndex++) {
 653         SetPaletteColor (Private, Index, (UINT8) (RedIndex << 5), (UINT8) (GreenIndex << 5), (UINT8) (BlueIndex << 6));
 654         Index++;
 655       }
 656     }
 657   }
 658 }
 659
 660 /**
 661   TODO: Add function description
 662
 663   @param  Private TODO: add argument description
 664
 665   TODO: add return values
 666
 667 **/
 668 STATIC
 669 VOID
 670 ClearScreen (
 671   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private
 672   )
 673 {
 674   UINT32  Color;
 675
 676   Color = 0;
 677   Private->PciIo->Mem.Write (
 678                         Private->PciIo,
 679                         EfiPciIoWidthFillUint32,
 680                         0,
 681                         0,
 682                         0x100000 >> 2,
 683                         &Color
 684                         );
 685 }
 686
 687 /**
 688   TODO: Add function description
 689
 690   @param  Private TODO: add argument description
 691
 692   TODO: add return values
 693
 694 **/
 695 VOID
 696 DrawLogo (
 697   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 698   UINTN                           ScreenWidth,
 699   UINTN                           ScreenHeight
 700   )
 701 {
 702   UINTN Offset;
 703   UINTN X;
 704   UINTN Y;
 705   UINT8 Color;
 706
 707   Offset        = 0;
 708   for (Y = 0; Y < ScreenHeight; Y++) {
 709     for (X = 0; X < ScreenWidth; X++) {
 710       Color                   = (UINT8) (256 * (X + Y) / (ScreenWidth + ScreenHeight));
 711       Private->LineBuffer[X]  = Color;
 712     }
 713
 714     Private->PciIo->Mem.Write (
 715                           Private->PciIo,
 716                           EfiPciIoWidthUint32,
 717                           0,
 718                           Offset + (Y * ScreenWidth),
 719                           ScreenWidth >> 2,
 720                           Private->LineBuffer
 721                           );
 722   }
 723 }
 724
 725 /**
 726   TODO: Add function description
 727
 728   @param  Private TODO: add argument description
 729   @param  ModeData TODO: add argument description
 730
 731   TODO: add return values
 732
 733 **/
 734 VOID
 735 InitializeGraphicsMode (
 736   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 737   CIRRUS_LOGIC_5430_VIDEO_MODES   *ModeData
 738   )
 739 {
 740   UINT8 Byte;
 741   UINTN Index;
 742
 743   outw (Private, SEQ_ADDRESS_REGISTER, 0x1206);
 744   outw (Private, SEQ_ADDRESS_REGISTER, 0x0012);
 745
 746   for (Index = 0; Index < 15; Index++) {
 747     outw (Private, SEQ_ADDRESS_REGISTER, ModeData->SeqSettings[Index]);
 748   }
 749
 750   outb (Private, SEQ_ADDRESS_REGISTER, 0x0f);
 751   Byte = (UINT8) ((inb (Private, SEQ_DATA_REGISTER) & 0xc7) ^ 0x30);
 752   outb (Private, SEQ_DATA_REGISTER, Byte);
 753
 754   outb (Private, MISC_OUTPUT_REGISTER, ModeData->MiscSetting);
 755   outw (Private, GRAPH_ADDRESS_REGISTER, 0x0506);
 756   outw (Private, SEQ_ADDRESS_REGISTER, 0x0300);
 757   outw (Private, CRTC_ADDRESS_REGISTER, 0x2011);
 758
 759   for (Index = 0; Index < 28; Index++) {
 760     outw (Private, CRTC_ADDRESS_REGISTER, (UINT16) ((ModeData->CrtcSettings[Index] << 8) | Index));
 761   }
 762
 763   for (Index = 0; Index < 9; Index++) {
 764     outw (Private, GRAPH_ADDRESS_REGISTER, (UINT16) ((GraphicsController[Index] << 8) | Index));
 765   }
 766
 767   inb (Private, INPUT_STATUS_1_REGISTER);
 768
 769   for (Index = 0; Index < 21; Index++) {
 770     outb (Private, ATT_ADDRESS_REGISTER, (UINT8) Index);
 771     outb (Private, ATT_ADDRESS_REGISTER, AttributeController[Index]);
 772   }
 773
 774   outb (Private, ATT_ADDRESS_REGISTER, 0x20);
 775
 776   outw (Private, GRAPH_ADDRESS_REGISTER, 0x0009);
 777   outw (Private, GRAPH_ADDRESS_REGISTER, 0x000a);
 778   outw (Private, GRAPH_ADDRESS_REGISTER, 0x000b);
 779   outb (Private, DAC_PIXEL_MASK_REGISTER, 0xff);
 780
 781   SetDefaultPalette (Private);
 782   ClearScreen (Private);
 783 }
 784
 785 EFI_STATUS
 786 EFIAPI
 787 InitializeCirrusLogic5430 (
 788   IN EFI_HANDLE           ImageHandle,
 789   IN EFI_SYSTEM_TABLE     *SystemTable
 790   )
 791 {
 792   EFI_STATUS              Status;
 793
 794   Status = EfiLibInstallDriverBindingComponentName2 (
 795              ImageHandle,
 796              SystemTable,
 797              &gCirrusLogic5430DriverBinding,
 798              ImageHandle,
 799              &gCirrusLogic5430ComponentName,
 800              &gCirrusLogic5430ComponentName2
 801              );
 802   ASSERT_EFI_ERROR (Status);
 803
 804   //
 805   // Install EFI Driver Supported EFI Version Protocol required for
 806   // EFI drivers that are on PCI and other plug in cards.
 807   //
 808   gCirrusLogic5430DriverSupportedEfiVersion.FirmwareVersion = PcdGet32 (PcdDriverSupportedEfiVersion);
 809   Status = gBS->InstallMultipleProtocolInterfaces (
 810                   &ImageHandle,
 811                   &gEfiDriverSupportedEfiVersionProtocolGuid,
 812                   &gCirrusLogic5430DriverSupportedEfiVersion,
 813                   NULL
 814                   );
 815   ASSERT_EFI_ERROR (Status);
 816
 817   return Status;
 818 }