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 - 2010, Intel Corporation. All rights reserved.<BR>
  15   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 /**
 111   CirrusLogic5430ControllerDriverSupported
 112
 113   TODO:    This - add argument and description to function comment
 114   TODO:    Controller - add argument and description to function comment
 115   TODO:    RemainingDevicePath - add argument and description to function comment
 116 **/
 117 EFI_STATUS
 118 EFIAPI
 119 CirrusLogic5430ControllerDriverSupported (
 120   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 121   IN EFI_HANDLE                     Controller,
 122   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 123   )
 124 {
 125   EFI_STATUS          Status;
 126   EFI_PCI_IO_PROTOCOL *PciIo;
 127   PCI_TYPE00          Pci;
 128   EFI_DEV_PATH        *Node;
 129
 130   //
 131   // Open the PCI I/O Protocol
 132   //
 133   Status = gBS->OpenProtocol (
 134                   Controller,
 135                   &gEfiPciIoProtocolGuid,
 136                   (VOID **) &PciIo,
 137                   This->DriverBindingHandle,
 138                   Controller,
 139                   EFI_OPEN_PROTOCOL_BY_DRIVER
 140                   );
 141   if (EFI_ERROR (Status)) {
 142     return Status;
 143   }
 144
 145   //
 146   // Read the PCI Configuration Header from the PCI Device
 147   //
 148   Status = PciIo->Pci.Read (
 149                         PciIo,
 150                         EfiPciIoWidthUint32,
 151                         0,
 152                         sizeof (Pci) / sizeof (UINT32),
 153                         &Pci
 154                         );
 155   if (EFI_ERROR (Status)) {
 156     goto Done;
 157   }
 158
 159   Status = EFI_UNSUPPORTED;
 160   //
 161   // See if the I/O enable is on.  Most systems only allow one VGA device to be turned on
 162   // at a time, so see if this is one that is turned on.
 163   //
 164   //  if (((Pci.Hdr.Command & 0x01) == 0x01)) {
 165   //
 166   // See if this is a Cirrus Logic PCI controller
 167   //
 168   if (Pci.Hdr.VendorId == CIRRUS_LOGIC_VENDOR_ID) {
 169     //
 170     // See if this is a 5430 or a 5446 PCI controller
 171     //
 172     if (Pci.Hdr.DeviceId == CIRRUS_LOGIC_5430_DEVICE_ID ||
 173         Pci.Hdr.DeviceId == CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID ||
 174         Pci.Hdr.DeviceId == CIRRUS_LOGIC_5446_DEVICE_ID) {
 175
 176       Status = EFI_SUCCESS;
 177       //
 178       // If this is an Intel 945 graphics controller,
 179       // go further check RemainingDevicePath validation
 180       //
 181       if (RemainingDevicePath != NULL) {
 182         Node = (EFI_DEV_PATH *) RemainingDevicePath;
 183         //
 184         // Check if RemainingDevicePath is the End of Device Path Node,
 185         // if yes, return EFI_SUCCESS
 186         //
 187         if (!IsDevicePathEnd (Node)) {
 188           //
 189           // If RemainingDevicePath isn't the End of Device Path Node,
 190           // check its validation
 191           //
 192           if (Node->DevPath.Type != ACPI_DEVICE_PATH ||
 193               Node->DevPath.SubType != ACPI_ADR_DP ||
 194               DevicePathNodeLength(&Node->DevPath) != sizeof(ACPI_ADR_DEVICE_PATH)) {
 195             Status = EFI_UNSUPPORTED;
 196           }
 197         }
 198       }
 199     }
 200   }
 201
 202 Done:
 203   //
 204   // Close the PCI I/O Protocol
 205   //
 206   gBS->CloseProtocol (
 207         Controller,
 208         &gEfiPciIoProtocolGuid,
 209         This->DriverBindingHandle,
 210         Controller
 211         );
 212
 213   return Status;
 214 }
 215
 216 /**
 217   CirrusLogic5430ControllerDriverStart
 218
 219   TODO:    This - add argument and description to function comment
 220   TODO:    Controller - add argument and description to function comment
 221   TODO:    RemainingDevicePath - add argument and description to function comment
 222 **/
 223 EFI_STATUS
 224 EFIAPI
 225 CirrusLogic5430ControllerDriverStart (
 226   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 227   IN EFI_HANDLE                     Controller,
 228   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 229   )
 230 {
 231   EFI_STATUS                      Status;
 232   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private;
 233   BOOLEAN                         PciAttributesSaved;
 234   EFI_DEVICE_PATH_PROTOCOL        *ParentDevicePath;
 235   ACPI_ADR_DEVICE_PATH            AcpiDeviceNode;
 236   UINT64                          Supports;
 237
 238   PciAttributesSaved = FALSE;
 239   //
 240   // Allocate Private context data for UGA Draw inteface.
 241   //
 242   Private = AllocateZeroPool (sizeof (CIRRUS_LOGIC_5430_PRIVATE_DATA));
 243   if (Private == NULL) {
 244     Status = EFI_OUT_OF_RESOURCES;
 245     goto Error;
 246   }
 247
 248   //
 249   // Set up context record
 250   //
 251   Private->Signature  = CIRRUS_LOGIC_5430_PRIVATE_DATA_SIGNATURE;
 252   Private->Handle     = NULL;
 253
 254   //
 255   // Open PCI I/O Protocol
 256   //
 257   Status = gBS->OpenProtocol (
 258                   Controller,
 259                   &gEfiPciIoProtocolGuid,
 260                   (VOID **) &Private->PciIo,
 261                   This->DriverBindingHandle,
 262                   Controller,
 263                   EFI_OPEN_PROTOCOL_BY_DRIVER
 264                   );
 265   if (EFI_ERROR (Status)) {
 266     goto Error;
 267   }
 268
 269   //
 270   // Get supported PCI attributes
 271   //
 272   Status = Private->PciIo->Attributes (
 273                              Private->PciIo,
 274                              EfiPciIoAttributeOperationSupported,
 275                              0,
 276                              &Supports
 277                              );
 278   if (EFI_ERROR (Status)) {
 279     goto Error;
 280   }
 281
 282   Supports &= (EFI_PCI_IO_ATTRIBUTE_VGA_IO | EFI_PCI_IO_ATTRIBUTE_VGA_IO_16);
 283   if (Supports == 0 || Supports == (EFI_PCI_IO_ATTRIBUTE_VGA_IO | EFI_PCI_IO_ATTRIBUTE_VGA_IO_16)) {
 284     Status = EFI_UNSUPPORTED;
 285     goto Error;
 286   }
 287
 288   //
 289   // Save original PCI attributes
 290   //
 291   Status = Private->PciIo->Attributes (
 292                     Private->PciIo,
 293                     EfiPciIoAttributeOperationGet,
 294                     0,
 295                     &Private->OriginalPciAttributes
 296                     );
 297
 298   if (EFI_ERROR (Status)) {
 299     goto Error;
 300   }
 301   PciAttributesSaved = TRUE;
 302
 303   Status = Private->PciIo->Attributes (
 304                              Private->PciIo,
 305                              EfiPciIoAttributeOperationEnable,
 306                              EFI_PCI_DEVICE_ENABLE | EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY | Supports,
 307                              NULL
 308                              );
 309   if (EFI_ERROR (Status)) {
 310     goto Error;
 311   }
 312
 313   //
 314   // Get ParentDevicePath
 315   //
 316   Status = gBS->HandleProtocol (
 317                   Controller,
 318                   &gEfiDevicePathProtocolGuid,
 319                   (VOID **) &ParentDevicePath
 320                   );
 321   if (EFI_ERROR (Status)) {
 322     goto Error;
 323   }
 324
 325   if (FeaturePcdGet (PcdSupportGop)) {
 326     //
 327     // Set Gop Device Path
 328     //
 329     if (RemainingDevicePath == NULL) {
 330       ZeroMem (&AcpiDeviceNode, sizeof (ACPI_ADR_DEVICE_PATH));
 331       AcpiDeviceNode.Header.Type = ACPI_DEVICE_PATH;
 332       AcpiDeviceNode.Header.SubType = ACPI_ADR_DP;
 333       AcpiDeviceNode.ADR = ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA, 0, 0);
 334       SetDevicePathNodeLength (&AcpiDeviceNode.Header, sizeof (ACPI_ADR_DEVICE_PATH));
 335
 336       Private->GopDevicePath = AppendDevicePathNode (
 337                                           ParentDevicePath,
 338                                           (EFI_DEVICE_PATH_PROTOCOL *) &AcpiDeviceNode
 339                                           );
 340     } else if (!IsDevicePathEnd (RemainingDevicePath)) {
 341       //
 342       // If RemainingDevicePath isn't the End of Device Path Node,
 343       // only scan the specified device by RemainingDevicePath
 344       //
 345       Private->GopDevicePath = AppendDevicePathNode (ParentDevicePath, RemainingDevicePath);
 346     } else {
 347       //
 348       // If RemainingDevicePath is the End of Device Path Node,
 349       // don't create child device and return EFI_SUCCESS
 350       //
 351       Private->GopDevicePath = NULL;
 352     }
 353
 354     if (Private->GopDevicePath != NULL) {
 355       //
 356       // Creat child handle and device path protocol firstly
 357       //
 358       Private->Handle = NULL;
 359       Status = gBS->InstallMultipleProtocolInterfaces (
 360                       &Private->Handle,
 361                       &gEfiDevicePathProtocolGuid,
 362                       Private->GopDevicePath,
 363                       NULL
 364                       );
 365     }
 366   }
 367
 368   //
 369   // Construct video mode buffer
 370   //
 371   Status = CirrusLogic5430VideoModeSetup (Private);
 372   if (EFI_ERROR (Status)) {
 373     goto Error;
 374   }
 375
 376   if (FeaturePcdGet (PcdSupportUga)) {
 377     //
 378     // Start the UGA Draw software stack.
 379     //
 380     Status = CirrusLogic5430UgaDrawConstructor (Private);
 381     ASSERT_EFI_ERROR (Status);
 382
 383     Private->UgaDevicePath = ParentDevicePath;
 384     Status = gBS->InstallMultipleProtocolInterfaces (
 385                     &Controller,
 386                     &gEfiUgaDrawProtocolGuid,
 387                     &Private->UgaDraw,
 388                     &gEfiDevicePathProtocolGuid,
 389                     Private->UgaDevicePath,
 390                     NULL
 391                     );
 392
 393   } else if (FeaturePcdGet (PcdSupportGop)) {
 394     if (Private->GopDevicePath == NULL) {
 395       //
 396       // If RemainingDevicePath is the End of Device Path Node,
 397       // don't create child device and return EFI_SUCCESS
 398       //
 399       Status = EFI_SUCCESS;
 400     } else {
 401
 402       //
 403       // Start the GOP software stack.
 404       //
 405       Status = CirrusLogic5430GraphicsOutputConstructor (Private);
 406       ASSERT_EFI_ERROR (Status);
 407
 408       Status = gBS->InstallMultipleProtocolInterfaces (
 409                       &Private->Handle,
 410                       &gEfiGraphicsOutputProtocolGuid,
 411                       &Private->GraphicsOutput,
 412                       &gEfiEdidDiscoveredProtocolGuid,
 413                       &Private->EdidDiscovered,
 414                       &gEfiEdidActiveProtocolGuid,
 415                       &Private->EdidActive,
 416                       NULL
 417                       );
 418     }
 419   } else {
 420     //
 421     // This driver must support eithor GOP or UGA or both.
 422     //
 423     ASSERT (FALSE);
 424     Status = EFI_UNSUPPORTED;
 425   }
 426
 427
 428 Error:
 429   if (EFI_ERROR (Status)) {
 430     if (Private) {
 431       if (Private->PciIo) {
 432         if (PciAttributesSaved == TRUE) {
 433           //
 434           // Restore original PCI attributes
 435           //
 436           Private->PciIo->Attributes (
 437                           Private->PciIo,
 438                           EfiPciIoAttributeOperationSet,
 439                           Private->OriginalPciAttributes,
 440                           NULL
 441                           );
 442         }
 443         //
 444         // Close the PCI I/O Protocol
 445         //
 446         gBS->CloseProtocol (
 447               Private->Handle,
 448               &gEfiPciIoProtocolGuid,
 449               This->DriverBindingHandle,
 450               Private->Handle
 451               );
 452       }
 453
 454       gBS->FreePool (Private);
 455     }
 456   }
 457
 458   return Status;
 459 }
 460
 461 /**
 462   CirrusLogic5430ControllerDriverStop
 463
 464   TODO:    This - add argument and description to function comment
 465   TODO:    Controller - add argument and description to function comment
 466   TODO:    NumberOfChildren - add argument and description to function comment
 467   TODO:    ChildHandleBuffer - add argument and description to function comment
 468   TODO:    EFI_SUCCESS - add return value to function comment
 469 **/
 470 EFI_STATUS
 471 EFIAPI
 472 CirrusLogic5430ControllerDriverStop (
 473   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 474   IN EFI_HANDLE                     Controller,
 475   IN UINTN                          NumberOfChildren,
 476   IN EFI_HANDLE                     *ChildHandleBuffer
 477   )
 478 {
 479   EFI_UGA_DRAW_PROTOCOL           *UgaDraw;
 480   EFI_GRAPHICS_OUTPUT_PROTOCOL    *GraphicsOutput;
 481
 482   EFI_STATUS                      Status;
 483   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private;
 484
 485   if (FeaturePcdGet (PcdSupportUga)) {
 486     Status = gBS->OpenProtocol (
 487                     Controller,
 488                     &gEfiUgaDrawProtocolGuid,
 489                     (VOID **) &UgaDraw,
 490                     This->DriverBindingHandle,
 491                     Controller,
 492                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 493                     );
 494     if (EFI_ERROR (Status)) {
 495       return Status;
 496     }
 497     //
 498     // Get our private context information
 499     //
 500     Private = CIRRUS_LOGIC_5430_PRIVATE_DATA_FROM_UGA_DRAW_THIS (UgaDraw);
 501     CirrusLogic5430UgaDrawDestructor (Private);
 502
 503     if (FeaturePcdGet (PcdSupportGop)) {
 504       CirrusLogic5430GraphicsOutputDestructor (Private);
 505       //
 506       // Remove the UGA and GOP protocol interface from the system
 507       //
 508       Status = gBS->UninstallMultipleProtocolInterfaces (
 509                       Private->Handle,
 510                       &gEfiUgaDrawProtocolGuid,
 511                       &Private->UgaDraw,
 512                       &gEfiGraphicsOutputProtocolGuid,
 513                       &Private->GraphicsOutput,
 514                       NULL
 515                       );
 516     } else {
 517       //
 518       // Remove the UGA Draw interface from the system
 519       //
 520       Status = gBS->UninstallMultipleProtocolInterfaces (
 521                       Private->Handle,
 522                       &gEfiUgaDrawProtocolGuid,
 523                       &Private->UgaDraw,
 524                       NULL
 525                       );
 526     }
 527   } else {
 528     Status = gBS->OpenProtocol (
 529                     Controller,
 530                     &gEfiGraphicsOutputProtocolGuid,
 531                     (VOID **) &GraphicsOutput,
 532                     This->DriverBindingHandle,
 533                     Controller,
 534                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 535                     );
 536     if (EFI_ERROR (Status)) {
 537       return Status;
 538     }
 539
 540     //
 541     // Get our private context information
 542     //
 543     Private = CIRRUS_LOGIC_5430_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput);
 544
 545     CirrusLogic5430GraphicsOutputDestructor (Private);
 546     //
 547     // Remove the GOP protocol interface from the system
 548     //
 549     Status = gBS->UninstallMultipleProtocolInterfaces (
 550                     Private->Handle,
 551                     &gEfiUgaDrawProtocolGuid,
 552                     &Private->UgaDraw,
 553                     &gEfiGraphicsOutputProtocolGuid,
 554                     &Private->GraphicsOutput,
 555                     NULL
 556                     );
 557   }
 558
 559   if (EFI_ERROR (Status)) {
 560     return Status;
 561   }
 562
 563   //
 564   // Restore original PCI attributes
 565   //
 566   Private->PciIo->Attributes (
 567                   Private->PciIo,
 568                   EfiPciIoAttributeOperationSet,
 569                   Private->OriginalPciAttributes,
 570                   NULL
 571                   );
 572
 573   //
 574   // Close the PCI I/O Protocol
 575   //
 576   gBS->CloseProtocol (
 577         Controller,
 578         &gEfiPciIoProtocolGuid,
 579         This->DriverBindingHandle,
 580         Controller
 581         );
 582
 583   //
 584   // Free our instance data
 585   //
 586   gBS->FreePool (Private);
 587
 588   return EFI_SUCCESS;
 589 }
 590
 591 /**
 592   CirrusLogic5430UgaDrawDestructor
 593
 594   TODO:    Private - add argument and description to function comment
 595   TODO:    EFI_SUCCESS - add return value to function comment
 596 **/
 597 EFI_STATUS
 598 CirrusLogic5430UgaDrawDestructor (
 599   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private
 600   )
 601 {
 602   return EFI_SUCCESS;
 603 }
 604
 605 /**
 606   TODO: Add function description
 607
 608   @param  Private TODO: add argument description
 609   @param  Address TODO: add argument description
 610   @param  Data TODO: add argument description
 611
 612   TODO: add return values
 613
 614 **/
 615 VOID
 616 outb (
 617   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 618   UINTN                           Address,
 619   UINT8                           Data
 620   )
 621 {
 622   Private->PciIo->Io.Write (
 623                       Private->PciIo,
 624                       EfiPciIoWidthUint8,
 625                       EFI_PCI_IO_PASS_THROUGH_BAR,
 626                       Address,
 627                       1,
 628                       &Data
 629                       );
 630 }
 631
 632 /**
 633   TODO: Add function description
 634
 635   @param  Private TODO: add argument description
 636   @param  Address TODO: add argument description
 637   @param  Data TODO: add argument description
 638
 639   TODO: add return values
 640
 641 **/
 642 VOID
 643 outw (
 644   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 645   UINTN                           Address,
 646   UINT16                          Data
 647   )
 648 {
 649   Private->PciIo->Io.Write (
 650                       Private->PciIo,
 651                       EfiPciIoWidthUint16,
 652                       EFI_PCI_IO_PASS_THROUGH_BAR,
 653                       Address,
 654                       1,
 655                       &Data
 656                       );
 657 }
 658
 659 /**
 660   TODO: Add function description
 661
 662   @param  Private TODO: add argument description
 663   @param  Address TODO: add argument description
 664
 665   TODO: add return values
 666
 667 **/
 668 UINT8
 669 inb (
 670   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 671   UINTN                           Address
 672   )
 673 {
 674   UINT8 Data;
 675
 676   Private->PciIo->Io.Read (
 677                       Private->PciIo,
 678                       EfiPciIoWidthUint8,
 679                       EFI_PCI_IO_PASS_THROUGH_BAR,
 680                       Address,
 681                       1,
 682                       &Data
 683                       );
 684   return Data;
 685 }
 686
 687 /**
 688   TODO: Add function description
 689
 690   @param  Private TODO: add argument description
 691   @param  Address TODO: add argument description
 692
 693   TODO: add return values
 694
 695 **/
 696 UINT16
 697 inw (
 698   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 699   UINTN                           Address
 700   )
 701 {
 702   UINT16  Data;
 703
 704   Private->PciIo->Io.Read (
 705                       Private->PciIo,
 706                       EfiPciIoWidthUint16,
 707                       EFI_PCI_IO_PASS_THROUGH_BAR,
 708                       Address,
 709                       1,
 710                       &Data
 711                       );
 712   return Data;
 713 }
 714
 715 /**
 716   TODO: Add function description
 717
 718   @param  Private TODO: add argument description
 719   @param  Index TODO: add argument description
 720   @param  Red TODO: add argument description
 721   @param  Green TODO: add argument description
 722   @param  Blue TODO: add argument description
 723
 724   TODO: add return values
 725
 726 **/
 727 VOID
 728 SetPaletteColor (
 729   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 730   UINTN                           Index,
 731   UINT8                           Red,
 732   UINT8                           Green,
 733   UINT8                           Blue
 734   )
 735 {
 736   outb (Private, PALETTE_INDEX_REGISTER, (UINT8) Index);
 737   outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Red >> 2));
 738   outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Green >> 2));
 739   outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Blue >> 2));
 740 }
 741
 742 /**
 743   TODO: Add function description
 744
 745   @param  Private TODO: add argument description
 746
 747   TODO: add return values
 748
 749 **/
 750 VOID
 751 SetDefaultPalette (
 752   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private
 753   )
 754 {
 755   UINTN Index;
 756   UINTN RedIndex;
 757   UINTN GreenIndex;
 758   UINTN BlueIndex;
 759
 760   Index = 0;
 761   for (RedIndex = 0; RedIndex < 8; RedIndex++) {
 762     for (GreenIndex = 0; GreenIndex < 8; GreenIndex++) {
 763       for (BlueIndex = 0; BlueIndex < 4; BlueIndex++) {
 764         SetPaletteColor (Private, Index, (UINT8) (RedIndex << 5), (UINT8) (GreenIndex << 5), (UINT8) (BlueIndex << 6));
 765         Index++;
 766       }
 767     }
 768   }
 769 }
 770
 771 /**
 772   TODO: Add function description
 773
 774   @param  Private TODO: add argument description
 775
 776   TODO: add return values
 777
 778 **/
 779 VOID
 780 ClearScreen (
 781   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private
 782   )
 783 {
 784   UINT32  Color;
 785
 786   Color = 0;
 787   Private->PciIo->Mem.Write (
 788                         Private->PciIo,
 789                         EfiPciIoWidthFillUint32,
 790                         0,
 791                         0,
 792                         0x100000 >> 2,
 793                         &Color
 794                         );
 795 }
 796
 797 /**
 798   TODO: Add function description
 799
 800   @param  Private TODO: add argument description
 801
 802   TODO: add return values
 803
 804 **/
 805 VOID
 806 DrawLogo (
 807   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 808   UINTN                           ScreenWidth,
 809   UINTN                           ScreenHeight
 810   )
 811 {
 812 }
 813
 814 /**
 815   TODO: Add function description
 816
 817   @param  Private TODO: add argument description
 818   @param  ModeData TODO: add argument description
 819
 820   TODO: add return values
 821
 822 **/
 823 VOID
 824 InitializeGraphicsMode (
 825   CIRRUS_LOGIC_5430_PRIVATE_DATA  *Private,
 826   CIRRUS_LOGIC_5430_VIDEO_MODES   *ModeData
 827   )
 828 {
 829   UINT8 Byte;
 830   UINTN Index;
 831   UINT16 DeviceId;
 832   EFI_STATUS Status;
 833
 834   Status = Private->PciIo->Pci.Read (
 835              Private->PciIo,
 836              EfiPciIoWidthUint16,
 837              PCI_DEVICE_ID_OFFSET,
 838              1,
 839              &DeviceId
 840              );
 841   //
 842   // Read the PCI Configuration Header from the PCI Device
 843   //
 844   ASSERT_EFI_ERROR (Status);
 845
 846   outw (Private, SEQ_ADDRESS_REGISTER, 0x1206);
 847   outw (Private, SEQ_ADDRESS_REGISTER, 0x0012);
 848
 849   for (Index = 0; Index < 15; Index++) {
 850     outw (Private, SEQ_ADDRESS_REGISTER, ModeData->SeqSettings[Index]);
 851   }
 852
 853   if (DeviceId != CIRRUS_LOGIC_5446_DEVICE_ID) {
 854     outb (Private, SEQ_ADDRESS_REGISTER, 0x0f);
 855     Byte = (UINT8) ((inb (Private, SEQ_DATA_REGISTER) & 0xc7) ^ 0x30);
 856     outb (Private, SEQ_DATA_REGISTER, Byte);
 857   }
 858
 859   outb (Private, MISC_OUTPUT_REGISTER, ModeData->MiscSetting);
 860   outw (Private, GRAPH_ADDRESS_REGISTER, 0x0506);
 861   outw (Private, SEQ_ADDRESS_REGISTER, 0x0300);
 862   outw (Private, CRTC_ADDRESS_REGISTER, 0x2011);
 863
 864   for (Index = 0; Index < 28; Index++) {
 865     outw (Private, CRTC_ADDRESS_REGISTER, (UINT16) ((ModeData->CrtcSettings[Index] << 8) | Index));
 866   }
 867
 868   for (Index = 0; Index < 9; Index++) {
 869     outw (Private, GRAPH_ADDRESS_REGISTER, (UINT16) ((GraphicsController[Index] << 8) | Index));
 870   }
 871
 872   inb (Private, INPUT_STATUS_1_REGISTER);
 873
 874   for (Index = 0; Index < 21; Index++) {
 875     outb (Private, ATT_ADDRESS_REGISTER, (UINT8) Index);
 876     outb (Private, ATT_ADDRESS_REGISTER, AttributeController[Index]);
 877   }
 878
 879   outb (Private, ATT_ADDRESS_REGISTER, 0x20);
 880
 881   outw (Private, GRAPH_ADDRESS_REGISTER, 0x0009);
 882   outw (Private, GRAPH_ADDRESS_REGISTER, 0x000a);
 883   outw (Private, GRAPH_ADDRESS_REGISTER, 0x000b);
 884   outb (Private, DAC_PIXEL_MASK_REGISTER, 0xff);
 885
 886   SetDefaultPalette (Private);
 887   ClearScreen (Private);
 888 }
 889
 890 EFI_STATUS
 891 EFIAPI
 892 InitializeCirrusLogic5430 (
 893   IN EFI_HANDLE           ImageHandle,
 894   IN EFI_SYSTEM_TABLE     *SystemTable
 895   )
 896 {
 897   EFI_STATUS              Status;
 898
 899   Status = EfiLibInstallDriverBindingComponentName2 (
 900              ImageHandle,
 901              SystemTable,
 902              &gCirrusLogic5430DriverBinding,
 903              ImageHandle,
 904              &gCirrusLogic5430ComponentName,
 905              &gCirrusLogic5430ComponentName2
 906              );
 907   ASSERT_EFI_ERROR (Status);
 908
 909   //
 910   // Install EFI Driver Supported EFI Version Protocol required for
 911   // EFI drivers that are on PCI and other plug in cards.
 912   //
 913   gCirrusLogic5430DriverSupportedEfiVersion.FirmwareVersion = PcdGet32 (PcdDriverSupportedEfiVersion);
 914   Status = gBS->InstallMultipleProtocolInterfaces (
 915                   &ImageHandle,
 916                   &gEfiDriverSupportedEfiVersionProtocolGuid,
 917                   &gCirrusLogic5430DriverSupportedEfiVersion,
 918                   NULL
 919                   );
 920   ASSERT_EFI_ERROR (Status);
 921
 922   return Status;
 923 }