1835 lines
50 KiB
C
1835 lines
50 KiB
C
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
vesa.c
|
|
|
|
Abstract:
|
|
|
|
This module implements VESA support.
|
|
|
|
Author:
|
|
|
|
Erick Smith (ericks) Sep. 2000
|
|
|
|
Environment:
|
|
|
|
kernel mode only
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "dderror.h"
|
|
#include "devioctl.h"
|
|
#include "miniport.h"
|
|
|
|
#include "ntddvdeo.h"
|
|
#include "video.h"
|
|
#include "vga.h"
|
|
#include "vesa.h"
|
|
|
|
#if defined(ALLOC_PRAGMA)
|
|
#pragma alloc_text(PAGE,ValidateVbeInfo)
|
|
#pragma alloc_text(PAGE,InitializeModeTable)
|
|
#pragma alloc_text(PAGE,UpdateRegistry)
|
|
#pragma alloc_text(PAGE,VgaSaveHardwareState)
|
|
#pragma alloc_text(PAGE,VesaSaveHardwareState)
|
|
#pragma alloc_text(PAGE,GetVideoMemoryBaseAddress)
|
|
#pragma alloc_text(PAGE,RaiseToPower2)
|
|
#pragma alloc_text(PAGE,RaiseToPower2Ulong)
|
|
#pragma alloc_text(PAGE,IsPower2)
|
|
#pragma alloc_text(PAGE,VBESetMode)
|
|
#pragma alloc_text(PAGE,VBEGetMode)
|
|
#pragma alloc_text(PAGE,VBEGetModeInfo)
|
|
#pragma alloc_text(PAGE,VBESaveState)
|
|
#pragma alloc_text(PAGE,VBERestoreState)
|
|
#pragma alloc_text(PAGE,VBESetDisplayWindow)
|
|
#pragma alloc_text(PAGE,VBEGetDisplayWindow)
|
|
#pragma alloc_text(PAGE,VBEGetScanLineLength)
|
|
#pragma alloc_text(PAGE,IsSavedModeVesa)
|
|
#pragma alloc_text(PAGE,VesaSaveHardwareState)
|
|
#pragma alloc_text(PAGE,VesaRestoreHardwareState)
|
|
#pragma alloc_text(PAGE,SaveFrameBuffer)
|
|
#pragma alloc_text(PAGE,RestoreFrameBuffer)
|
|
#endif
|
|
|
|
USHORT
|
|
RaiseToPower2(
|
|
USHORT x
|
|
)
|
|
|
|
{
|
|
USHORT Mask = x;
|
|
|
|
if (Mask & (Mask - 1)) {
|
|
|
|
Mask = 1;
|
|
|
|
while (Mask < x && Mask != 0) {
|
|
Mask <<= 1;
|
|
}
|
|
}
|
|
|
|
return Mask;
|
|
}
|
|
|
|
ULONG
|
|
RaiseToPower2Ulong(
|
|
ULONG x
|
|
)
|
|
|
|
{
|
|
ULONG Mask = x;
|
|
|
|
if (Mask & (Mask - 1)) {
|
|
|
|
Mask = 1;
|
|
|
|
while (Mask < x && Mask != 0) {
|
|
Mask <<= 1;
|
|
}
|
|
}
|
|
|
|
return Mask;
|
|
}
|
|
|
|
BOOLEAN
|
|
IsPower2(
|
|
USHORT x
|
|
)
|
|
|
|
{
|
|
return( !(x & (x- 1)) );
|
|
}
|
|
|
|
VOID
|
|
UpdateRegistry(
|
|
PHW_DEVICE_EXTENSION hwDeviceExtension,
|
|
PWSTR ValueName,
|
|
PUCHAR Value
|
|
)
|
|
|
|
/*++
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG Len = (strlen(Value) + 1) * 2;
|
|
PWSTR WideString;
|
|
|
|
WideString = VideoPortAllocatePool(hwDeviceExtension,
|
|
VpPagedPool,
|
|
Len,
|
|
' agV');
|
|
|
|
if (WideString) {
|
|
|
|
PWSTR ptr = WideString;
|
|
|
|
while(*Value) {
|
|
*ptr++ = (WCHAR) *Value++;
|
|
}
|
|
*ptr = 0;
|
|
|
|
VideoPortSetRegistryParameters(hwDeviceExtension,
|
|
ValueName,
|
|
WideString,
|
|
Len);
|
|
|
|
VideoPortFreePool(hwDeviceExtension, WideString);
|
|
}
|
|
}
|
|
|
|
BOOLEAN
|
|
IsVesaBiosOk(
|
|
PVIDEO_PORT_INT10_INTERFACE pInt10,
|
|
USHORT OemSoftwareRev,
|
|
PUCHAR OemVendorName,
|
|
PUCHAR OemProductName,
|
|
PUCHAR OemProductRev
|
|
)
|
|
|
|
{
|
|
|
|
VideoDebugPrint((1, "OemSoftwareRev = %d\n", OemSoftwareRev));
|
|
VideoDebugPrint((1, "OemVendorName = '%s'\n", OemVendorName));
|
|
VideoDebugPrint((1, "OemProductName = '%s'\n", OemProductName));
|
|
VideoDebugPrint((1, "OemProductRev = '%s'\n", OemProductRev));
|
|
|
|
//
|
|
// The ATI ArtX boxes currently have a VESA Bios bug where
|
|
// they indicate they support linear mode access when
|
|
// they don't. Fail these boards.
|
|
//
|
|
|
|
if ((strcmp(OemProductName, "ATI S1-370TL") == 0) ||
|
|
(strcmp(OemProductName, "ArtX I") == 0)) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Several 3dfx boards have buggy vesa bioses. The mode set
|
|
// works, but the display is corrupted.
|
|
//
|
|
|
|
if ((strcmp(OemProductName, "Voodoo4 4500 ") == 0) ||
|
|
(strcmp(OemProductName, "Voodoo3 3000 LC ") == 0) ||
|
|
(strcmp(OemProductName, "Voodoo3 2000 LC ") == 0) ||
|
|
(strcmp(OemProductName, "3Dfx Banshee") == 0)) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Matrox G100 boards with rev 1.05 bioses can't set vesa modes.
|
|
// We hang in the bios.
|
|
//
|
|
|
|
if ((strcmp(OemProductName, "MGA-G100") == 0) &&
|
|
(OemSoftwareRev == 0x105)) {
|
|
|
|
//
|
|
// We must also disable 800x600x16 color mode for this
|
|
// device. This makes the assumption that the mode we
|
|
// are deleting is the last mode in our table.
|
|
//
|
|
|
|
NumVideoModes--;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// We have seen at least on SIS 5597 part which returns a bad
|
|
// linear address. Lets disable these parts.
|
|
//
|
|
|
|
if (strcmp(OemProductName, "SiS 5597") == 0) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// We found a bad nVidia GeForce MX part. It hangs in the bios
|
|
// on boot.
|
|
//
|
|
|
|
if ((strcmp(OemVendorName, "NVidia Corporation") == 0) &&
|
|
(strcmp(OemProductName, "NV11 (GeForce2) Board") == 0) &&
|
|
(strcmp(OemProductRev, "Chip Rev B2") == 0) &&
|
|
(OemSoftwareRev == 0x311)) {
|
|
|
|
//
|
|
// This bios "may" be buggy, but in an effort to not kill
|
|
// vesa support on all GeForce MX boards, lets also look at
|
|
// the version string embedded in the bios.
|
|
//
|
|
// We know the bad bios's have the following string at location
|
|
// c000:0159:
|
|
//
|
|
// "Version 3.11.01.24N16"
|
|
//
|
|
// Lets read from this location and try to match on this string
|
|
//
|
|
|
|
UCHAR Version[22];
|
|
pInt10->Int10ReadMemory(pInt10->Context,
|
|
(USHORT)0xC000,
|
|
(USHORT)0x0159,
|
|
Version,
|
|
21);
|
|
|
|
Version[21] = 0;
|
|
|
|
if (strcmp(Version, "Version 3.11.01.24N16") == 0) {
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOLEAN
|
|
ValidateVbeInfo(
|
|
PHW_DEVICE_EXTENSION hwDeviceExtension,
|
|
PVGA_INFO_BLOCK InfoBlock
|
|
)
|
|
|
|
/*++
|
|
|
|
Notes:
|
|
|
|
This routine makes the assumption that the InfoBlock is still
|
|
valid in the VDM transfer area.
|
|
|
|
--*/
|
|
|
|
{
|
|
PVIDEO_PORT_INT10_INTERFACE pInt10;
|
|
BOOLEAN UseVesa = FALSE;
|
|
|
|
pInt10 = &hwDeviceExtension->Int10;
|
|
|
|
if (InfoBlock->VesaSignature == 'ASEV') {
|
|
|
|
PUCHAR OemString;
|
|
UCHAR OemStringBuffer[80];
|
|
ULONG MemorySize;
|
|
|
|
//
|
|
// Capture OEM String
|
|
//
|
|
|
|
pInt10->Int10ReadMemory(pInt10->Context,
|
|
(USHORT)SEG(InfoBlock->OemStringPtr),
|
|
(USHORT)OFF(InfoBlock->OemStringPtr),
|
|
OemStringBuffer,
|
|
80);
|
|
|
|
OemString = OemStringBuffer;
|
|
|
|
VideoDebugPrint((1, "*********************************************\n"));
|
|
VideoDebugPrint((1, " VBE Signature: VESA\n"));
|
|
VideoDebugPrint((1, " VBE Version: %d.%02d\n",
|
|
InfoBlock->VbeVersion >> 8,
|
|
InfoBlock->VbeVersion & 0xff));
|
|
VideoDebugPrint((1, " OEM String: %s\n",
|
|
OemString));
|
|
|
|
if (InfoBlock->TotalMemory < 16) {
|
|
|
|
//
|
|
// If less than 1 meg, display in KB
|
|
//
|
|
|
|
VideoDebugPrint((1, " Total Memory: %dKB\n",
|
|
InfoBlock->TotalMemory * 64));
|
|
|
|
} else {
|
|
|
|
//
|
|
// Else display in MB
|
|
//
|
|
|
|
VideoDebugPrint((1, " Total Memory: %dMB\n",
|
|
InfoBlock->TotalMemory / 16));
|
|
}
|
|
|
|
if (InfoBlock->VbeVersion >= 0x102) {
|
|
|
|
UCHAR OemVendorName[80];
|
|
UCHAR OemProductName[80];
|
|
UCHAR OemProductRev[80];
|
|
|
|
pInt10->Int10ReadMemory(pInt10->Context,
|
|
(USHORT)SEG(InfoBlock->OemVendorNamePtr),
|
|
(USHORT)OFF(InfoBlock->OemVendorNamePtr),
|
|
OemVendorName,
|
|
80);
|
|
|
|
pInt10->Int10ReadMemory(pInt10->Context,
|
|
(USHORT)SEG(InfoBlock->OemProductNamePtr),
|
|
(USHORT)OFF(InfoBlock->OemProductNamePtr),
|
|
OemProductName,
|
|
80);
|
|
|
|
pInt10->Int10ReadMemory(pInt10->Context,
|
|
(USHORT)SEG(InfoBlock->OemProductRevPtr),
|
|
(USHORT)OFF(InfoBlock->OemProductRevPtr),
|
|
OemProductRev,
|
|
80);
|
|
|
|
OemVendorName[79] = 0;
|
|
OemProductName[79] = 0;
|
|
OemProductRev[79] = 0;
|
|
|
|
VideoDebugPrint((1, " OEM Software Rev: %d.%02d\n",
|
|
InfoBlock->OemSoftwareRev >> 8,
|
|
InfoBlock->OemSoftwareRev & 0xff));
|
|
VideoDebugPrint((1, " OEM Vendor Name: %s\n", OemVendorName));
|
|
VideoDebugPrint((1, " OEM Product Name: %s\n", OemProductName));
|
|
VideoDebugPrint((1, " OEM Product Rev: %s\n", OemProductRev));
|
|
|
|
UseVesa = IsVesaBiosOk(pInt10,
|
|
InfoBlock->OemSoftwareRev,
|
|
OemVendorName,
|
|
OemProductName,
|
|
OemProductRev);
|
|
|
|
}
|
|
|
|
VideoDebugPrint((1, "*********************************************\n"));
|
|
|
|
#if 0
|
|
//
|
|
// It would be nice if we could dump the following info into the
|
|
// registry. But as the GDI code currently stands, if we add
|
|
// ChipType or AdapterString info into the registry, we lose
|
|
// fullscreen support. This has to do with the way GDI currently
|
|
// determines the fullscreen device.
|
|
//
|
|
// For now, lets just not add this registry info.
|
|
//
|
|
|
|
UpdateRegistry(hwDeviceExtension,
|
|
L"HardwareInformation.ChipType",
|
|
OemString);
|
|
|
|
//
|
|
// Adapter String MUST be VGA. Without it, the system won't
|
|
// recognize this driver as the VGA driver.
|
|
//
|
|
|
|
UpdateRegistry(hwDeviceExtension,
|
|
L"HardwareInformation.AdapterString",
|
|
"VGA");
|
|
|
|
UpdateRegistry(hwDeviceExtension,
|
|
L"HardwareInformation.DacType",
|
|
(InfoBlock->Capabilities & VBE_CAP_DAC_WIDTH_8BPP)
|
|
? "8 bit" : "6 bit");
|
|
|
|
UpdateRegistry(hwDeviceExtension,
|
|
L"HardwareInformation.BiosString",
|
|
OemProductRev);
|
|
|
|
//
|
|
// Store memory size in registry
|
|
//
|
|
|
|
MemorySize = InfoBlock->TotalMemory << 16;
|
|
|
|
VideoPortSetRegistryParameters(hwDeviceExtension,
|
|
L"HardwareInformation.MemorySize",
|
|
&MemorySize,
|
|
sizeof(ULONG));
|
|
#endif
|
|
|
|
} else {
|
|
|
|
VideoDebugPrint((0, "Invalid VBE Info Block.\n"));
|
|
}
|
|
|
|
return UseVesa;
|
|
}
|
|
|
|
VOID
|
|
InitializeModeTable(
|
|
PVOID HwDeviceExtension
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine does one time initialization of the device.
|
|
|
|
Arguments:
|
|
|
|
HwDeviceExtension - Pointer to the miniport driver's adapter information.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PHW_DEVICE_EXTENSION hwDeviceExtension = HwDeviceExtension;
|
|
INT10_BIOS_ARGUMENTS BiosArguments;
|
|
PVGA_INFO_BLOCK InfoBlock;
|
|
PMODE_INFO_BLOCK ModeBlock;
|
|
PUSHORT ModeTable;
|
|
PUSHORT ModePtr;
|
|
ULONG NumVesaModes;
|
|
PVIDEOMODE VideoModePtr;
|
|
LONG TotalMemory;
|
|
ULONG VideoMemoryRequired;
|
|
USHORT VbeVersion;
|
|
PULONG Memory;
|
|
ULONG AdditionalModes = 0;
|
|
|
|
USHORT VdmSeg, VdmOff;
|
|
VP_STATUS Status;
|
|
PVIDEO_PORT_INT10_INTERFACE pInt10;
|
|
ULONG Length = 0x1000;
|
|
|
|
BOOLEAN LinearModeSupported;
|
|
BOOLEAN ModeValid;
|
|
|
|
hwDeviceExtension->Int10.Size = sizeof(VIDEO_PORT_INT10_INTERFACE);
|
|
hwDeviceExtension->Int10.Version = 1;
|
|
|
|
Status = VideoPortQueryServices(hwDeviceExtension,
|
|
VideoPortServicesInt10,
|
|
(PINTERFACE)&hwDeviceExtension->Int10);
|
|
|
|
VgaModeList = ModesVGA;
|
|
|
|
if (Status == NO_ERROR) {
|
|
|
|
pInt10 = &hwDeviceExtension->Int10;
|
|
|
|
pInt10->InterfaceReference(pInt10->Context);
|
|
|
|
//
|
|
// Get a chunk of memory in VDM area to use for buffers.
|
|
//
|
|
|
|
Status = pInt10->Int10AllocateBuffer(pInt10->Context,
|
|
&VdmSeg,
|
|
&VdmOff,
|
|
&Length);
|
|
|
|
if ((Status != NO_ERROR) || (Length < 0x1000)) {
|
|
ASSERT(FALSE);
|
|
}
|
|
|
|
hwDeviceExtension->VdmSeg = VdmSeg;
|
|
hwDeviceExtension->VdmOff = VdmOff;
|
|
|
|
//
|
|
// Allocate Memory
|
|
//
|
|
|
|
InfoBlock = VideoPortAllocatePool(hwDeviceExtension,
|
|
VpPagedPool,
|
|
sizeof(VGA_INFO_BLOCK) +
|
|
sizeof(MODE_INFO_BLOCK) +
|
|
256 +
|
|
2, // space for a 0xffff terminator
|
|
' agV');
|
|
|
|
if (InfoBlock) {
|
|
|
|
ModeBlock = (PMODE_INFO_BLOCK)((ULONG_PTR)InfoBlock + sizeof(VGA_INFO_BLOCK));
|
|
ModeTable = (PUSHORT)((ULONG_PTR)ModeBlock + sizeof(MODE_INFO_BLOCK));
|
|
|
|
ModeTable[128] = 0xffff; // make sure we have a mode terminator
|
|
|
|
//
|
|
// Get VESA mode information
|
|
//
|
|
|
|
InfoBlock->VesaSignature = '2EBV';
|
|
|
|
pInt10->Int10WriteMemory(pInt10->Context,
|
|
VdmSeg,
|
|
VdmOff,
|
|
InfoBlock,
|
|
sizeof(VGA_INFO_BLOCK));
|
|
|
|
//
|
|
// Get SuperVGA support info
|
|
//
|
|
|
|
BiosArguments.Eax = 0x4f00;
|
|
BiosArguments.Edi = VdmOff;
|
|
BiosArguments.SegEs = VdmSeg;
|
|
|
|
pInt10->Int10CallBios(pInt10->Context, &BiosArguments);
|
|
|
|
pInt10->Int10ReadMemory(pInt10->Context,
|
|
VdmSeg,
|
|
VdmOff,
|
|
InfoBlock,
|
|
sizeof(VGA_INFO_BLOCK));
|
|
|
|
TotalMemory = InfoBlock->TotalMemory * 0x10000;
|
|
VbeVersion = InfoBlock->VbeVersion;
|
|
|
|
//
|
|
// NOTE: We must call ValidateVbeInfo while the info block
|
|
// is still in the transfer area.
|
|
//
|
|
|
|
if (ValidateVbeInfo(hwDeviceExtension, InfoBlock)) {
|
|
|
|
//
|
|
// Capture the list of mode numbers
|
|
//
|
|
|
|
pInt10->Int10ReadMemory(pInt10->Context,
|
|
(USHORT)(InfoBlock->VideoModePtr >> 16),
|
|
(USHORT)(InfoBlock->VideoModePtr & 0xffff),
|
|
ModeTable,
|
|
256);
|
|
|
|
//
|
|
// Count the number of VESA modes, and allocate memory for the
|
|
// mode list. The mode list is terminated by a -1.
|
|
//
|
|
|
|
ModePtr = ModeTable;
|
|
NumVesaModes = 0;
|
|
|
|
while (*ModePtr != 0xffff) {
|
|
NumVesaModes++;
|
|
ModePtr++;
|
|
}
|
|
|
|
if (NumVesaModes == 128) {
|
|
|
|
//
|
|
// Something is wrong. We hit our hard coded terminator.
|
|
// Don't try to use vesa modes.
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
VgaModeList = VideoPortAllocatePool(hwDeviceExtension,
|
|
VpPagedPool,
|
|
(NumVesaModes + NumVideoModes) *
|
|
sizeof(VIDEOMODE),
|
|
' agV');
|
|
|
|
if (VgaModeList == NULL) {
|
|
|
|
VideoDebugPrint((0, "failed to allocate %d bytes.\n",
|
|
(NumVesaModes + NumVideoModes) * sizeof(VIDEOMODE)));
|
|
|
|
VgaModeList = ModesVGA;
|
|
|
|
//
|
|
// Perform clean up.
|
|
//
|
|
|
|
VideoPortFreePool(hwDeviceExtension, InfoBlock);
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Copy the existing constant VGA modes into our mode list table.
|
|
//
|
|
|
|
memmove(VgaModeList, ModesVGA, sizeof(VIDEOMODE) * NumVideoModes);
|
|
|
|
//
|
|
// Now populate the rest of the table based on the VESA mode
|
|
// table.
|
|
//
|
|
|
|
VideoModePtr = VgaModeList + NumVideoModes;
|
|
ModePtr = ModeTable;
|
|
|
|
while (NumVesaModes--) {
|
|
|
|
ModeValid = FALSE;
|
|
|
|
//
|
|
// Get info about the VESA mode.
|
|
//
|
|
|
|
BiosArguments.Eax = 0x4f01;
|
|
BiosArguments.Ecx = *ModePtr;
|
|
BiosArguments.Edi = VdmOff;
|
|
BiosArguments.SegEs = VdmSeg;
|
|
|
|
pInt10->Int10CallBios(pInt10->Context, &BiosArguments);
|
|
|
|
if ((BiosArguments.Eax & 0xffff) == VESA_STATUS_SUCCESS) {
|
|
|
|
//
|
|
// Copy the mode information out of the csrss process
|
|
//
|
|
|
|
pInt10->Int10ReadMemory(pInt10->Context,
|
|
VdmSeg,
|
|
VdmOff,
|
|
ModeBlock,
|
|
sizeof(MODE_INFO_BLOCK));
|
|
|
|
//
|
|
// Make sure that this is a graphics mode, and
|
|
// that it is supported by this hardware.
|
|
//
|
|
|
|
if ((ModeBlock->ModeAttributes & 0x11) == 0x11) {
|
|
|
|
if ((VbeVersion >= 0x200) &&
|
|
(ModeBlock->PhysBasePtr) &&
|
|
(ModeBlock->ModeAttributes & 0x80)) {
|
|
|
|
LinearModeSupported = TRUE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Make sure banked modes are supported
|
|
//
|
|
|
|
ASSERT((ModeBlock->ModeAttributes & 0x40) == 0);
|
|
LinearModeSupported = FALSE;
|
|
}
|
|
|
|
//
|
|
// Only include this mode if the following are true:
|
|
//
|
|
// 1. The mode is an 8bpp or higher mode
|
|
// 2. The resolution is 640x480 or greater
|
|
//
|
|
|
|
if ((ModeBlock->XResolution >= 640) &&
|
|
(ModeBlock->YResolution >= 480) &&
|
|
(ModeBlock->NumberOfPlanes != 0) &&
|
|
(ModeBlock->BitsPerPixel >= 8)) {
|
|
|
|
//
|
|
// Fill in the video mode structure.
|
|
//
|
|
|
|
memset(VideoModePtr, 0, sizeof(VIDEOMODE));
|
|
|
|
if (ModeBlock->ModeAttributes & 0x08) {
|
|
VideoModePtr->fbType |= VIDEO_MODE_COLOR;
|
|
}
|
|
|
|
if (ModeBlock->ModeAttributes & 0x10) {
|
|
VideoModePtr->fbType |= VIDEO_MODE_GRAPHICS;
|
|
}
|
|
|
|
VideoModePtr->numPlanes = ModeBlock->NumberOfPlanes;
|
|
VideoModePtr->bitsPerPlane = ModeBlock->BitsPerPixel /
|
|
ModeBlock->NumberOfPlanes;
|
|
|
|
if (VideoModePtr->bitsPerPlane == 16) {
|
|
|
|
//
|
|
// Check to see if this is really a 15 bpp mode
|
|
//
|
|
|
|
if (ModeBlock->GreenMaskSize == 5) {
|
|
VideoModePtr->bitsPerPlane = 15;
|
|
}
|
|
}
|
|
|
|
if (ModeBlock->XCharSize) {
|
|
VideoModePtr->col = ModeBlock->XResolution / ModeBlock->XCharSize;
|
|
} else {
|
|
VideoModePtr->col = 80;
|
|
}
|
|
|
|
if (ModeBlock->YCharSize) {
|
|
VideoModePtr->row = ModeBlock->YResolution / ModeBlock->YCharSize;
|
|
} else {
|
|
VideoModePtr->row = 25;
|
|
}
|
|
|
|
VideoModePtr->hres = ModeBlock->XResolution;
|
|
VideoModePtr->vres = ModeBlock->YResolution;
|
|
VideoModePtr->frequency = 1;
|
|
VideoModePtr->Int10ModeNumber = (((ULONG)*ModePtr) << 16) | 0x00004f02;
|
|
VideoModePtr->Granularity = ModeBlock->WinGranularity << 10;
|
|
VideoModePtr->NonVgaHardware = (ModeBlock->ModeAttributes & 0x20) ? TRUE : FALSE;
|
|
|
|
if (LinearModeSupported) {
|
|
|
|
if (VbeVersion >= 0x300) {
|
|
VideoModePtr->wbytes = ModeBlock->LinBytesPerScanLine;
|
|
} else {
|
|
VideoModePtr->wbytes = ModeBlock->BytesPerScanLine;
|
|
}
|
|
|
|
//
|
|
// We first try to round up VideoMemoryRequired
|
|
// to power of 2 so that we'll have a better
|
|
// chance to get it mapped as write combined
|
|
// on systems where MTRR is the only mechanism
|
|
// for such mappings. If the rounded up value
|
|
// is larger than the size of on-board memory
|
|
// we'll at least round it up to page boundary
|
|
//
|
|
|
|
VideoMemoryRequired = RaiseToPower2Ulong(VideoModePtr->wbytes * VideoModePtr->vres);
|
|
|
|
if(VideoMemoryRequired > (ULONG)TotalMemory) {
|
|
VideoMemoryRequired =
|
|
(VideoModePtr->wbytes * VideoModePtr->vres + 0x1000 - 1) & ~(0x1000 - 1);
|
|
}
|
|
|
|
VideoModePtr->sbytes = VideoMemoryRequired;
|
|
VideoModePtr->PixelsPerScan = VideoModePtr->hres;
|
|
VideoModePtr->banktype = NoBanking;
|
|
|
|
VideoModePtr->Int10ModeNumber |= 0x40000000;
|
|
|
|
VideoModePtr->MemoryBase = ModeBlock->PhysBasePtr;
|
|
VideoModePtr->MemoryLength = VideoMemoryRequired;
|
|
VideoModePtr->FrameOffset = 0;
|
|
VideoModePtr->FrameLength = VideoMemoryRequired;
|
|
VideoModePtr->fbType |= VIDEO_MODE_LINEAR;
|
|
|
|
} else {
|
|
|
|
VideoModePtr->wbytes = RaiseToPower2(ModeBlock->BytesPerScanLine);
|
|
|
|
//
|
|
// Round up to bank boundary if possible.
|
|
//
|
|
|
|
VideoMemoryRequired =
|
|
(VideoModePtr->wbytes * VideoModePtr->vres + 0x10000 - 1) & ~(0x10000 - 1);
|
|
|
|
if(VideoMemoryRequired > (ULONG)TotalMemory) {
|
|
|
|
//
|
|
// Round up to page boundary.
|
|
//
|
|
|
|
VideoMemoryRequired =
|
|
(VideoModePtr->wbytes * VideoModePtr->vres + 0x1000 - 1) & ~(0x1000 - 1);
|
|
}
|
|
|
|
VideoModePtr->sbytes = VideoMemoryRequired;
|
|
VideoModePtr->PixelsPerScan = RaiseToPower2(VideoModePtr->hres);
|
|
VideoModePtr->banktype = VideoBanked1RW;
|
|
VideoModePtr->MemoryBase = 0xa0000;
|
|
VideoModePtr->MemoryLength = 0x10000;
|
|
VideoModePtr->FrameOffset = 0;
|
|
VideoModePtr->FrameLength = 0x10000;
|
|
VideoModePtr->fbType |= VIDEO_MODE_BANKED;
|
|
}
|
|
|
|
if (ModeBlock->ModeAttributes & 0x40) {
|
|
VideoModePtr->banktype = NormalBanking;
|
|
}
|
|
|
|
//
|
|
// Make sure there is enough memory for the mode
|
|
//
|
|
|
|
if ((VideoModePtr->wbytes * VideoModePtr->vres) <= TotalMemory) {
|
|
ModeValid = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ModeValid) {
|
|
|
|
VideoDebugPrint((1, "Supported: %dx%dx%dbpp\n",
|
|
VideoModePtr->hres,
|
|
VideoModePtr->vres,
|
|
VideoModePtr->bitsPerPlane));
|
|
|
|
VideoModePtr++;
|
|
AdditionalModes++;
|
|
|
|
} else {
|
|
|
|
VideoDebugPrint((1, "Rejecting: %dx%dx%dbpp\n",
|
|
ModeBlock->XResolution,
|
|
ModeBlock->YResolution,
|
|
ModeBlock->BitsPerPixel));
|
|
}
|
|
|
|
ModePtr++;
|
|
}
|
|
|
|
//
|
|
// Lets check to see if we can map the memory for one of these modes.
|
|
// If not, don't support the extended modes.
|
|
//
|
|
// Note: this is a temporary hack, until I can implent the correct
|
|
// fix.
|
|
//
|
|
|
|
VideoModePtr--;
|
|
|
|
if (IS_LINEAR_MODE(VideoModePtr)) {
|
|
|
|
PHYSICAL_ADDRESS Address;
|
|
UCHAR inIoSpace = 0;
|
|
|
|
Address.LowPart = VideoModePtr->MemoryBase;
|
|
Address.HighPart = 0;
|
|
|
|
#if defined(PLUG_AND_PLAY)
|
|
inIoSpace |= VIDEO_MEMORY_SPACE_P6CACHE;
|
|
#endif
|
|
Memory = VideoPortGetDeviceBase(hwDeviceExtension,
|
|
Address,
|
|
0x1000,
|
|
inIoSpace);
|
|
|
|
if (Memory) {
|
|
|
|
VideoPortFreeDeviceBase(hwDeviceExtension, Memory);
|
|
|
|
} else {
|
|
|
|
//
|
|
// We can't map the memory, so don't expose the extra modes.
|
|
//
|
|
|
|
VideoDebugPrint((0, "vga.sys: Mapping 0x%x failed\n", VideoModePtr->MemoryBase));
|
|
AdditionalModes = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
VideoPortFreePool(hwDeviceExtension, InfoBlock);
|
|
}
|
|
}
|
|
|
|
NumVideoModes += AdditionalModes;
|
|
|
|
} // VgaInitialize()
|
|
|
|
ULONG
|
|
GetVideoMemoryBaseAddress(
|
|
PHW_DEVICE_EXTENSION hwDeviceExtension,
|
|
PVIDEOMODE pRequestedMode
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine get the base address of the framebuffer of a given mode
|
|
|
|
Return Value:
|
|
|
|
Base address of framebuffer
|
|
|
|
--*/
|
|
|
|
{
|
|
PMODE_INFO_BLOCK ModeBlock;
|
|
ULONG Length = 0x1000;
|
|
INT10_BIOS_ARGUMENTS BiosArguments;
|
|
PVIDEO_PORT_INT10_INTERFACE pInt10;
|
|
ULONG RetValue;
|
|
|
|
//
|
|
// If this is not a vesa mode, just return the saved base address
|
|
//
|
|
|
|
if (pRequestedMode->fbType & VIDEO_MODE_BANKED) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
pInt10 = &hwDeviceExtension->Int10;
|
|
|
|
if(!(pInt10->Size))
|
|
{
|
|
|
|
//
|
|
// This structure should be initialized in VgaInitialize
|
|
// If this function get called before VgaInitialize, just return 0;
|
|
//
|
|
|
|
return 0;
|
|
}
|
|
|
|
ModeBlock = VideoPortAllocatePool(hwDeviceExtension,
|
|
VpPagedPool,
|
|
sizeof(MODE_INFO_BLOCK),
|
|
' agV');
|
|
|
|
if(!ModeBlock) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Get info about the VESA mode.
|
|
//
|
|
|
|
BiosArguments.Eax = 0x4f01;
|
|
BiosArguments.Ecx = pRequestedMode->Int10ModeNumber >> 16;
|
|
BiosArguments.Edi = hwDeviceExtension->VdmOff;
|
|
BiosArguments.SegEs = hwDeviceExtension->VdmSeg;
|
|
|
|
pInt10->Int10CallBios(pInt10->Context, &BiosArguments);
|
|
|
|
if ((BiosArguments.Eax & 0xffff) == VESA_STATUS_SUCCESS) {
|
|
|
|
//
|
|
// Copy the mode information out of the csrss process
|
|
//
|
|
|
|
pInt10->Int10ReadMemory(pInt10->Context,
|
|
hwDeviceExtension->VdmSeg,
|
|
hwDeviceExtension->VdmOff,
|
|
ModeBlock,
|
|
sizeof(MODE_INFO_BLOCK));
|
|
|
|
RetValue = ModeBlock->PhysBasePtr;
|
|
|
|
} else {
|
|
|
|
RetValue = 0;
|
|
}
|
|
|
|
VideoPortFreePool(hwDeviceExtension, ModeBlock);
|
|
return( RetValue );
|
|
|
|
}
|
|
|
|
VP_STATUS
|
|
VBEGetModeInfo(
|
|
PHW_DEVICE_EXTENSION hwDeviceExtension,
|
|
USHORT ModeNumber,
|
|
PMODE_INFO_BLOCK ModeInfoBlock
|
|
)
|
|
{
|
|
INT10_BIOS_ARGUMENTS Int10BiosArguments;
|
|
PVIDEO_PORT_INT10_INTERFACE pInt10;
|
|
VP_STATUS status;
|
|
|
|
pInt10 = &hwDeviceExtension->Int10;
|
|
|
|
Int10BiosArguments.Eax = VBE_GET_MODE_INFO;
|
|
Int10BiosArguments.Ecx = ModeNumber;
|
|
Int10BiosArguments.Edi = hwDeviceExtension->VdmOff;
|
|
Int10BiosArguments.SegEs = hwDeviceExtension->VdmSeg;
|
|
|
|
status = pInt10->Int10CallBios(pInt10->Context, &Int10BiosArguments);
|
|
|
|
if (status == NO_ERROR &&
|
|
(Int10BiosArguments.Eax & 0xffff) == VESA_STATUS_SUCCESS) {
|
|
|
|
//
|
|
// Copy the mode information out of the csrss process
|
|
//
|
|
|
|
status = pInt10->Int10ReadMemory(pInt10->Context,
|
|
hwDeviceExtension->VdmSeg,
|
|
hwDeviceExtension->VdmOff,
|
|
ModeInfoBlock,
|
|
sizeof(MODE_INFO_BLOCK));
|
|
|
|
if (status == NO_ERROR) {
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
VP_STATUS
|
|
VBESetMode(
|
|
PHW_DEVICE_EXTENSION HwDeviceExtension,
|
|
USHORT VesaModeNumber
|
|
)
|
|
{
|
|
VIDEO_X86_BIOS_ARGUMENTS biosArguments;
|
|
VP_STATUS status;
|
|
|
|
biosArguments.Eax = VBE_SET_MODE;
|
|
biosArguments.Ebx = VesaModeNumber;
|
|
|
|
status = VideoPortInt10(HwDeviceExtension, &biosArguments);
|
|
|
|
if ((status == NO_ERROR) &&
|
|
((biosArguments.Eax & 0x0000FFFF) == VESA_STATUS_SUCCESS)) {
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
USHORT
|
|
VBEGetMode(
|
|
PHW_DEVICE_EXTENSION HwDeviceExtension
|
|
)
|
|
{
|
|
VIDEO_X86_BIOS_ARGUMENTS biosArguments;
|
|
VP_STATUS status;
|
|
|
|
biosArguments.Eax = VBE_GET_MODE;
|
|
|
|
status = VideoPortInt10(HwDeviceExtension, &biosArguments);
|
|
|
|
if ((status == NO_ERROR) &&
|
|
((biosArguments.Eax & 0x0000FFFF) == VESA_STATUS_SUCCESS)) {
|
|
|
|
return (USHORT)(biosArguments.Ebx & 0x0000FFFF) ;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
ULONG
|
|
VBESaveState(
|
|
PHW_DEVICE_EXTENSION hwDeviceExtension,
|
|
PCHAR StateBuffer
|
|
)
|
|
{
|
|
INT10_BIOS_ARGUMENTS Int10BiosArguments;
|
|
PVIDEO_PORT_INT10_INTERFACE pInt10;
|
|
VP_STATUS status;
|
|
ULONG Size;
|
|
|
|
pInt10 = &hwDeviceExtension->Int10;
|
|
|
|
Int10BiosArguments.Eax = VBE_SAVE_RESTORE_STATE;
|
|
Int10BiosArguments.Edx = 0x0;
|
|
|
|
//
|
|
// Save all the state
|
|
//
|
|
|
|
Int10BiosArguments.Ecx = 0x0F;
|
|
|
|
status = pInt10->Int10CallBios(pInt10->Context, &Int10BiosArguments);
|
|
|
|
if (status != NO_ERROR ||
|
|
(Int10BiosArguments.Eax & 0xffff) != VESA_STATUS_SUCCESS) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
Size = (Int10BiosArguments.Ebx & 0xffff) << 6 ;
|
|
|
|
//
|
|
// if StateBuffer is NULL, the caller is only want to know the size
|
|
// of the buffer needed to store the state
|
|
//
|
|
|
|
if (StateBuffer == NULL) {
|
|
return Size;
|
|
}
|
|
|
|
Int10BiosArguments.Eax = VBE_SAVE_RESTORE_STATE;
|
|
Int10BiosArguments.Edx = 0x1;
|
|
Int10BiosArguments.Ecx = 0x0F;
|
|
Int10BiosArguments.Ebx = hwDeviceExtension->VdmOff;
|
|
Int10BiosArguments.SegEs = hwDeviceExtension->VdmSeg;
|
|
|
|
status = pInt10->Int10CallBios(pInt10->Context, &Int10BiosArguments);
|
|
|
|
if (status == NO_ERROR &&
|
|
(Int10BiosArguments.Eax & 0xffff) == VESA_STATUS_SUCCESS) {
|
|
|
|
//
|
|
// Copy the state data of the csrss process
|
|
//
|
|
|
|
status = pInt10->Int10ReadMemory(pInt10->Context,
|
|
hwDeviceExtension->VdmSeg,
|
|
hwDeviceExtension->VdmOff,
|
|
StateBuffer,
|
|
Size);
|
|
if (status == NO_ERROR) {
|
|
|
|
return Size;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
VP_STATUS
|
|
VBERestoreState(
|
|
PHW_DEVICE_EXTENSION hwDeviceExtension,
|
|
PCHAR StateBuffer,
|
|
ULONG Size
|
|
)
|
|
{
|
|
INT10_BIOS_ARGUMENTS Int10BiosArguments;
|
|
PVIDEO_PORT_INT10_INTERFACE pInt10;
|
|
VP_STATUS status;
|
|
|
|
pInt10 = &hwDeviceExtension->Int10;
|
|
|
|
//
|
|
// Copy the state data to the csrss process
|
|
//
|
|
|
|
status = pInt10->Int10WriteMemory(pInt10->Context,
|
|
hwDeviceExtension->VdmSeg,
|
|
hwDeviceExtension->VdmOff,
|
|
StateBuffer,
|
|
Size);
|
|
|
|
if (status != NO_ERROR) {
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
Int10BiosArguments.Eax = VBE_SAVE_RESTORE_STATE;
|
|
Int10BiosArguments.Edx = 0x2;
|
|
Int10BiosArguments.Ecx = 0x0f;
|
|
Int10BiosArguments.Ebx = hwDeviceExtension->VdmOff;
|
|
Int10BiosArguments.SegEs = hwDeviceExtension->VdmSeg;
|
|
|
|
status = pInt10->Int10CallBios(pInt10->Context, &Int10BiosArguments);
|
|
|
|
if (status != NO_ERROR ||
|
|
(Int10BiosArguments.Eax & 0xffff) != VESA_STATUS_SUCCESS) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
VP_STATUS
|
|
VBESetDisplayWindow(
|
|
PHW_DEVICE_EXTENSION hwDeviceExtension,
|
|
UCHAR WindowSelect,
|
|
USHORT WindowNumber
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine set the position of the specified window in the
|
|
frame buffer memory
|
|
|
|
Arguments:
|
|
|
|
HwDeviceExtension
|
|
Pointer to the miniport driver's adapter information.
|
|
|
|
WindowSelect
|
|
0 for Window A and 1 for Window B
|
|
|
|
WindowNumber
|
|
Window number in video memory in window granularity units
|
|
|
|
Return Value:
|
|
|
|
VP_STATUS
|
|
|
|
--*/
|
|
|
|
{
|
|
VIDEO_X86_BIOS_ARGUMENTS biosArguments;
|
|
VP_STATUS status;
|
|
|
|
biosArguments.Eax = VBE_WINDOW_CONTROL;
|
|
biosArguments.Ebx = WindowSelect & 0x01;
|
|
biosArguments.Edx = WindowNumber;
|
|
|
|
status = VideoPortInt10(hwDeviceExtension, &biosArguments);
|
|
|
|
if ((status != NO_ERROR) ||
|
|
((biosArguments.Eax & 0x0000FFFF) != VESA_STATUS_SUCCESS)) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
USHORT
|
|
VBEGetDisplayWindow(
|
|
PHW_DEVICE_EXTENSION hwDeviceExtension,
|
|
UCHAR WindowSelect
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine set the position of the specified window in the
|
|
frame buffer memory
|
|
|
|
Arguments:
|
|
|
|
HwDeviceExtension
|
|
Pointer to the miniport driver's adapter information.
|
|
|
|
WindowSelect
|
|
0 for Window A and 1 for Window B
|
|
|
|
Return Value:
|
|
|
|
Window number in video memory in window granularity units
|
|
|
|
--*/
|
|
|
|
{
|
|
VIDEO_X86_BIOS_ARGUMENTS biosArguments;
|
|
VP_STATUS status;
|
|
|
|
biosArguments.Eax = VBE_WINDOW_CONTROL;
|
|
biosArguments.Ebx = (WindowSelect & 0x1) | 0x100;
|
|
|
|
status = VideoPortInt10(hwDeviceExtension, &biosArguments);
|
|
|
|
if ((status != NO_ERROR) ||
|
|
((biosArguments.Eax & 0x0000FFFF) != VESA_STATUS_SUCCESS)) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
return ((USHORT)(biosArguments.Edx & 0xFFFF));
|
|
}
|
|
|
|
USHORT
|
|
VBEGetScanLineLength(
|
|
PHW_DEVICE_EXTENSION HwDeviceExtension
|
|
)
|
|
{
|
|
VIDEO_X86_BIOS_ARGUMENTS biosArguments;
|
|
VP_STATUS status;
|
|
|
|
biosArguments.Eax = VBE_SCANLINE;
|
|
biosArguments.Ebx = 0x1;
|
|
|
|
status = VideoPortInt10(HwDeviceExtension, &biosArguments);
|
|
|
|
if ((status == NO_ERROR) &&
|
|
((biosArguments.Eax & 0x0000FFFF) == VESA_STATUS_SUCCESS)) {
|
|
|
|
return (USHORT)(biosArguments.Ebx & 0x0000FFFF) ;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
VP_STATUS
|
|
VesaSaveHardwareState(
|
|
PHW_DEVICE_EXTENSION HwDeviceExtension,
|
|
PVIDEO_HARDWARE_STATE HardwareState,
|
|
ULONG HardwareStateSize,
|
|
USHORT ModeNumber
|
|
)
|
|
{
|
|
PVIDEO_HARDWARE_STATE_HEADER hardwareStateHeader;
|
|
VP_STATUS status;
|
|
ULONG FrameBufferSize;
|
|
PMODE_INFO_BLOCK ModeInfoBlock;
|
|
PVESA_INFO pVesaInfo;
|
|
|
|
hardwareStateHeader =
|
|
(PVIDEO_HARDWARE_STATE_HEADER) HardwareState->StateHeader;
|
|
|
|
//
|
|
// Zero out the structure
|
|
//
|
|
|
|
VideoPortZeroMemory((PVOID) hardwareStateHeader,
|
|
sizeof(VIDEO_HARDWARE_STATE_HEADER));
|
|
|
|
//
|
|
// Set the Header field
|
|
//
|
|
|
|
hardwareStateHeader->Length = sizeof(VIDEO_HARDWARE_STATE_HEADER);
|
|
hardwareStateHeader->VGAStateFlags |= VIDEO_STATE_UNEMULATED_VGA_STATE;
|
|
|
|
hardwareStateHeader->VesaInfoOffset =
|
|
(sizeof(VIDEO_HARDWARE_STATE_HEADER) + 7) & ~7;
|
|
|
|
pVesaInfo = (PVESA_INFO)((PCHAR)hardwareStateHeader +
|
|
hardwareStateHeader->VesaInfoOffset);
|
|
|
|
//
|
|
// Check the size needed to store hardware state
|
|
//
|
|
|
|
if (!(pVesaInfo->HardwareStateSize =
|
|
VBESaveState(HwDeviceExtension, NULL))) {
|
|
|
|
return ERROR_INVALID_FUNCTION;
|
|
}
|
|
|
|
//
|
|
// In the case the size needed is too big just retrun failure
|
|
// This should not happen in reality
|
|
//
|
|
|
|
if( VGA_TOTAL_STATE_SIZE < hardwareStateHeader->VesaInfoOffset +
|
|
sizeof(VESA_INFO) +
|
|
pVesaInfo->HardwareStateSize) {
|
|
|
|
return ERROR_INVALID_FUNCTION;
|
|
}
|
|
|
|
//
|
|
// Save hardware state
|
|
//
|
|
|
|
if (pVesaInfo->HardwareStateSize !=
|
|
VBESaveState(HwDeviceExtension, pVesaInfo->HardwareState)) {
|
|
|
|
return ERROR_INVALID_FUNCTION;
|
|
}
|
|
|
|
pVesaInfo->ModeNumber = ModeNumber;
|
|
|
|
ModeInfoBlock = &(pVesaInfo->ModeInfoBlock);
|
|
|
|
//
|
|
// Retrieve mode info
|
|
//
|
|
|
|
if( VBEGetModeInfo(HwDeviceExtension,
|
|
ModeNumber,
|
|
ModeInfoBlock) != NO_ERROR) {
|
|
|
|
return ERROR_INVALID_FUNCTION;
|
|
}
|
|
|
|
//
|
|
// Save framebuffer
|
|
//
|
|
|
|
hardwareStateHeader->FrameBufferData =
|
|
SaveFrameBuffer(HwDeviceExtension, pVesaInfo);
|
|
|
|
if(hardwareStateHeader->FrameBufferData) {
|
|
|
|
return NO_ERROR;
|
|
|
|
} else {
|
|
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|
|
|
|
PCHAR
|
|
SaveFrameBuffer(
|
|
PHW_DEVICE_EXTENSION hwDeviceExtension,
|
|
PVESA_INFO pVesaInfo
|
|
)
|
|
{
|
|
ULONG FrameBufferSize, BankSize, CopySize, LeftSize, k;
|
|
USHORT i;
|
|
PCHAR FrameBufferData, pFrameBuffer;
|
|
PHYSICAL_ADDRESS FBPhysicalAddress;
|
|
PMODE_INFO_BLOCK ModeInfoBlock;
|
|
|
|
ModeInfoBlock = (PMODE_INFO_BLOCK) &(pVesaInfo->ModeInfoBlock);
|
|
|
|
//
|
|
// We'll try to get the current value of scanline size just in case a DOS
|
|
// app changed it. But we stay on the value we have if the vesa function
|
|
// is not supported or failed.
|
|
//
|
|
|
|
i = VBEGetScanLineLength(hwDeviceExtension);
|
|
|
|
if(i) {
|
|
|
|
ModeInfoBlock->BytesPerScanLine = i;
|
|
}
|
|
|
|
//
|
|
// 1) Calculate Framebuffer size
|
|
//
|
|
|
|
//
|
|
// Check if it is graphics or text mode. For text mode we simply
|
|
// assume a size of 32k
|
|
//
|
|
|
|
if (ModeInfoBlock->ModeAttributes & 0x10) {
|
|
|
|
FrameBufferSize = ModeInfoBlock->BytesPerScanLine *
|
|
ModeInfoBlock->YResolution;
|
|
|
|
} else {
|
|
|
|
FrameBufferSize = 0x8000;
|
|
}
|
|
|
|
pVesaInfo->FrameBufferSize = FrameBufferSize;
|
|
|
|
//
|
|
// 2) Determine the location and the size to be mapped and map it
|
|
//
|
|
|
|
if (!(ModeInfoBlock->ModeAttributes & 0x10)) {
|
|
|
|
//
|
|
// This is a text mode
|
|
//
|
|
|
|
FBPhysicalAddress.HighPart = 0;
|
|
FBPhysicalAddress.LowPart = ModeInfoBlock->WinASegment << 4;
|
|
|
|
if( FBPhysicalAddress.LowPart == 0) {
|
|
|
|
FBPhysicalAddress.LowPart = 0xB8000;
|
|
}
|
|
|
|
BankSize = 0x8000;
|
|
|
|
} else if (pVesaInfo->ModeNumber & 0x4000) {
|
|
|
|
//
|
|
// Linear framebuffer can be viewed as one large bank
|
|
//
|
|
|
|
FBPhysicalAddress.LowPart = ModeInfoBlock->PhysBasePtr;
|
|
FBPhysicalAddress.HighPart = 0;
|
|
BankSize = FrameBufferSize;
|
|
|
|
} else {
|
|
|
|
//
|
|
// This is a banked mode
|
|
//
|
|
|
|
FBPhysicalAddress.HighPart = 0;
|
|
FBPhysicalAddress.LowPart = ModeInfoBlock->WinASegment << 4;
|
|
|
|
if( FBPhysicalAddress.LowPart == 0) {
|
|
|
|
FBPhysicalAddress.LowPart = 0xA0000;
|
|
}
|
|
|
|
BankSize = 1024 * ModeInfoBlock->WinSize;
|
|
|
|
//
|
|
// The bank size shouldn't exceed 64k. But we'd better guard
|
|
// the bad BIOS
|
|
//
|
|
|
|
if(BankSize > 0x10000 || BankSize == 0) {
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// k will be used later to translate the window number
|
|
// in the unit of WinSize to the window number in the
|
|
// unit of WinGranularity
|
|
//
|
|
|
|
if (ModeInfoBlock->WinGranularity) {
|
|
|
|
k = ModeInfoBlock->WinSize/ModeInfoBlock->WinGranularity;
|
|
|
|
} else {
|
|
|
|
k = 1;
|
|
}
|
|
}
|
|
|
|
if(( pFrameBuffer = VideoPortGetDeviceBase(hwDeviceExtension,
|
|
FBPhysicalAddress,
|
|
BankSize,
|
|
FALSE)) == NULL ) {
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// 3) Allocate memory for framebuffer data
|
|
//
|
|
|
|
if((FrameBufferData = VideoPortAllocatePool(hwDeviceExtension,
|
|
VpPagedPool,
|
|
FrameBufferSize,
|
|
' agV')) == NULL) {
|
|
|
|
VideoPortFreeDeviceBase(hwDeviceExtension, pFrameBuffer);
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// 4) Save famebuffer data
|
|
//
|
|
|
|
LeftSize = FrameBufferSize;
|
|
|
|
for ( i = 0; LeftSize > 0; i++ ) {
|
|
|
|
if (!(pVesaInfo->ModeNumber & 0x4000)) {
|
|
|
|
//
|
|
// If this is a banked mode, switch to the right bank.
|
|
// We set both Window A and B, as some VBEs have these
|
|
// set as separately available read and write windows.
|
|
//
|
|
|
|
VBESetDisplayWindow(hwDeviceExtension, 0, i * (USHORT)k);
|
|
VBESetDisplayWindow(hwDeviceExtension, 1, i * (USHORT)k);
|
|
}
|
|
|
|
CopySize = (LeftSize < BankSize) ? LeftSize : BankSize;
|
|
|
|
VideoPortMoveMemory(FrameBufferData + i * BankSize,
|
|
pFrameBuffer,
|
|
CopySize);
|
|
|
|
LeftSize -= CopySize;
|
|
}
|
|
|
|
//
|
|
// 5) Relese resource
|
|
//
|
|
|
|
VideoPortFreeDeviceBase(hwDeviceExtension, pFrameBuffer);
|
|
|
|
return FrameBufferData;
|
|
}
|
|
|
|
BOOLEAN
|
|
IsSavedModeVesa(
|
|
PVIDEO_HARDWARE_STATE HardwareState
|
|
)
|
|
{
|
|
PVIDEO_HARDWARE_STATE_HEADER hardwareStateHeader;
|
|
|
|
hardwareStateHeader =
|
|
(PVIDEO_HARDWARE_STATE_HEADER) HardwareState->StateHeader;
|
|
|
|
if (hardwareStateHeader->Length == sizeof(VIDEO_HARDWARE_STATE_HEADER) &&
|
|
hardwareStateHeader->VesaInfoOffset ) {
|
|
|
|
return TRUE;
|
|
|
|
} else {
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
VP_STATUS
|
|
VesaRestoreHardwareState(
|
|
PHW_DEVICE_EXTENSION HwDeviceExtension,
|
|
PVIDEO_HARDWARE_STATE HardwareState,
|
|
ULONG HardwareStateSize
|
|
)
|
|
{
|
|
|
|
VIDEO_X86_BIOS_ARGUMENTS biosArguments;
|
|
PVIDEO_HARDWARE_STATE_HEADER hardwareStateHeader;
|
|
PMODE_INFO_BLOCK ModeInfoBlock;
|
|
PVESA_INFO pVesaInfo;
|
|
VP_STATUS status;
|
|
|
|
hardwareStateHeader =
|
|
(PVIDEO_HARDWARE_STATE_HEADER) HardwareState->StateHeader;
|
|
|
|
pVesaInfo = (PVESA_INFO)((PCHAR)hardwareStateHeader +
|
|
hardwareStateHeader->VesaInfoOffset);
|
|
|
|
//
|
|
//
|
|
// 1) set the original mode
|
|
// 2) restore hardware state
|
|
//
|
|
// Please note that both steps are necessary
|
|
//
|
|
|
|
//
|
|
// We always use default CRTC value
|
|
//
|
|
|
|
VBESetMode (HwDeviceExtension, pVesaInfo->ModeNumber & (~0x800));
|
|
|
|
if ( VBERestoreState(HwDeviceExtension,
|
|
pVesaInfo->HardwareState,
|
|
pVesaInfo->HardwareStateSize) != NO_ERROR ) {
|
|
|
|
return ERROR_INVALID_FUNCTION;
|
|
}
|
|
|
|
ModeInfoBlock = (PMODE_INFO_BLOCK) &(pVesaInfo->ModeInfoBlock);
|
|
|
|
//
|
|
// Restore framebuffer data
|
|
//
|
|
|
|
if(RestoreFrameBuffer(HwDeviceExtension,
|
|
pVesaInfo,
|
|
hardwareStateHeader->FrameBufferData)) {
|
|
|
|
hardwareStateHeader->FrameBufferData = 0;
|
|
return NO_ERROR;
|
|
|
|
} else {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
ULONG
|
|
RestoreFrameBuffer(
|
|
PHW_DEVICE_EXTENSION HwDeviceExtension,
|
|
PVESA_INFO pVesaInfo,
|
|
PCHAR FrameBufferData
|
|
)
|
|
{
|
|
ULONG FrameBufferSize, BankSize, CopySize, LeftSize, k;
|
|
PHYSICAL_ADDRESS FBPhysicalAddress;
|
|
USHORT i, WinA, WinB;
|
|
PCHAR pFrameBuffer;
|
|
PMODE_INFO_BLOCK ModeInfoBlock;
|
|
|
|
if(!FrameBufferData) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
ModeInfoBlock = (PMODE_INFO_BLOCK) &(pVesaInfo->ModeInfoBlock);
|
|
|
|
//
|
|
// 1) Get Framebuffer size
|
|
//
|
|
|
|
FrameBufferSize = pVesaInfo->FrameBufferSize;
|
|
|
|
if (!FrameBufferSize) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// 2) Determine the location and the size to be mapped and map it
|
|
//
|
|
|
|
if (!(ModeInfoBlock->ModeAttributes & 0x10)) {
|
|
|
|
//
|
|
// This is a text mode
|
|
//
|
|
|
|
FBPhysicalAddress.HighPart = 0;
|
|
FBPhysicalAddress.LowPart = ModeInfoBlock->WinASegment << 4;
|
|
|
|
if( FBPhysicalAddress.LowPart == 0) {
|
|
|
|
FBPhysicalAddress.LowPart = 0xB8000;
|
|
}
|
|
|
|
BankSize = 0x8000;
|
|
|
|
} else if (pVesaInfo->ModeNumber & 0x4000) {
|
|
|
|
//
|
|
// Linear framebuffer can be viewed as one large bank
|
|
//
|
|
|
|
FBPhysicalAddress.LowPart = ModeInfoBlock->PhysBasePtr;
|
|
FBPhysicalAddress.HighPart = 0;
|
|
BankSize = FrameBufferSize;
|
|
|
|
} else {
|
|
|
|
//
|
|
// This is a banked mode
|
|
//
|
|
|
|
FBPhysicalAddress.HighPart = 0;
|
|
FBPhysicalAddress.LowPart = ModeInfoBlock->WinASegment << 4;
|
|
|
|
if( FBPhysicalAddress.LowPart == 0) {
|
|
|
|
FBPhysicalAddress.LowPart = 0xA0000;
|
|
}
|
|
|
|
BankSize = 1024 * ModeInfoBlock->WinSize;
|
|
|
|
//
|
|
// The bank size shouldn't exceed 64k. But we'd better guard
|
|
// the bad BIOS
|
|
//
|
|
|
|
if(BankSize > 0x10000 || BankSize == 0) {
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// k will be used later to translate the window number
|
|
// in the unit of WinSize to the window number in the
|
|
// unit of WinGranularity
|
|
//
|
|
|
|
if (ModeInfoBlock->WinGranularity) {
|
|
|
|
k = ModeInfoBlock->WinSize/ModeInfoBlock->WinGranularity;
|
|
|
|
} else {
|
|
|
|
k = 1;
|
|
}
|
|
|
|
}
|
|
|
|
if((pFrameBuffer = VideoPortGetDeviceBase(HwDeviceExtension,
|
|
FBPhysicalAddress,
|
|
FrameBufferSize,
|
|
FALSE)) == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// 3) Restore framebuffer data
|
|
//
|
|
|
|
//
|
|
// For banked mode we need to save the current bank number before
|
|
// we change it.
|
|
//
|
|
|
|
if (!(pVesaInfo->ModeNumber & 0x4000)) {
|
|
|
|
//
|
|
// We need to save the curren window number for banked mode
|
|
//
|
|
|
|
WinA = VBEGetDisplayWindow(HwDeviceExtension, 0);
|
|
WinB = VBEGetDisplayWindow(HwDeviceExtension, 1);
|
|
|
|
}
|
|
|
|
LeftSize = FrameBufferSize;
|
|
|
|
for (i = 0; LeftSize > 0; i++) {
|
|
|
|
if (!(pVesaInfo->ModeNumber & 0x4000)) {
|
|
|
|
//
|
|
// This is a banked mode.
|
|
//
|
|
// We need set both Window A and B, as some VBEs have these
|
|
// set as separately available read and write windows.
|
|
//
|
|
|
|
VBESetDisplayWindow(HwDeviceExtension, 0, i * (USHORT)k);
|
|
VBESetDisplayWindow(HwDeviceExtension, 1, i * (USHORT)k);
|
|
}
|
|
|
|
CopySize = (LeftSize < BankSize) ? LeftSize : BankSize;
|
|
|
|
VideoPortMoveMemory(pFrameBuffer,
|
|
FrameBufferData + i * BankSize,
|
|
CopySize);
|
|
|
|
LeftSize -= CopySize;
|
|
}
|
|
|
|
if (!(pVesaInfo->ModeNumber & 0x4000)) {
|
|
|
|
//
|
|
// For banked mode we need to restore the window number after
|
|
// we changed it.
|
|
//
|
|
|
|
VBESetDisplayWindow(HwDeviceExtension, 0, WinA);
|
|
VBESetDisplayWindow(HwDeviceExtension, 1, WinB);
|
|
}
|
|
|
|
|
|
//
|
|
// 4) Relese resource
|
|
//
|
|
|
|
VideoPortFreeDeviceBase(HwDeviceExtension, pFrameBuffer);
|
|
VideoPortFreePool(HwDeviceExtension, FrameBufferData);
|
|
|
|
return FrameBufferSize;
|
|
}
|