49a2d8cbf5
Check whenever an EDID blob is present. In case it is get the display resolution from it. Unless PcdVideoResolutionSource indicates the display resolution has been set already, update PcdVideoHorizontalResolution and PcdVideoVerticalResolution accordingly. Also add the resolution to the mode list. This will make OVMF boot up with the display resolution configured by QEMU, which is 1280x800 by default. The resolution can be set using the xres and yres properties. Here is an example for FullHD: qemu-system-x86_64 -device VGA,xres=1920,yres=1080 Ref: https://bugzilla.tianocore.org/show_bug.cgi?id=3778 Ref: https://bugzilla.redhat.com/show_bug.cgi?id=1749250 Signed-off-by: Gerd Hoffmann <kraxel@redhat.com> Acked-by: Ard Biesheuvel <ardb@kernel.org>
492 lines
13 KiB
C
492 lines
13 KiB
C
/** @file
|
|
Graphics Output Protocol functions for the QEMU video controller.
|
|
|
|
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
|
|
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
**/
|
|
|
|
#include "Qemu.h"
|
|
|
|
///
|
|
/// 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
|
|
};
|
|
|
|
UINT8 Crtc_640_480_32bpp_60[28] = {
|
|
0x5d, 0x4f, 0x50, 0x82, 0x53, 0x9f, 0x00, 0x3e,
|
|
0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0xe1, 0x83, 0xdf, 0x40, 0x00, 0xe7, 0x04, 0xe3,
|
|
0xff, 0x00, 0x00, 0x32
|
|
};
|
|
|
|
UINT16 Seq_640_480_256_60[15] = {
|
|
0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
|
|
0x5b0c, 0x450d, 0x7e0e, 0x2b1b, 0x2f1c, 0x301d, 0x331e
|
|
};
|
|
|
|
UINT16 Seq_640_480_32bpp_60[15] = {
|
|
0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1907, 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
|
|
};
|
|
|
|
UINT8 Crtc_800_600_32bpp_60[28] = {
|
|
0x7F, 0x63, 0x64, 0x80, 0x6B, 0x1B, 0x72, 0xF0,
|
|
0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x58, 0x8C, 0x57, 0x90, 0x00, 0x5F, 0x91, 0xE3,
|
|
0xFF, 0x00, 0x00, 0x32
|
|
};
|
|
|
|
UINT16 Seq_800_600_256_60[15] = {
|
|
0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
|
|
0x5b0c, 0x450d, 0x510e, 0x2b1b, 0x2f1c, 0x301d, 0x3a1e
|
|
};
|
|
|
|
UINT16 Seq_800_600_32bpp_60[15] = {
|
|
0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1907, 0x0008, 0x4a0b,
|
|
0x5b0c, 0x450d, 0x510e, 0x2b1b, 0x2f1c, 0x301d, 0x3a1e
|
|
};
|
|
|
|
UINT8 Crtc_960_720_32bpp_60[28] = {
|
|
0xA3, 0x77, 0x80, 0x86, 0x85, 0x96, 0x24, 0xFD,
|
|
0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x02, 0x88, 0xCF, 0xe0, 0x00, 0x00, 0x64, 0xE3,
|
|
0xFF, 0x4A, 0x00, 0x32
|
|
};
|
|
|
|
UINT16 Seq_960_720_32bpp_60[15] = {
|
|
0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1907, 0x0008, 0x4a0b,
|
|
0x5b0c, 0x450d, 0x760e, 0x2b1b, 0x2f1c, 0x301d, 0x341e
|
|
};
|
|
|
|
//
|
|
// 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
|
|
};
|
|
|
|
//
|
|
// 1024 x 768 x 24-bit color @ 60 Hertz
|
|
//
|
|
UINT8 Crtc_1024_768_24bpp_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, 0x32
|
|
};
|
|
|
|
UINT16 Seq_1024_768_24bpp_60[15] = {
|
|
0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1507, 0x0008, 0x4a0b,
|
|
0x5b0c, 0x450d, 0x760e, 0x2b1b, 0x2f1c, 0x301d, 0x341e
|
|
};
|
|
|
|
UINT8 Crtc_1024_768_32bpp_60[28] = {
|
|
0xA3, 0x7F, 0x80, 0x86, 0x85, 0x96, 0x24, 0xFD,
|
|
0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x02, 0x88, 0xFF, 0xe0, 0x00, 0x00, 0x64, 0xE3,
|
|
0xFF, 0x4A, 0x00, 0x32
|
|
};
|
|
|
|
UINT16 Seq_1024_768_32bpp_60[15] = {
|
|
0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1907, 0x0008, 0x4a0b,
|
|
0x5b0c, 0x450d, 0x760e, 0x2b1b, 0x2f1c, 0x301d, 0x341e
|
|
};
|
|
|
|
///
|
|
/// Table of supported video modes
|
|
///
|
|
QEMU_VIDEO_CIRRUS_MODES QemuVideoCirrusModes[] = {
|
|
// { 640, 480, 8, Crtc_640_480_256_60, Seq_640_480_256_60, 0xe3 },
|
|
// { 800, 600, 8, Crtc_800_600_256_60, Seq_800_600_256_60, 0xef },
|
|
{ 640, 480, 32, Crtc_640_480_32bpp_60, Seq_640_480_32bpp_60, 0xef },
|
|
{ 800, 600, 32, Crtc_800_600_32bpp_60, Seq_800_600_32bpp_60, 0xef },
|
|
// { 1024, 768, 8, Crtc_1024_768_256_60, Seq_1024_768_256_60, 0xef }
|
|
{ 1024, 768, 24, Crtc_1024_768_24bpp_60, Seq_1024_768_24bpp_60, 0xef }
|
|
// { 1024, 768, 32, Crtc_1024_768_32bpp_60, Seq_1024_768_32bpp_60, 0xef }
|
|
// { 960, 720, 32, Crtc_960_720_32bpp_60, Seq_1024_768_32bpp_60, 0xef }
|
|
};
|
|
|
|
#define QEMU_VIDEO_CIRRUS_MODE_COUNT \
|
|
(ARRAY_SIZE (QemuVideoCirrusModes))
|
|
|
|
/**
|
|
Construct the valid video modes for QemuVideo.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
QemuVideoCirrusModeSetup (
|
|
QEMU_VIDEO_PRIVATE_DATA *Private
|
|
)
|
|
{
|
|
UINT32 Index;
|
|
QEMU_VIDEO_MODE_DATA *ModeData;
|
|
QEMU_VIDEO_CIRRUS_MODES *VideoMode;
|
|
|
|
//
|
|
// Setup Video Modes
|
|
//
|
|
Private->ModeData = AllocatePool (
|
|
sizeof (Private->ModeData[0]) * QEMU_VIDEO_CIRRUS_MODE_COUNT
|
|
);
|
|
if (Private->ModeData == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
ModeData = Private->ModeData;
|
|
VideoMode = &QemuVideoCirrusModes[0];
|
|
for (Index = 0; Index < QEMU_VIDEO_CIRRUS_MODE_COUNT; Index++) {
|
|
ModeData->InternalModeIndex = Index;
|
|
ModeData->HorizontalResolution = VideoMode->Width;
|
|
ModeData->VerticalResolution = VideoMode->Height;
|
|
ModeData->ColorDepth = VideoMode->ColorDepth;
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"Adding Mode %d as Cirrus Internal Mode %d: %dx%d, %d-bit\n",
|
|
(INT32)(ModeData - Private->ModeData),
|
|
ModeData->InternalModeIndex,
|
|
ModeData->HorizontalResolution,
|
|
ModeData->VerticalResolution,
|
|
ModeData->ColorDepth
|
|
));
|
|
|
|
ModeData++;
|
|
VideoMode++;
|
|
}
|
|
|
|
Private->MaxMode = ModeData - Private->ModeData;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
///
|
|
/// Table of supported video modes
|
|
///
|
|
STATIC QEMU_VIDEO_BOCHS_MODES QemuVideoBochsModes[] = {
|
|
{ 640, 480 },
|
|
{ 800, 480 },
|
|
{ 800, 600 },
|
|
{ 832, 624 },
|
|
{ 960, 640 },
|
|
{ 1024, 600 },
|
|
{ 1024, 768 },
|
|
{ 1152, 864 },
|
|
{ 1152, 870 },
|
|
{ 1280, 720 },
|
|
{ 1280, 760 },
|
|
{ 1280, 768 },
|
|
{ 1280, 800 },
|
|
{ 1280, 960 },
|
|
{ 1280, 1024 },
|
|
{ 1360, 768 },
|
|
{ 1366, 768 },
|
|
{ 1400, 1050 },
|
|
{ 1440, 900 },
|
|
{ 1600, 900 },
|
|
{ 1600, 1200 },
|
|
{ 1680, 1050 },
|
|
{ 1920, 1080 },
|
|
{ 1920, 1200 },
|
|
{ 1920, 1440 },
|
|
{ 2000, 2000 },
|
|
{ 2048, 1536 },
|
|
{ 2048, 2048 },
|
|
{ 2560, 1440 },
|
|
{ 2560, 1600 },
|
|
{ 2560, 2048 },
|
|
{ 2800, 2100 },
|
|
{ 3200, 2400 },
|
|
{ 3840, 2160 },
|
|
{ 4096, 2160 },
|
|
{ 7680, 4320 },
|
|
{ 8192, 4320 }
|
|
};
|
|
|
|
#define QEMU_VIDEO_BOCHS_MODE_COUNT \
|
|
(ARRAY_SIZE (QemuVideoBochsModes))
|
|
|
|
STATIC
|
|
VOID
|
|
QemuVideoBochsAddMode (
|
|
QEMU_VIDEO_PRIVATE_DATA *Private,
|
|
UINT32 AvailableFbSize,
|
|
UINT32 Width,
|
|
UINT32 Height
|
|
)
|
|
{
|
|
QEMU_VIDEO_MODE_DATA *ModeData = Private->ModeData + Private->MaxMode;
|
|
UINTN RequiredFbSize;
|
|
|
|
RequiredFbSize = (UINTN)Width * Height * 4;
|
|
if (RequiredFbSize > AvailableFbSize) {
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"Skipping Bochs Mode %dx%d, 32-bit (not enough vram)\n",
|
|
Width,
|
|
Height
|
|
));
|
|
return;
|
|
}
|
|
|
|
ModeData->InternalModeIndex = (UINT32)Private->MaxMode;
|
|
ModeData->HorizontalResolution = Width;
|
|
ModeData->VerticalResolution = Height;
|
|
ModeData->ColorDepth = 32;
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"Adding Bochs Internal Mode %d: %dx%d, %d-bit\n",
|
|
ModeData->InternalModeIndex,
|
|
ModeData->HorizontalResolution,
|
|
ModeData->VerticalResolution,
|
|
ModeData->ColorDepth
|
|
));
|
|
|
|
Private->MaxMode++;
|
|
}
|
|
|
|
STATIC
|
|
VOID
|
|
QemuVideoBochsEdid (
|
|
QEMU_VIDEO_PRIVATE_DATA *Private,
|
|
UINT32 *XRes,
|
|
UINT32 *YRes
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
if (Private->Variant != QEMU_VIDEO_BOCHS_MMIO) {
|
|
return;
|
|
}
|
|
|
|
Status = Private->PciIo->Mem.Read (
|
|
Private->PciIo,
|
|
EfiPciIoWidthUint8,
|
|
PCI_BAR_IDX2,
|
|
0,
|
|
sizeof (Private->Edid),
|
|
Private->Edid
|
|
);
|
|
if (Status != EFI_SUCCESS) {
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"%a: mmio read failed\n",
|
|
__FUNCTION__
|
|
));
|
|
return;
|
|
}
|
|
|
|
if ((Private->Edid[0] != 0x00) ||
|
|
(Private->Edid[1] != 0xff))
|
|
{
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"%a: magic check failed\n",
|
|
__FUNCTION__
|
|
));
|
|
return;
|
|
}
|
|
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"%a: blob found (extensions: %d)\n",
|
|
__FUNCTION__,
|
|
Private->Edid[126]
|
|
));
|
|
|
|
if ((Private->Edid[54] == 0x00) &&
|
|
(Private->Edid[55] == 0x00))
|
|
{
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"%a: no detailed timing descriptor\n",
|
|
__FUNCTION__
|
|
));
|
|
return;
|
|
}
|
|
|
|
*XRes = Private->Edid[56] | ((Private->Edid[58] & 0xf0) << 4);
|
|
*YRes = Private->Edid[59] | ((Private->Edid[61] & 0xf0) << 4);
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"%a: default resolution: %dx%d\n",
|
|
__FUNCTION__,
|
|
*XRes,
|
|
*YRes
|
|
));
|
|
|
|
if (PcdGet8 (PcdVideoResolutionSource) == 0) {
|
|
Status = PcdSet32S (PcdVideoHorizontalResolution, *XRes);
|
|
ASSERT_RETURN_ERROR (Status);
|
|
Status = PcdSet32S (PcdVideoVerticalResolution, *YRes);
|
|
ASSERT_RETURN_ERROR (Status);
|
|
Status = PcdSet8S (PcdVideoResolutionSource, 2);
|
|
ASSERT_RETURN_ERROR (Status);
|
|
}
|
|
|
|
// TODO: register edid as gEfiEdidDiscoveredProtocolGuid ?
|
|
}
|
|
|
|
EFI_STATUS
|
|
QemuVideoBochsModeSetup (
|
|
QEMU_VIDEO_PRIVATE_DATA *Private,
|
|
BOOLEAN IsQxl
|
|
)
|
|
{
|
|
UINT32 AvailableFbSize;
|
|
UINT32 Index, XRes = 0, YRes = 0;
|
|
|
|
//
|
|
// Fetch the available framebuffer size.
|
|
//
|
|
// VBE_DISPI_INDEX_VIDEO_MEMORY_64K is expected to return the size of the
|
|
// drawable framebuffer. Up to and including qemu-2.1 however it used to
|
|
// return the size of PCI BAR 0 (ie. the full video RAM size).
|
|
//
|
|
// On stdvga the two concepts coincide with each other; the full memory size
|
|
// is usable for drawing.
|
|
//
|
|
// On QXL however, only a leading segment, "surface 0", can be used for
|
|
// drawing; the rest of the video memory is used for the QXL guest-host
|
|
// protocol. VBE_DISPI_INDEX_VIDEO_MEMORY_64K should report the size of
|
|
// "surface 0", but since it doesn't (up to and including qemu-2.1), we
|
|
// retrieve the size of the drawable portion from a field in the QXL ROM BAR,
|
|
// where it is also available.
|
|
//
|
|
if (IsQxl) {
|
|
UINT32 Signature;
|
|
UINT32 DrawStart;
|
|
|
|
Signature = 0;
|
|
DrawStart = 0xFFFFFFFF;
|
|
AvailableFbSize = 0;
|
|
if (EFI_ERROR (
|
|
Private->PciIo->Mem.Read (
|
|
Private->PciIo,
|
|
EfiPciIoWidthUint32,
|
|
PCI_BAR_IDX2,
|
|
0,
|
|
1,
|
|
&Signature
|
|
)
|
|
) ||
|
|
(Signature != SIGNATURE_32 ('Q', 'X', 'R', 'O')) ||
|
|
EFI_ERROR (
|
|
Private->PciIo->Mem.Read (
|
|
Private->PciIo,
|
|
EfiPciIoWidthUint32,
|
|
PCI_BAR_IDX2,
|
|
36,
|
|
1,
|
|
&DrawStart
|
|
)
|
|
) ||
|
|
(DrawStart != 0) ||
|
|
EFI_ERROR (
|
|
Private->PciIo->Mem.Read (
|
|
Private->PciIo,
|
|
EfiPciIoWidthUint32,
|
|
PCI_BAR_IDX2,
|
|
40,
|
|
1,
|
|
&AvailableFbSize
|
|
)
|
|
))
|
|
{
|
|
DEBUG ((
|
|
DEBUG_ERROR,
|
|
"%a: can't read size of drawable buffer from QXL "
|
|
"ROM\n",
|
|
__FUNCTION__
|
|
));
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
} else {
|
|
AvailableFbSize = BochsRead (Private, VBE_DISPI_INDEX_VIDEO_MEMORY_64K);
|
|
AvailableFbSize *= SIZE_64KB;
|
|
}
|
|
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"%a: AvailableFbSize=0x%x\n",
|
|
__FUNCTION__,
|
|
AvailableFbSize
|
|
));
|
|
|
|
//
|
|
// Setup Video Modes
|
|
//
|
|
Private->ModeData = AllocatePool (
|
|
sizeof (Private->ModeData[0]) * (QEMU_VIDEO_BOCHS_MODE_COUNT+1)
|
|
);
|
|
if (Private->ModeData == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
QemuVideoBochsEdid (Private, &XRes, &YRes);
|
|
if (XRes && YRes) {
|
|
QemuVideoBochsAddMode (
|
|
Private,
|
|
AvailableFbSize,
|
|
XRes,
|
|
YRes
|
|
);
|
|
}
|
|
|
|
for (Index = 0; Index < QEMU_VIDEO_BOCHS_MODE_COUNT; Index++) {
|
|
if ((QemuVideoBochsModes[Index].Width == XRes) &&
|
|
(QemuVideoBochsModes[Index].Height == YRes))
|
|
{
|
|
continue; // duplicate with edid resolution
|
|
}
|
|
|
|
QemuVideoBochsAddMode (
|
|
Private,
|
|
AvailableFbSize,
|
|
QemuVideoBochsModes[Index].Width,
|
|
QemuVideoBochsModes[Index].Height
|
|
);
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|