tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/OptionRomPkg/CirrusLogic5430Dxe/CirrusLogic5430.c

924 lines
26 KiB
C
Raw Blame History

/** @file
Cirrus Logic 5430 Controller Driver.
This driver is a sample implementation of the UGA Draw and Graphics Output
Protocols for the Cirrus Logic 5430 family of PCI video controllers.
This driver is only usable in the EFI pre-boot environment.
This sample is intended to show how the UGA Draw and Graphics output Protocol
is able to function.
The UGA I/O Protocol is not implemented in this sample.
A fully compliant EFI UGA driver requires both
the UGA Draw and the UGA I/O Protocol. Please refer to Microsoft's
documentation on UGA for details on how to write a UGA driver that is able
to function both in the EFI pre-boot environment and from the OS runtime.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
//
// Cirrus Logic 5430 Controller Driver
//
#include "CirrusLogic5430.h"
EFI_DRIVER_BINDING_PROTOCOL gCirrusLogic5430DriverBinding = {
CirrusLogic5430ControllerDriverSupported,
CirrusLogic5430ControllerDriverStart,
CirrusLogic5430ControllerDriverStop,
0x10,
NULL,
NULL
};
///
/// Generic Attribute Controller Register Settings
///
UINT8 AttributeController[21] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x41, 0x00, 0x0F, 0x00, 0x00
};
///
/// Generic Graphics Controller Register Settings
///
UINT8 GraphicsController[9] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF
};
//
// 640 x 480 x 256 color @ 60 Hertz
//
UINT8 Crtc_640_480_256_60[28] = {
0x5d, 0x4f, 0x50, 0x82, 0x53, 0x9f, 0x00, 0x3e,
0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xe1, 0x83, 0xdf, 0x50, 0x00, 0xe7, 0x04, 0xe3,
0xff, 0x00, 0x00, 0x22
};
UINT16 Seq_640_480_256_60[15] = {
0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
0x5b0c, 0x450d, 0x7e0e, 0x2b1b, 0x2f1c, 0x301d, 0x331e
};
//
// 800 x 600 x 256 color @ 60 Hertz
//
UINT8 Crtc_800_600_256_60[28] = {
0x7F, 0x63, 0x64, 0x80, 0x6B, 0x1B, 0x72, 0xF0,
0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x58, 0x8C, 0x57, 0x64, 0x00, 0x5F, 0x91, 0xE3,
0xFF, 0x00, 0x00, 0x22
};
UINT16 Seq_800_600_256_60[15] = {
0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
0x5b0c, 0x450d, 0x510e, 0x2b1b, 0x2f1c, 0x301d, 0x3a1e
};
//
// 1024 x 768 x 256 color @ 60 Hertz
//
UINT8 Crtc_1024_768_256_60[28] = {
0xA3, 0x7F, 0x80, 0x86, 0x85, 0x96, 0x24, 0xFD,
0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, 0x88, 0xFF, 0x80, 0x00, 0x00, 0x24, 0xE3,
0xFF, 0x4A, 0x00, 0x22
};
UINT16 Seq_1024_768_256_60[15] = {
0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
0x5b0c, 0x450d, 0x760e, 0x2b1b, 0x2f1c, 0x301d, 0x341e
};
///
/// Table of supported video modes
///
CIRRUS_LOGIC_5430_VIDEO_MODES CirrusLogic5430VideoModes[] = {
{ 640, 480, 8, 60, Crtc_640_480_256_60, Seq_640_480_256_60, 0xe3 },
{ 800, 600, 8, 60, Crtc_800_600_256_60, Seq_800_600_256_60, 0xef },
{ 1024, 768, 8, 60, Crtc_1024_768_256_60, Seq_1024_768_256_60, 0xef }
};
/**
CirrusLogic5430ControllerDriverSupported
TODO: This - add argument and description to function comment
TODO: Controller - add argument and description to function comment
TODO: RemainingDevicePath - add argument and description to function comment
**/
EFI_STATUS
EFIAPI
CirrusLogic5430ControllerDriverSupported (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE Controller,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
)
{
EFI_STATUS Status;
EFI_PCI_IO_PROTOCOL *PciIo;
PCI_TYPE00 Pci;
EFI_DEV_PATH *Node;
//
// Open the PCI I/O Protocol
//
Status = gBS->OpenProtocol (
Controller,
&gEfiPciIoProtocolGuid,
(VOID **) &PciIo,
This->DriverBindingHandle,
Controller,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Read the PCI Configuration Header from the PCI Device
//
Status = PciIo->Pci.Read (
PciIo,
EfiPciIoWidthUint32,
0,
sizeof (Pci) / sizeof (UINT32),
&Pci
);
if (EFI_ERROR (Status)) {
goto Done;
}
Status = EFI_UNSUPPORTED;
//
// See if the I/O enable is on. Most systems only allow one VGA device to be turned on
// at a time, so see if this is one that is turned on.
//
// if (((Pci.Hdr.Command & 0x01) == 0x01)) {
//
// See if this is a Cirrus Logic PCI controller
//
if (Pci.Hdr.VendorId == CIRRUS_LOGIC_VENDOR_ID) {
//
// See if this is a 5430 or a 5446 PCI controller
//
if (Pci.Hdr.DeviceId == CIRRUS_LOGIC_5430_DEVICE_ID ||
Pci.Hdr.DeviceId == CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID ||
Pci.Hdr.DeviceId == CIRRUS_LOGIC_5446_DEVICE_ID) {
Status = EFI_SUCCESS;
//
// If this is an Intel 945 graphics controller,
// go further check RemainingDevicePath validation
//
if (RemainingDevicePath != NULL) {
Node = (EFI_DEV_PATH *) RemainingDevicePath;
//
// Check if RemainingDevicePath is the End of Device Path Node,
// if yes, return EFI_SUCCESS
//
if (!IsDevicePathEnd (Node)) {
//
// If RemainingDevicePath isn't the End of Device Path Node,
// check its validation
//
if (Node->DevPath.Type != ACPI_DEVICE_PATH ||
Node->DevPath.SubType != ACPI_ADR_DP ||
DevicePathNodeLength(&Node->DevPath) != sizeof(ACPI_ADR_DEVICE_PATH)) {
Status = EFI_UNSUPPORTED;
}
}
}
}
}
Done:
//
// Close the PCI I/O Protocol
//
gBS->CloseProtocol (
Controller,
&gEfiPciIoProtocolGuid,
This->DriverBindingHandle,
Controller
);
return Status;
}
/**
CirrusLogic5430ControllerDriverStart
TODO: This - add argument and description to function comment
TODO: Controller - add argument and description to function comment
TODO: RemainingDevicePath - add argument and description to function comment
**/
EFI_STATUS
EFIAPI
CirrusLogic5430ControllerDriverStart (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE Controller,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
)
{
EFI_STATUS Status;
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private;
BOOLEAN PciAttributesSaved;
EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
ACPI_ADR_DEVICE_PATH AcpiDeviceNode;
UINT64 Supports;
PciAttributesSaved = FALSE;
//
// Allocate Private context data for UGA Draw inteface.
//
Private = AllocateZeroPool (sizeof (CIRRUS_LOGIC_5430_PRIVATE_DATA));
if (Private == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Error;
}
//
// Set up context record
//
Private->Signature = CIRRUS_LOGIC_5430_PRIVATE_DATA_SIGNATURE;
Private->Handle = NULL;
//
// Open PCI I/O Protocol
//
Status = gBS->OpenProtocol (
Controller,
&gEfiPciIoProtocolGuid,
(VOID **) &Private->PciIo,
This->DriverBindingHandle,
Controller,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
goto Error;
}
//
// Get supported PCI attributes
//
Status = Private->PciIo->Attributes (
Private->PciIo,
EfiPciIoAttributeOperationSupported,
0,
&Supports
);
if (EFI_ERROR (Status)) {
goto Error;
}
Supports &= (EFI_PCI_IO_ATTRIBUTE_VGA_IO | EFI_PCI_IO_ATTRIBUTE_VGA_IO_16);
if (Supports == 0 || Supports == (EFI_PCI_IO_ATTRIBUTE_VGA_IO | EFI_PCI_IO_ATTRIBUTE_VGA_IO_16)) {
Status = EFI_UNSUPPORTED;
goto Error;
}
//
// Save original PCI attributes
//
Status = Private->PciIo->Attributes (
Private->PciIo,
EfiPciIoAttributeOperationGet,
0,
&Private->OriginalPciAttributes
);
if (EFI_ERROR (Status)) {
goto Error;
}
PciAttributesSaved = TRUE;
Status = Private->PciIo->Attributes (
Private->PciIo,
EfiPciIoAttributeOperationEnable,
EFI_PCI_DEVICE_ENABLE | EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY | Supports,
NULL
);
if (EFI_ERROR (Status)) {
goto Error;
}
//
// Get ParentDevicePath
//
Status = gBS->HandleProtocol (
Controller,
&gEfiDevicePathProtocolGuid,
(VOID **) &ParentDevicePath
);
if (EFI_ERROR (Status)) {
goto Error;
}
if (FeaturePcdGet (PcdSupportGop)) {
//
// Set Gop Device Path
//
if (RemainingDevicePath == NULL) {
ZeroMem (&AcpiDeviceNode, sizeof (ACPI_ADR_DEVICE_PATH));
AcpiDeviceNode.Header.Type = ACPI_DEVICE_PATH;
AcpiDeviceNode.Header.SubType = ACPI_ADR_DP;
AcpiDeviceNode.ADR = ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA, 0, 0);
SetDevicePathNodeLength (&AcpiDeviceNode.Header, sizeof (ACPI_ADR_DEVICE_PATH));
Private->GopDevicePath = AppendDevicePathNode (
ParentDevicePath,
(EFI_DEVICE_PATH_PROTOCOL *) &AcpiDeviceNode
);
} else if (!IsDevicePathEnd (RemainingDevicePath)) {
//
// If RemainingDevicePath isn't the End of Device Path Node,
// only scan the specified device by RemainingDevicePath
//
Private->GopDevicePath = AppendDevicePathNode (ParentDevicePath, RemainingDevicePath);
} else {
//
// If RemainingDevicePath is the End of Device Path Node,
// don't create child device and return EFI_SUCCESS
//
Private->GopDevicePath = NULL;
}
if (Private->GopDevicePath != NULL) {
//
// Creat child handle and device path protocol firstly
//
Private->Handle = NULL;
Status = gBS->InstallMultipleProtocolInterfaces (
&Private->Handle,
&gEfiDevicePathProtocolGuid,
Private->GopDevicePath,
NULL
);
}
}
//
// Construct video mode buffer
//
Status = CirrusLogic5430VideoModeSetup (Private);
if (EFI_ERROR (Status)) {
goto Error;
}
if (FeaturePcdGet (PcdSupportUga)) {
//
// Start the UGA Draw software stack.
//
Status = CirrusLogic5430UgaDrawConstructor (Private);
ASSERT_EFI_ERROR (Status);
Private->UgaDevicePath = ParentDevicePath;
Status = gBS->InstallMultipleProtocolInterfaces (
&Controller,
&gEfiUgaDrawProtocolGuid,
&Private->UgaDraw,
&gEfiDevicePathProtocolGuid,
Private->UgaDevicePath,
NULL
);
} else if (FeaturePcdGet (PcdSupportGop)) {
if (Private->GopDevicePath == NULL) {
//
// If RemainingDevicePath is the End of Device Path Node,
// don't create child device and return EFI_SUCCESS
//
Status = EFI_SUCCESS;
} else {
//
// Start the GOP software stack.
//
Status = CirrusLogic5430GraphicsOutputConstructor (Private);
ASSERT_EFI_ERROR (Status);
Status = gBS->InstallMultipleProtocolInterfaces (
&Private->Handle,
&gEfiGraphicsOutputProtocolGuid,
&Private->GraphicsOutput,
&gEfiEdidDiscoveredProtocolGuid,
&Private->EdidDiscovered,
&gEfiEdidActiveProtocolGuid,
&Private->EdidActive,
NULL
);
}
} else {
//
// This driver must support eithor GOP or UGA or both.
//
ASSERT (FALSE);
Status = EFI_UNSUPPORTED;
}
Error:
if (EFI_ERROR (Status)) {
if (Private) {
if (Private->PciIo) {
if (PciAttributesSaved == TRUE) {
//
// Restore original PCI attributes
//
Private->PciIo->Attributes (
Private->PciIo,
EfiPciIoAttributeOperationSet,
Private->OriginalPciAttributes,
NULL
);
}
//
// Close the PCI I/O Protocol
//
gBS->CloseProtocol (
Private->Handle,
&gEfiPciIoProtocolGuid,
This->DriverBindingHandle,
Private->Handle
);
}
gBS->FreePool (Private);
}
}
return Status;
}
/**
CirrusLogic5430ControllerDriverStop
TODO: This - add argument and description to function comment
TODO: Controller - add argument and description to function comment
TODO: NumberOfChildren - add argument and description to function comment
TODO: ChildHandleBuffer - add argument and description to function comment
TODO: EFI_SUCCESS - add return value to function comment
**/
EFI_STATUS
EFIAPI
CirrusLogic5430ControllerDriverStop (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE Controller,
IN UINTN NumberOfChildren,
IN EFI_HANDLE *ChildHandleBuffer
)
{
EFI_UGA_DRAW_PROTOCOL *UgaDraw;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
EFI_STATUS Status;
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private;
if (FeaturePcdGet (PcdSupportUga)) {
Status = gBS->OpenProtocol (
Controller,
&gEfiUgaDrawProtocolGuid,
(VOID **) &UgaDraw,
This->DriverBindingHandle,
Controller,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get our private context information
//
Private = CIRRUS_LOGIC_5430_PRIVATE_DATA_FROM_UGA_DRAW_THIS (UgaDraw);
CirrusLogic5430UgaDrawDestructor (Private);
if (FeaturePcdGet (PcdSupportGop)) {
CirrusLogic5430GraphicsOutputDestructor (Private);
//
// Remove the UGA and GOP protocol interface from the system
//
Status = gBS->UninstallMultipleProtocolInterfaces (
Private->Handle,
&gEfiUgaDrawProtocolGuid,
&Private->UgaDraw,
&gEfiGraphicsOutputProtocolGuid,
&Private->GraphicsOutput,
NULL
);
} else {
//
// Remove the UGA Draw interface from the system
//
Status = gBS->UninstallMultipleProtocolInterfaces (
Private->Handle,
&gEfiUgaDrawProtocolGuid,
&Private->UgaDraw,
NULL
);
}
} else {
Status = gBS->OpenProtocol (
Controller,
&gEfiGraphicsOutputProtocolGuid,
(VOID **) &GraphicsOutput,
This->DriverBindingHandle,
Controller,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get our private context information
//
Private = CIRRUS_LOGIC_5430_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput);
CirrusLogic5430GraphicsOutputDestructor (Private);
//
// Remove the GOP protocol interface from the system
//
Status = gBS->UninstallMultipleProtocolInterfaces (
Private->Handle,
&gEfiUgaDrawProtocolGuid,
&Private->UgaDraw,
&gEfiGraphicsOutputProtocolGuid,
&Private->GraphicsOutput,
NULL
);
}
if (EFI_ERROR (Status)) {
return Status;
}
//
// Restore original PCI attributes
//
Private->PciIo->Attributes (
Private->PciIo,
EfiPciIoAttributeOperationSet,
Private->OriginalPciAttributes,
NULL
);
//
// Close the PCI I/O Protocol
//
gBS->CloseProtocol (
Controller,
&gEfiPciIoProtocolGuid,
This->DriverBindingHandle,
Controller
);
//
// Free our instance data
//
gBS->FreePool (Private);
return EFI_SUCCESS;
}
/**
CirrusLogic5430UgaDrawDestructor
TODO: Private - add argument and description to function comment
TODO: EFI_SUCCESS - add return value to function comment
**/
EFI_STATUS
CirrusLogic5430UgaDrawDestructor (
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private
)
{
return EFI_SUCCESS;
}
/**
TODO: Add function description
@param Private TODO: add argument description
@param Address TODO: add argument description
@param Data TODO: add argument description
TODO: add return values
**/
VOID
outb (
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
UINTN Address,
UINT8 Data
)
{
Private->PciIo->Io.Write (
Private->PciIo,
EfiPciIoWidthUint8,
EFI_PCI_IO_PASS_THROUGH_BAR,
Address,
1,
&Data
);
}
/**
TODO: Add function description
@param Private TODO: add argument description
@param Address TODO: add argument description
@param Data TODO: add argument description
TODO: add return values
**/
VOID
outw (
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
UINTN Address,
UINT16 Data
)
{
Private->PciIo->Io.Write (
Private->PciIo,
EfiPciIoWidthUint16,
EFI_PCI_IO_PASS_THROUGH_BAR,
Address,
1,
&Data
);
}
/**
TODO: Add function description
@param Private TODO: add argument description
@param Address TODO: add argument description
TODO: add return values
**/
UINT8
inb (
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
UINTN Address
)
{
UINT8 Data;
Private->PciIo->Io.Read (
Private->PciIo,
EfiPciIoWidthUint8,
EFI_PCI_IO_PASS_THROUGH_BAR,
Address,
1,
&Data
);
return Data;
}
/**
TODO: Add function description
@param Private TODO: add argument description
@param Address TODO: add argument description
TODO: add return values
**/
UINT16
inw (
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
UINTN Address
)
{
UINT16 Data;
Private->PciIo->Io.Read (
Private->PciIo,
EfiPciIoWidthUint16,
EFI_PCI_IO_PASS_THROUGH_BAR,
Address,
1,
&Data
);
return Data;
}
/**
TODO: Add function description
@param Private TODO: add argument description
@param Index TODO: add argument description
@param Red TODO: add argument description
@param Green TODO: add argument description
@param Blue TODO: add argument description
TODO: add return values
**/
VOID
SetPaletteColor (
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
UINTN Index,
UINT8 Red,
UINT8 Green,
UINT8 Blue
)
{
outb (Private, PALETTE_INDEX_REGISTER, (UINT8) Index);
outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Red >> 2));
outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Green >> 2));
outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Blue >> 2));
}
/**
TODO: Add function description
@param Private TODO: add argument description
TODO: add return values
**/
VOID
SetDefaultPalette (
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private
)
{
UINTN Index;
UINTN RedIndex;
UINTN GreenIndex;
UINTN BlueIndex;
Index = 0;
for (RedIndex = 0; RedIndex < 8; RedIndex++) {
for (GreenIndex = 0; GreenIndex < 8; GreenIndex++) {
for (BlueIndex = 0; BlueIndex < 4; BlueIndex++) {
SetPaletteColor (Private, Index, (UINT8) (RedIndex << 5), (UINT8) (GreenIndex << 5), (UINT8) (BlueIndex << 6));
Index++;
}
}
}
}
/**
TODO: Add function description
@param Private TODO: add argument description
TODO: add return values
**/
VOID
ClearScreen (
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private
)
{
UINT32 Color;
Color = 0;
Private->PciIo->Mem.Write (
Private->PciIo,
EfiPciIoWidthFillUint32,
0,
0,
0x100000 >> 2,
&Color
);
}
/**
TODO: Add function description
@param Private TODO: add argument description
TODO: add return values
**/
VOID
DrawLogo (
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
UINTN ScreenWidth,
UINTN ScreenHeight
)
{
}
/**
TODO: Add function description
@param Private TODO: add argument description
@param ModeData TODO: add argument description
TODO: add return values
**/
VOID
InitializeGraphicsMode (
CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
CIRRUS_LOGIC_5430_VIDEO_MODES *ModeData
)
{
UINT8 Byte;
UINTN Index;
UINT16 DeviceId;
EFI_STATUS Status;
Status = Private->PciIo->Pci.Read (
Private->PciIo,
EfiPciIoWidthUint16,
PCI_DEVICE_ID_OFFSET,
1,
&DeviceId
);
//
// Read the PCI Configuration Header from the PCI Device
//
ASSERT_EFI_ERROR (Status);
outw (Private, SEQ_ADDRESS_REGISTER, 0x1206);
outw (Private, SEQ_ADDRESS_REGISTER, 0x0012);
for (Index = 0; Index < 15; Index++) {
outw (Private, SEQ_ADDRESS_REGISTER, ModeData->SeqSettings[Index]);
}
if (DeviceId != CIRRUS_LOGIC_5446_DEVICE_ID) {
outb (Private, SEQ_ADDRESS_REGISTER, 0x0f);
Byte = (UINT8) ((inb (Private, SEQ_DATA_REGISTER) & 0xc7) ^ 0x30);
outb (Private, SEQ_DATA_REGISTER, Byte);
}
outb (Private, MISC_OUTPUT_REGISTER, ModeData->MiscSetting);
outw (Private, GRAPH_ADDRESS_REGISTER, 0x0506);
outw (Private, SEQ_ADDRESS_REGISTER, 0x0300);
outw (Private, CRTC_ADDRESS_REGISTER, 0x2011);
for (Index = 0; Index < 28; Index++) {
outw (Private, CRTC_ADDRESS_REGISTER, (UINT16) ((ModeData->CrtcSettings[Index] << 8) | Index));
}
for (Index = 0; Index < 9; Index++) {
outw (Private, GRAPH_ADDRESS_REGISTER, (UINT16) ((GraphicsController[Index] << 8) | Index));
}
inb (Private, INPUT_STATUS_1_REGISTER);
for (Index = 0; Index < 21; Index++) {
outb (Private, ATT_ADDRESS_REGISTER, (UINT8) Index);
outb (Private, ATT_ADDRESS_REGISTER, AttributeController[Index]);
}
outb (Private, ATT_ADDRESS_REGISTER, 0x20);
outw (Private, GRAPH_ADDRESS_REGISTER, 0x0009);
outw (Private, GRAPH_ADDRESS_REGISTER, 0x000a);
outw (Private, GRAPH_ADDRESS_REGISTER, 0x000b);
outb (Private, DAC_PIXEL_MASK_REGISTER, 0xff);
SetDefaultPalette (Private);
ClearScreen (Private);
}
EFI_STATUS
EFIAPI
InitializeCirrusLogic5430 (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
Status = EfiLibInstallDriverBindingComponentName2 (
ImageHandle,
SystemTable,
&gCirrusLogic5430DriverBinding,
ImageHandle,
&gCirrusLogic5430ComponentName,
&gCirrusLogic5430ComponentName2
);
ASSERT_EFI_ERROR (Status);
//
// Install EFI Driver Supported EFI Version Protocol required for
// EFI drivers that are on PCI and other plug in cards.
//
gCirrusLogic5430DriverSupportedEfiVersion.FirmwareVersion = PcdGet32 (PcdDriverSupportedEfiVersion);
Status = gBS->InstallMultipleProtocolInterfaces (
&ImageHandle,
&gEfiDriverSupportedEfiVersionProtocolGuid,
&gCirrusLogic5430DriverSupportedEfiVersion,
NULL
);
ASSERT_EFI_ERROR (Status);
return Status;
}
Reference in New Issue View Git Blame Copy Permalink