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

401 lines
13 KiB
C
Raw Blame History

/** @file
This driver is a implementation of the Graphics Output Protocol
for the QEMU ramfb device.
Copyright (c) 2018, Red Hat Inc.
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.
**/
#include <Protocol/GraphicsOutput.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/DevicePathLib.h>
#include <Library/FrameBufferBltLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/QemuFwCfgLib.h>
#include <Guid/QemuRamfb.h>
#define RAMFB_FORMAT 0x34325258 /* DRM_FORMAT_XRGB8888 */
#define RAMFB_BPP 4
#pragma pack (1)
typedef struct RAMFB_CONFIG {
UINT64 Address;
UINT32 FourCC;
UINT32 Flags;
UINT32 Width;
UINT32 Height;
UINT32 Stride;
} RAMFB_CONFIG;
#pragma pack ()
STATIC EFI_HANDLE mRamfbHandle;
STATIC EFI_HANDLE mGopHandle;
STATIC FRAME_BUFFER_CONFIGURE *mQemuRamfbFrameBufferBltConfigure;
STATIC UINTN mQemuRamfbFrameBufferBltConfigureSize;
STATIC FIRMWARE_CONFIG_ITEM mRamfbFwCfgItem;
STATIC EFI_GRAPHICS_OUTPUT_MODE_INFORMATION mQemuRamfbModeInfo[] = {
{
0, // Version
640, // HorizontalResolution
480, // VerticalResolution
},{
0, // Version
800, // HorizontalResolution
600, // VerticalResolution
},{
0, // Version
1024, // HorizontalResolution
768, // VerticalResolution
}
};
STATIC EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE mQemuRamfbMode = {
ARRAY_SIZE (mQemuRamfbModeInfo), // MaxMode
0, // Mode
mQemuRamfbModeInfo, // Info
sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION), // SizeOfInfo
};
STATIC
EFI_STATUS
EFIAPI
QemuRamfbGraphicsOutputQueryMode (
IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
IN UINT32 ModeNumber,
OUT UINTN *SizeOfInfo,
OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION **Info
)
{
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *ModeInfo;
if (Info == NULL || SizeOfInfo == NULL ||
ModeNumber >= mQemuRamfbMode.MaxMode) {
return EFI_INVALID_PARAMETER;
}
ModeInfo = &mQemuRamfbModeInfo[ModeNumber];
*Info = AllocateCopyPool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION),
ModeInfo);
if (*Info == NULL) {
return EFI_OUT_OF_RESOURCES;
}
*SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
return EFI_SUCCESS;
}
STATIC
EFI_STATUS
EFIAPI
QemuRamfbGraphicsOutputSetMode (
IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
IN UINT32 ModeNumber
)
{
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *ModeInfo;
RAMFB_CONFIG Config;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL Black;
RETURN_STATUS Status;
if (ModeNumber >= mQemuRamfbMode.MaxMode) {
return EFI_UNSUPPORTED;
}
ModeInfo = &mQemuRamfbModeInfo[ModeNumber];
DEBUG ((DEBUG_INFO, "Ramfb: SetMode %u (%ux%u)\n", ModeNumber,
ModeInfo->HorizontalResolution, ModeInfo->VerticalResolution));
Config.Address = SwapBytes64 (mQemuRamfbMode.FrameBufferBase);
Config.FourCC = SwapBytes32 (RAMFB_FORMAT);
Config.Flags = SwapBytes32 (0);
Config.Width = SwapBytes32 (ModeInfo->HorizontalResolution);
Config.Height = SwapBytes32 (ModeInfo->VerticalResolution);
Config.Stride = SwapBytes32 (ModeInfo->HorizontalResolution * RAMFB_BPP);
Status = FrameBufferBltConfigure (
(VOID*)(UINTN)mQemuRamfbMode.FrameBufferBase,
ModeInfo,
mQemuRamfbFrameBufferBltConfigure,
&mQemuRamfbFrameBufferBltConfigureSize
);
if (Status == RETURN_BUFFER_TOO_SMALL) {
if (mQemuRamfbFrameBufferBltConfigure != NULL) {
FreePool (mQemuRamfbFrameBufferBltConfigure);
}
mQemuRamfbFrameBufferBltConfigure =
AllocatePool (mQemuRamfbFrameBufferBltConfigureSize);
if (mQemuRamfbFrameBufferBltConfigure == NULL) {
mQemuRamfbFrameBufferBltConfigureSize = 0;
return EFI_OUT_OF_RESOURCES;
}
Status = FrameBufferBltConfigure (
(VOID*)(UINTN)mQemuRamfbMode.FrameBufferBase,
ModeInfo,
mQemuRamfbFrameBufferBltConfigure,
&mQemuRamfbFrameBufferBltConfigureSize
);
}
if (RETURN_ERROR (Status)) {
ASSERT (Status == RETURN_UNSUPPORTED);
return Status;
}
mQemuRamfbMode.Mode = ModeNumber;
mQemuRamfbMode.Info = ModeInfo;
QemuFwCfgSelectItem (mRamfbFwCfgItem);
QemuFwCfgWriteBytes (sizeof (Config), &Config);
//
// clear screen
//
ZeroMem (&Black, sizeof (Black));
Status = FrameBufferBlt (
mQemuRamfbFrameBufferBltConfigure,
&Black,
EfiBltVideoFill,
0, // SourceX -- ignored
0, // SourceY -- ignored
0, // DestinationX
0, // DestinationY
ModeInfo->HorizontalResolution, // Width
ModeInfo->VerticalResolution, // Height
0 // Delta -- ignored
);
if (RETURN_ERROR (Status)) {
DEBUG ((DEBUG_WARN, "%a: clearing the screen failed: %r\n",
__FUNCTION__, Status));
}
return EFI_SUCCESS;
}
STATIC
EFI_STATUS
EFIAPI
QemuRamfbGraphicsOutputBlt (
IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL
IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
IN UINTN SourceX,
IN UINTN SourceY,
IN UINTN DestinationX,
IN UINTN DestinationY,
IN UINTN Width,
IN UINTN Height,
IN UINTN Delta
)
{
return FrameBufferBlt (
mQemuRamfbFrameBufferBltConfigure,
BltBuffer,
BltOperation,
SourceX,
SourceY,
DestinationX,
DestinationY,
Width,
Height,
Delta
);
}
STATIC EFI_GRAPHICS_OUTPUT_PROTOCOL mQemuRamfbGraphicsOutput = {
QemuRamfbGraphicsOutputQueryMode,
QemuRamfbGraphicsOutputSetMode,
QemuRamfbGraphicsOutputBlt,
&mQemuRamfbMode,
};
EFI_STATUS
EFIAPI
InitializeQemuRamfb (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_DEVICE_PATH_PROTOCOL *RamfbDevicePath;
EFI_DEVICE_PATH_PROTOCOL *GopDevicePath;
VOID *DevicePath;
VENDOR_DEVICE_PATH VendorDeviceNode;
ACPI_ADR_DEVICE_PATH AcpiDeviceNode;
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS FbBase;
UINTN FbSize, MaxFbSize, Pages;
UINTN FwCfgSize;
UINTN Index;
if (!QemuFwCfgIsAvailable ()) {
DEBUG ((DEBUG_INFO, "Ramfb: no FwCfg\n"));
return EFI_NOT_FOUND;
}
Status = QemuFwCfgFindFile ("etc/ramfb", &mRamfbFwCfgItem, &FwCfgSize);
if (EFI_ERROR (Status)) {
return EFI_NOT_FOUND;
}
if (FwCfgSize != sizeof (RAMFB_CONFIG)) {
DEBUG ((DEBUG_ERROR, "Ramfb: FwCfg size mismatch (expected %lu, got %lu)\n",
(UINT64)sizeof (RAMFB_CONFIG), (UINT64)FwCfgSize));
return EFI_PROTOCOL_ERROR;
}
MaxFbSize = 0;
for (Index = 0; Index < ARRAY_SIZE (mQemuRamfbModeInfo); Index++) {
mQemuRamfbModeInfo[Index].PixelsPerScanLine =
mQemuRamfbModeInfo[Index].HorizontalResolution;
mQemuRamfbModeInfo[Index].PixelFormat =
PixelBlueGreenRedReserved8BitPerColor;
FbSize = RAMFB_BPP *
mQemuRamfbModeInfo[Index].HorizontalResolution *
mQemuRamfbModeInfo[Index].VerticalResolution;
if (MaxFbSize < FbSize) {
MaxFbSize = FbSize;
}
DEBUG ((DEBUG_INFO, "Ramfb: Mode %lu: %ux%u, %lu kB\n", (UINT64)Index,
mQemuRamfbModeInfo[Index].HorizontalResolution,
mQemuRamfbModeInfo[Index].VerticalResolution,
(UINT64)(FbSize / 1024)));
}
Pages = EFI_SIZE_TO_PAGES (MaxFbSize);
MaxFbSize = EFI_PAGES_TO_SIZE (Pages);
FbBase = (EFI_PHYSICAL_ADDRESS)(UINTN)AllocateReservedPages (Pages);
if (FbBase == 0) {
DEBUG ((DEBUG_ERROR, "Ramfb: memory allocation failed\n"));
return EFI_OUT_OF_RESOURCES;
}
DEBUG ((DEBUG_INFO, "Ramfb: Framebuffer at 0x%lx, %lu kB, %lu pages\n",
(UINT64)FbBase, (UINT64)(MaxFbSize / 1024), (UINT64)Pages));
mQemuRamfbMode.FrameBufferSize = MaxFbSize;
mQemuRamfbMode.FrameBufferBase = FbBase;
//
// 800 x 600
//
QemuRamfbGraphicsOutputSetMode (&mQemuRamfbGraphicsOutput, 1);
//
// ramfb vendor devpath
//
VendorDeviceNode.Header.Type = HARDWARE_DEVICE_PATH;
VendorDeviceNode.Header.SubType = HW_VENDOR_DP;
CopyGuid (&VendorDeviceNode.Guid, &gQemuRamfbGuid);
SetDevicePathNodeLength (&VendorDeviceNode.Header,
sizeof (VENDOR_DEVICE_PATH));
RamfbDevicePath = AppendDevicePathNode (NULL,
(EFI_DEVICE_PATH_PROTOCOL *) &VendorDeviceNode);
if (RamfbDevicePath == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto FreeFramebuffer;
}
Status = gBS->InstallMultipleProtocolInterfaces (
&mRamfbHandle,
&gEfiDevicePathProtocolGuid,
RamfbDevicePath,
NULL
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Ramfb: install Ramfb Vendor DevicePath failed: %r\n",
Status));
goto FreeRamfbDevicePath;
}
//
// gop devpath + protocol
//
AcpiDeviceNode.Header.Type = ACPI_DEVICE_PATH;
AcpiDeviceNode.Header.SubType = ACPI_ADR_DP;
AcpiDeviceNode.ADR = ACPI_DISPLAY_ADR (
1, // DeviceIdScheme
0, // HeadId
0, // NonVgaOutput
1, // BiosCanDetect
0, // VendorInfo
ACPI_ADR_DISPLAY_TYPE_EXTERNAL_DIGITAL, // Type
0, // Port
0 // Index
);
SetDevicePathNodeLength (&AcpiDeviceNode.Header,
sizeof (ACPI_ADR_DEVICE_PATH));
GopDevicePath = AppendDevicePathNode (RamfbDevicePath,
(EFI_DEVICE_PATH_PROTOCOL *) &AcpiDeviceNode);
if (GopDevicePath == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto FreeRamfbHandle;
}
Status = gBS->InstallMultipleProtocolInterfaces (
&mGopHandle,
&gEfiDevicePathProtocolGuid,
GopDevicePath,
&gEfiGraphicsOutputProtocolGuid,
&mQemuRamfbGraphicsOutput,
NULL
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Ramfb: install GOP DevicePath failed: %r\n",
Status));
goto FreeGopDevicePath;
}
Status = gBS->OpenProtocol (
mRamfbHandle,
&gEfiDevicePathProtocolGuid,
&DevicePath,
gImageHandle,
mGopHandle,
EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Ramfb: OpenProtocol failed: %r\n", Status));
goto FreeGopHandle;
}
return EFI_SUCCESS;
FreeGopHandle:
gBS->UninstallMultipleProtocolInterfaces (
mGopHandle,
&gEfiDevicePathProtocolGuid,
GopDevicePath,
&gEfiGraphicsOutputProtocolGuid,
&mQemuRamfbGraphicsOutput,
NULL
);
FreeGopDevicePath:
FreePool (GopDevicePath);
FreeRamfbHandle:
gBS->UninstallMultipleProtocolInterfaces (
mRamfbHandle,
&gEfiDevicePathProtocolGuid,
RamfbDevicePath,
NULL
);
FreeRamfbDevicePath:
FreePool (RamfbDevicePath);
FreeFramebuffer:
FreePages ((VOID*)(UINTN)mQemuRamfbMode.FrameBufferBase, Pages);
return Status;
}
Reference in New Issue View Git Blame Copy Permalink