mirror of
https://github.com/reactos/reactos.git
synced 2024-07-07 13:15:07 +00:00
767 lines
26 KiB
C
767 lines
26 KiB
C
/*
|
|
* PROJECT: ReactOS Bochs graphics card driver
|
|
* LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
|
|
* PURPOSE: Bochs graphics card driver
|
|
* COPYRIGHT: Copyright 2022 Hervé Poussineau <hpoussin@reactos.org>
|
|
*/
|
|
|
|
#include "bochsmp.h"
|
|
|
|
static const BOCHS_SIZE BochsAvailableResolutions[] = {
|
|
{ 640, 480 }, // VGA
|
|
{ 800, 600 }, // SVGA
|
|
{ 1024, 600 }, // WSVGA
|
|
{ 1024, 768 }, // XGA
|
|
{ 1152, 864 }, // XGA+
|
|
{ 1280, 720 }, // WXGA-H
|
|
{ 1280, 768 }, // WXGA
|
|
{ 1280, 960 }, // SXGA-
|
|
{ 1280, 1024 }, // SXGA
|
|
{ 1368, 768 }, // HD ready
|
|
{ 1400, 1050 }, // SXGA+
|
|
{ 1440, 900 }, // WSXGA
|
|
{ 1600, 900 }, // HD+
|
|
{ 1600, 1200 }, // UXGA
|
|
{ 1680, 1050 }, // WSXGA+
|
|
{ 1920, 1080 }, // FHD
|
|
{ 2048, 1536 }, // QXGA
|
|
{ 2560, 1440 }, // WQHD
|
|
{ 2560, 1600 }, // WQXGA
|
|
{ 2560, 2048 }, // QSXGA
|
|
{ 2800, 2100 }, // QSXGA+
|
|
{ 3200, 2400 }, // QUXGA
|
|
{ 3840, 2160 }, // 4K UHD-1
|
|
};
|
|
|
|
CODE_SEG("PAGE")
|
|
static VOID
|
|
BochsFreeResources(
|
|
_Inout_ PBOCHS_DEVICE_EXTENSION DeviceExtension)
|
|
{
|
|
if (DeviceExtension->AvailableModeInfo)
|
|
{
|
|
VideoPortFreePool(DeviceExtension, DeviceExtension->AvailableModeInfo);
|
|
DeviceExtension->AvailableModeInfo = NULL;
|
|
}
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static VOID
|
|
BochsWriteDispI(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_In_ ULONG Index,
|
|
_In_ USHORT Value)
|
|
{
|
|
if (DeviceExtension->IoPorts.RangeInIoSpace)
|
|
{
|
|
VideoPortWritePortUshort((PUSHORT)(DeviceExtension->IoPorts.Mapped - VBE_DISPI_IOPORT_INDEX + VBE_DISPI_IOPORT_INDEX), Index);
|
|
VideoPortWritePortUshort((PUSHORT)(DeviceExtension->IoPorts.Mapped - VBE_DISPI_IOPORT_INDEX + VBE_DISPI_IOPORT_DATA), Value);
|
|
}
|
|
else
|
|
{
|
|
VideoPortWriteRegisterUshort((PUSHORT)(DeviceExtension->IoPorts.Mapped + 0x500 + Index * 2), Value);
|
|
}
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static USHORT
|
|
BochsReadDispI(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_In_ ULONG Index)
|
|
{
|
|
if (DeviceExtension->IoPorts.RangeInIoSpace)
|
|
{
|
|
VideoPortWritePortUshort((PUSHORT)(DeviceExtension->IoPorts.Mapped - VBE_DISPI_IOPORT_INDEX + VBE_DISPI_IOPORT_INDEX), Index);
|
|
return VideoPortReadPortUshort((PUSHORT)(DeviceExtension->IoPorts.Mapped - VBE_DISPI_IOPORT_INDEX + VBE_DISPI_IOPORT_DATA));
|
|
}
|
|
else
|
|
{
|
|
return VideoPortReadRegisterUshort((PUSHORT)(DeviceExtension->IoPorts.Mapped + 0x500 + Index * 2));
|
|
}
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN
|
|
BochsWriteDispIAndCheck(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_In_ ULONG Index,
|
|
_In_ USHORT Value)
|
|
{
|
|
BochsWriteDispI(DeviceExtension, Index, Value);
|
|
return BochsReadDispI(DeviceExtension, Index) == Value;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN
|
|
BochsInitializeSuitableModeInfo(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_In_ ULONG PotentialModeCount)
|
|
{
|
|
ULONG i, ModeCount = 0;
|
|
|
|
for (i = 0; i < ARRAYSIZE(BochsAvailableResolutions) && ModeCount < PotentialModeCount; i++)
|
|
{
|
|
if (BochsAvailableResolutions[i].XResolution > DeviceExtension->MaxXResolution)
|
|
continue;
|
|
if (BochsAvailableResolutions[i].YResolution > DeviceExtension->MaxYResolution)
|
|
continue;
|
|
if (BochsAvailableResolutions[i].XResolution * BochsAvailableResolutions[i].YResolution * 4 > DeviceExtension->VramSize64K * 64 * 1024)
|
|
continue;
|
|
DeviceExtension->AvailableModeInfo[ModeCount++] = BochsAvailableResolutions[i];
|
|
}
|
|
|
|
if (ModeCount == 0)
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: no suitable modes available!\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
DeviceExtension->AvailableModeCount = ModeCount;
|
|
return TRUE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN
|
|
BochsGetControllerInfo(
|
|
_Inout_ PBOCHS_DEVICE_EXTENSION DeviceExtension)
|
|
{
|
|
USHORT Version;
|
|
WCHAR ChipType[5];
|
|
ULONG SizeInBytes;
|
|
|
|
/* Detect DISPI version */
|
|
for (Version = VBE_DISPI_ID5; Version >= VBE_DISPI_ID0; Version--)
|
|
{
|
|
if (BochsWriteDispIAndCheck(DeviceExtension, VBE_DISPI_INDEX_ID, Version))
|
|
break;
|
|
}
|
|
if (Version < VBE_DISPI_ID0)
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: VBE extension signature incorrect\n"));
|
|
return FALSE;
|
|
}
|
|
VideoDebugPrint((Error, "Bochs: detected version 0x%04x\n", Version));
|
|
if (Version < VBE_DISPI_ID2)
|
|
{
|
|
/* Too old (no 32 bpp support, no linear frame buffer) */
|
|
VideoDebugPrint((Error, "Bochs: VBE extension too old (0x%04x)\n", Version));
|
|
return FALSE;
|
|
}
|
|
|
|
if (Version <= VBE_DISPI_ID2)
|
|
{
|
|
DeviceExtension->MaxXResolution = 1024;
|
|
DeviceExtension->MaxYResolution = 768;
|
|
}
|
|
else
|
|
{
|
|
BochsWriteDispI(DeviceExtension, VBE_DISPI_INDEX_ENABLE, VBE_DISPI_GETCAPS);
|
|
DeviceExtension->MaxXResolution = BochsReadDispI(DeviceExtension, VBE_DISPI_INDEX_XRES);
|
|
DeviceExtension->MaxYResolution = BochsReadDispI(DeviceExtension, VBE_DISPI_INDEX_YRES);
|
|
BochsWriteDispI(DeviceExtension, VBE_DISPI_INDEX_ENABLE, VBE_DISPI_DISABLED);
|
|
/* Workaround bug in QEMU bochs-display */
|
|
if (DeviceExtension->MaxXResolution == 0 && DeviceExtension->MaxYResolution == 0)
|
|
{
|
|
DeviceExtension->MaxXResolution = 1024;
|
|
DeviceExtension->MaxYResolution = 768;
|
|
}
|
|
}
|
|
if (Version < VBE_DISPI_ID4)
|
|
{
|
|
DeviceExtension->VramSize64K = 4 * 1024 / 64; /* 4 MB */
|
|
}
|
|
else if (Version == VBE_DISPI_ID4)
|
|
{
|
|
DeviceExtension->VramSize64K = 8 * 1024 / 64; /* 8 MB */
|
|
}
|
|
else
|
|
{
|
|
DeviceExtension->VramSize64K = BochsReadDispI(DeviceExtension, VBE_DISPI_INDEX_VIDEO_MEMORY_64K);
|
|
}
|
|
VideoDebugPrint((Info, "Bochs: capabilities %dx%d (%d MB)\n",
|
|
DeviceExtension->MaxXResolution,
|
|
DeviceExtension->MaxYResolution,
|
|
DeviceExtension->VramSize64K * 64 / 1024));
|
|
|
|
/* Store information in registry */
|
|
#define HEX(c) (((c) >= 0 && (c) <= 9) ? (c) + L'0' : (c) - 10 + L'A')
|
|
ChipType[0] = HEX((Version >> 12) & 0xf);
|
|
ChipType[1] = HEX((Version >> 8) & 0xf);
|
|
ChipType[2] = HEX((Version >> 4) & 0xf);
|
|
ChipType[3] = HEX(Version & 0xf);
|
|
ChipType[4] = UNICODE_NULL;
|
|
VideoPortSetRegistryParameters(DeviceExtension, L"HardwareInformation.ChipType", ChipType, sizeof(ChipType));
|
|
SizeInBytes = DeviceExtension->VramSize64K * 64 * 1024;
|
|
VideoPortSetRegistryParameters(DeviceExtension, L"HardwareInformation.MemorySize", &SizeInBytes, sizeof(SizeInBytes));
|
|
return TRUE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static VOID
|
|
BochsGetModeInfo(
|
|
_In_ PBOCHS_SIZE AvailableModeInfo,
|
|
_Out_ PVIDEO_MODE_INFORMATION ModeInfo,
|
|
_In_ ULONG Index)
|
|
{
|
|
VideoDebugPrint((Info, "Bochs: Filling details of mode #%d\n", Index));
|
|
|
|
ModeInfo->Length = sizeof(*ModeInfo);
|
|
ModeInfo->ModeIndex = Index;
|
|
ModeInfo->VisScreenWidth = AvailableModeInfo->XResolution;
|
|
ModeInfo->VisScreenHeight = AvailableModeInfo->YResolution;
|
|
ModeInfo->ScreenStride = AvailableModeInfo->XResolution * 4;
|
|
ModeInfo->NumberOfPlanes = 1;
|
|
ModeInfo->BitsPerPlane = 32;
|
|
ModeInfo->Frequency = 60;
|
|
|
|
/* 960 DPI appears to be common */
|
|
ModeInfo->XMillimeter = AvailableModeInfo->XResolution * 254 / 960;
|
|
ModeInfo->YMillimeter = AvailableModeInfo->YResolution * 254 / 960;
|
|
ModeInfo->NumberRedBits = 8;
|
|
ModeInfo->NumberGreenBits = 8;
|
|
ModeInfo->NumberBlueBits = 8;
|
|
ModeInfo->RedMask = 0xff0000;
|
|
ModeInfo->GreenMask = 0x00ff00;
|
|
ModeInfo->BlueMask = 0x0000ff;
|
|
|
|
ModeInfo->AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
|
|
ModeInfo->VideoMemoryBitmapWidth = AvailableModeInfo->XResolution;
|
|
ModeInfo->VideoMemoryBitmapHeight = AvailableModeInfo->YResolution;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN
|
|
BochsMapVideoMemory(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_In_ PVIDEO_MEMORY RequestedAddress,
|
|
_Out_ PVIDEO_MEMORY_INFORMATION MapInformation,
|
|
_Out_ PSTATUS_BLOCK StatusBlock)
|
|
{
|
|
VP_STATUS Status;
|
|
PHYSICAL_ADDRESS VideoMemory;
|
|
ULONG MemSpace = VIDEO_MEMORY_SPACE_MEMORY;
|
|
|
|
VideoDebugPrint((Info, "Bochs: BochsMapVideoMemory Entry\n"));
|
|
|
|
VideoMemory = DeviceExtension->FrameBuffer.RangeStart;
|
|
MapInformation->VideoRamBase = RequestedAddress->RequestedVirtualAddress;
|
|
MapInformation->VideoRamLength = 4 *
|
|
DeviceExtension->AvailableModeInfo[DeviceExtension->CurrentMode].XResolution *
|
|
DeviceExtension->AvailableModeInfo[DeviceExtension->CurrentMode].YResolution;
|
|
|
|
Status = VideoPortMapMemory(DeviceExtension,
|
|
VideoMemory,
|
|
&MapInformation->VideoRamLength,
|
|
&MemSpace,
|
|
&MapInformation->VideoRamBase);
|
|
if (Status != NO_ERROR)
|
|
{
|
|
VideoDebugPrint((Error, "BochsMapVideoMemory - VideoPortMapMemory failed status:%x\n", Status));
|
|
StatusBlock->Status = Status;
|
|
return FALSE;
|
|
}
|
|
|
|
MapInformation->FrameBufferBase = MapInformation->VideoRamBase;
|
|
MapInformation->FrameBufferLength = MapInformation->VideoRamLength;
|
|
StatusBlock->Information = sizeof(*MapInformation);
|
|
StatusBlock->Status = NO_ERROR;
|
|
|
|
VideoDebugPrint((Info, "Bochs:BochsMapVideoMemory Exit VideoRamBase: %p VideoRamLength: 0x%x PhysBasePtr: 0x%x\n",
|
|
MapInformation->VideoRamBase, MapInformation->VideoRamLength, (ULONG)VideoMemory.QuadPart));
|
|
return TRUE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN NTAPI
|
|
BochsUnmapVideoMemory(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_In_ PVIDEO_MEMORY VideoMemory,
|
|
_Out_ PSTATUS_BLOCK StatusBlock)
|
|
{
|
|
VP_STATUS Status;
|
|
|
|
VideoDebugPrint((Info, "Bochs: BochsUnmapVideoMemory Entry VideoRamBase:%p\n", VideoMemory->RequestedVirtualAddress));
|
|
|
|
Status = VideoPortUnmapMemory(DeviceExtension, VideoMemory->RequestedVirtualAddress, NULL);
|
|
if (Status != NO_ERROR)
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: BochsUnmapVideoMemory Failed to unmap memory:%p Status:%x\n",
|
|
VideoMemory->RequestedVirtualAddress,
|
|
Status));
|
|
}
|
|
|
|
StatusBlock->Status = Status;
|
|
|
|
VideoDebugPrint((Info, "Bochs: BochsUnmapVideoMemory Exit status:%x\n", Status));
|
|
return (Status == NO_ERROR);
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN
|
|
BochsQueryNumAvailableModes(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_Out_ PVIDEO_NUM_MODES AvailableModes,
|
|
_Out_ PSTATUS_BLOCK StatusBlock)
|
|
{
|
|
AvailableModes->NumModes = DeviceExtension->AvailableModeCount;
|
|
AvailableModes->ModeInformationLength = sizeof(VIDEO_MODE_INFORMATION);
|
|
|
|
StatusBlock->Information = sizeof(*AvailableModes);
|
|
StatusBlock->Status = NO_ERROR;
|
|
return TRUE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN
|
|
BochsQueryAvailableModes(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_Out_ PVIDEO_MODE_INFORMATION ReturnedModes,
|
|
_Out_ PSTATUS_BLOCK StatusBlock)
|
|
{
|
|
ULONG Count;
|
|
PBOCHS_SIZE AvailableModeInfo;
|
|
PVIDEO_MODE_INFORMATION ModeInfo;
|
|
|
|
for (Count = 0, AvailableModeInfo = DeviceExtension->AvailableModeInfo, ModeInfo = ReturnedModes;
|
|
Count < DeviceExtension->AvailableModeCount;
|
|
Count++, AvailableModeInfo++, ModeInfo++)
|
|
{
|
|
VideoPortZeroMemory(ModeInfo, sizeof(*ModeInfo));
|
|
BochsGetModeInfo(AvailableModeInfo, ModeInfo, Count);
|
|
}
|
|
|
|
StatusBlock->Information = sizeof(VIDEO_MODE_INFORMATION) * DeviceExtension->AvailableModeCount;
|
|
StatusBlock->Status = NO_ERROR;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN
|
|
BochsSetCurrentMode(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_In_ PVIDEO_MODE RequestedMode,
|
|
_Out_ PSTATUS_BLOCK StatusBlock)
|
|
{
|
|
PBOCHS_SIZE AvailableModeInfo;
|
|
/* Mask the two high-order bits, which can be set to request special behavior */
|
|
ULONG ModeRequested = RequestedMode->RequestedMode & 0x3fffffff;
|
|
BOOLEAN Ret;
|
|
|
|
VideoDebugPrint((Info, "Bochs:BochsSetCurrentMode Entry\n"));
|
|
|
|
if (ModeRequested >= DeviceExtension->AvailableModeCount)
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: set current mode - invalid parameter\n"));
|
|
StatusBlock->Status = ERROR_INVALID_PARAMETER;
|
|
return FALSE;
|
|
}
|
|
|
|
AvailableModeInfo = &DeviceExtension->AvailableModeInfo[ModeRequested];
|
|
|
|
/* Set the mode characteristics */
|
|
BochsWriteDispI(DeviceExtension, VBE_DISPI_INDEX_ENABLE, VBE_DISPI_DISABLED);
|
|
Ret = BochsWriteDispIAndCheck(DeviceExtension, VBE_DISPI_INDEX_XRES, AvailableModeInfo->XResolution) &&
|
|
BochsWriteDispIAndCheck(DeviceExtension, VBE_DISPI_INDEX_YRES, AvailableModeInfo->YResolution) &&
|
|
BochsWriteDispIAndCheck(DeviceExtension, VBE_DISPI_INDEX_BPP, 32);
|
|
/* Always enable screen, even if display settings change failed */
|
|
BochsWriteDispI(DeviceExtension, VBE_DISPI_INDEX_ENABLE, VBE_DISPI_LFB_ENABLED | VBE_DISPI_ENABLED);
|
|
if (!Ret)
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: failed to change mode\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
/* Enable VGA (QEMU secondary-vga disables it by default) */
|
|
if (!DeviceExtension->IoPorts.RangeInIoSpace)
|
|
{
|
|
/* Discard AR flip-flip */
|
|
(VOID)VideoPortReadRegisterUshort((PUSHORT)(DeviceExtension->IoPorts.Mapped + 0x41A));
|
|
/* Enable display */
|
|
VideoPortWriteRegisterUshort((PUSHORT)(DeviceExtension->IoPorts.Mapped + 0x400), 0x20);
|
|
}
|
|
|
|
DeviceExtension->CurrentMode = (USHORT)ModeRequested;
|
|
StatusBlock->Status = NO_ERROR;
|
|
|
|
VideoDebugPrint((Info, "Bochs:BochsSetCurrentMode Exit Mode:%d\n", ModeRequested));
|
|
return TRUE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN
|
|
BochsQueryCurrentMode(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_Out_ PVIDEO_MODE_INFORMATION VideoModeInfo,
|
|
_Out_ PSTATUS_BLOCK StatusBlock)
|
|
{
|
|
PBOCHS_SIZE AvailableModeInfo;
|
|
|
|
if (DeviceExtension->CurrentMode > DeviceExtension->AvailableModeCount)
|
|
{
|
|
StatusBlock->Status = ERROR_INVALID_PARAMETER;
|
|
return FALSE;
|
|
}
|
|
|
|
AvailableModeInfo = &DeviceExtension->AvailableModeInfo[DeviceExtension->CurrentMode];
|
|
VideoPortZeroMemory(VideoModeInfo, sizeof(*VideoModeInfo));
|
|
BochsGetModeInfo(AvailableModeInfo, VideoModeInfo, DeviceExtension->CurrentMode);
|
|
|
|
StatusBlock->Information = sizeof(*VideoModeInfo);
|
|
StatusBlock->Status = NO_ERROR;
|
|
return TRUE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN
|
|
BochsResetDevice(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_Out_ PSTATUS_BLOCK StatusBlock)
|
|
{
|
|
VideoDebugPrint((Info, "Bochs:BochsResetDevice Entry\n"));
|
|
|
|
StatusBlock->Status = NO_ERROR;
|
|
|
|
VideoDebugPrint((Info, "Bochs:BochsResetDevice Exit\n"));
|
|
return TRUE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
static BOOLEAN
|
|
BochsGetChildState(
|
|
_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension,
|
|
_Out_ PULONG pChildState,
|
|
_Out_ PSTATUS_BLOCK StatusBlock)
|
|
{
|
|
*pChildState = VIDEO_CHILD_ACTIVE;
|
|
|
|
StatusBlock->Information = sizeof(*pChildState);
|
|
StatusBlock->Status = NO_ERROR;
|
|
return TRUE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
VP_STATUS NTAPI
|
|
BochsFindAdapter(
|
|
_In_ PVOID HwDeviceExtension,
|
|
_In_ PVOID HwContext,
|
|
_In_ PWSTR ArgumentString,
|
|
_In_ PVIDEO_PORT_CONFIG_INFO ConfigInfo,
|
|
_In_ PUCHAR Again)
|
|
{
|
|
PBOCHS_DEVICE_EXTENSION DeviceExtension = HwDeviceExtension;
|
|
VIDEO_ACCESS_RANGE AccessRanges[2] = {0};
|
|
|
|
if (ConfigInfo->Length < sizeof(*ConfigInfo))
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
if (VideoPortGetAccessRanges(DeviceExtension, 0, NULL, ARRAYSIZE(AccessRanges), AccessRanges, NULL, NULL, NULL) != NO_ERROR)
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: failed to get access ranges\n"));
|
|
return ERROR_DEV_NOT_EXIST;
|
|
}
|
|
|
|
/* Framebuffer */
|
|
DeviceExtension->FrameBuffer.RangeStart = AccessRanges[0].RangeStart;
|
|
DeviceExtension->FrameBuffer.RangeLength = AccessRanges[0].RangeLength;
|
|
DeviceExtension->FrameBuffer.RangeInIoSpace = AccessRanges[0].RangeInIoSpace;
|
|
|
|
/* I/O ports */
|
|
if (AccessRanges[1].RangeLength == 0)
|
|
{
|
|
/* Set default values */
|
|
AccessRanges[1].RangeStart.LowPart = VBE_DISPI_IOPORT_INDEX;
|
|
AccessRanges[1].RangeLength = 2;
|
|
AccessRanges[1].RangeInIoSpace = TRUE;
|
|
if (VideoPortVerifyAccessRanges(DeviceExtension, 1, &AccessRanges[1]) != NO_ERROR)
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: failed to claim I/O range 0x%x-0x%x\n",
|
|
VBE_DISPI_IOPORT_INDEX,
|
|
VBE_DISPI_IOPORT_INDEX + 1));
|
|
return ERROR_DEV_NOT_EXIST;
|
|
}
|
|
}
|
|
else if (AccessRanges[1].RangeLength != 0x1000)
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: invalid access ranges (size 0x%x)\n", AccessRanges[1].RangeLength));
|
|
return ERROR_DEV_NOT_EXIST;
|
|
}
|
|
DeviceExtension->IoPorts.RangeStart = AccessRanges[1].RangeStart;
|
|
DeviceExtension->IoPorts.RangeLength = AccessRanges[1].RangeLength;
|
|
DeviceExtension->IoPorts.RangeInIoSpace = AccessRanges[1].RangeInIoSpace;
|
|
|
|
DeviceExtension->IoPorts.Mapped = VideoPortGetDeviceBase(DeviceExtension,
|
|
DeviceExtension->IoPorts.RangeStart,
|
|
DeviceExtension->IoPorts.RangeLength,
|
|
DeviceExtension->IoPorts.RangeInIoSpace
|
|
? VIDEO_MEMORY_SPACE_IO
|
|
: VIDEO_MEMORY_SPACE_MEMORY);
|
|
if (!DeviceExtension->IoPorts.Mapped)
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: failed to map dispi interface\n"));
|
|
return ERROR_DEV_NOT_EXIST;
|
|
}
|
|
VideoDebugPrint((Info, "Bochs: address 0x%x mapped to 0x%p\n",
|
|
DeviceExtension->IoPorts.RangeStart.LowPart,
|
|
DeviceExtension->IoPorts.Mapped));
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
BOOLEAN NTAPI
|
|
BochsInitialize(
|
|
_In_ PVOID HwDeviceExtension)
|
|
{
|
|
ULONG PotentialModeCount = 0;
|
|
PBOCHS_DEVICE_EXTENSION DeviceExtension = HwDeviceExtension;
|
|
|
|
VideoDebugPrint((Info, "Bochs: BochsInitialize\n"));
|
|
|
|
if (!BochsGetControllerInfo(DeviceExtension))
|
|
{
|
|
BochsFreeResources(DeviceExtension);
|
|
return FALSE;
|
|
}
|
|
|
|
PotentialModeCount = ARRAYSIZE(BochsAvailableResolutions);
|
|
DeviceExtension->AvailableModeInfo = VideoPortAllocatePool(HwDeviceExtension,
|
|
VpPagedPool,
|
|
PotentialModeCount * sizeof(BOCHS_SIZE),
|
|
BOCHS_TAG);
|
|
if (!DeviceExtension->AvailableModeInfo)
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: insufficient resources\n"));
|
|
BochsFreeResources(DeviceExtension);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!BochsInitializeSuitableModeInfo(DeviceExtension, PotentialModeCount))
|
|
{
|
|
BochsFreeResources(DeviceExtension);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
BOOLEAN NTAPI
|
|
BochsStartIO(
|
|
_In_ PVOID HwDeviceExtension,
|
|
_Inout_ PVIDEO_REQUEST_PACKET RequestPacket)
|
|
{
|
|
PBOCHS_DEVICE_EXTENSION DeviceExtension = HwDeviceExtension;
|
|
|
|
VideoDebugPrint((Info, "Bochs: BochsStartIO\n"));
|
|
RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
|
|
|
|
switch (RequestPacket->IoControlCode)
|
|
{
|
|
case IOCTL_VIDEO_MAP_VIDEO_MEMORY:
|
|
{
|
|
VideoDebugPrint((Info, "BochsStartIO - Map video memory\n"));
|
|
if (RequestPacket->InputBufferLength < sizeof(VIDEO_MEMORY))
|
|
{
|
|
VideoDebugPrint((Error, "BochsStartIO - invalid input parameter\n"));
|
|
RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
|
|
return FALSE;
|
|
}
|
|
if (RequestPacket->OutputBufferLength < sizeof(VIDEO_MEMORY_INFORMATION))
|
|
{
|
|
VideoDebugPrint((Error, "BochsStartIO - Insufficent output buffer\n"));
|
|
RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
|
|
return FALSE;
|
|
}
|
|
return BochsMapVideoMemory(DeviceExtension,
|
|
(PVIDEO_MEMORY)RequestPacket->InputBuffer,
|
|
(PVIDEO_MEMORY_INFORMATION)RequestPacket->OutputBuffer,
|
|
RequestPacket->StatusBlock);
|
|
}
|
|
|
|
case IOCTL_VIDEO_UNMAP_VIDEO_MEMORY:
|
|
{
|
|
VideoDebugPrint((Info, "BochsStartIO - Unmap video memory\n"));
|
|
if (RequestPacket->InputBufferLength < sizeof(VIDEO_MEMORY))
|
|
{
|
|
RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
|
|
return FALSE;
|
|
}
|
|
return BochsUnmapVideoMemory(DeviceExtension,
|
|
(PVIDEO_MEMORY)RequestPacket->InputBuffer,
|
|
RequestPacket->StatusBlock);
|
|
}
|
|
|
|
case IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES:
|
|
{
|
|
VideoDebugPrint((Info, "BochsStartIO - Query num available modes\n"));
|
|
if (RequestPacket->OutputBufferLength < sizeof(VIDEO_NUM_MODES))
|
|
{
|
|
RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
|
|
return FALSE;
|
|
}
|
|
return BochsQueryNumAvailableModes(DeviceExtension,
|
|
(PVIDEO_NUM_MODES)RequestPacket->OutputBuffer,
|
|
RequestPacket->StatusBlock);
|
|
}
|
|
|
|
case IOCTL_VIDEO_QUERY_AVAIL_MODES:
|
|
{
|
|
VideoDebugPrint((Info, "BochsStartIO - Query available modes\n"));
|
|
if (RequestPacket->OutputBufferLength < DeviceExtension->AvailableModeCount * sizeof(VIDEO_MODE_INFORMATION))
|
|
{
|
|
RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
|
|
return FALSE;
|
|
}
|
|
return BochsQueryAvailableModes(DeviceExtension,
|
|
(PVIDEO_MODE_INFORMATION)RequestPacket->OutputBuffer,
|
|
RequestPacket->StatusBlock);
|
|
}
|
|
|
|
case IOCTL_VIDEO_SET_CURRENT_MODE:
|
|
{
|
|
VideoDebugPrint((Info, "BochsStartIO - Set current mode\n"));
|
|
if (RequestPacket->InputBufferLength < sizeof(VIDEO_MODE))
|
|
{
|
|
VideoDebugPrint((Error, "Bochs: set current mode - invalid parameter\n"));
|
|
RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
|
|
return FALSE;
|
|
}
|
|
return BochsSetCurrentMode(DeviceExtension,
|
|
(PVIDEO_MODE)RequestPacket->InputBuffer,
|
|
RequestPacket->StatusBlock);
|
|
}
|
|
|
|
case IOCTL_VIDEO_QUERY_CURRENT_MODE:
|
|
{
|
|
VideoDebugPrint((Info, "BochsStartIO - Query current mode\n"));
|
|
if (RequestPacket->OutputBufferLength < sizeof(VIDEO_MODE_INFORMATION))
|
|
{
|
|
RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
|
|
return FALSE;
|
|
}
|
|
return BochsQueryCurrentMode(DeviceExtension,
|
|
(PVIDEO_MODE_INFORMATION)RequestPacket->OutputBuffer,
|
|
RequestPacket->StatusBlock);
|
|
}
|
|
|
|
case IOCTL_VIDEO_RESET_DEVICE:
|
|
{
|
|
VideoDebugPrint((Info, "BochsStartIO - Reset device\n"));
|
|
return BochsResetDevice(DeviceExtension,
|
|
RequestPacket->StatusBlock);
|
|
}
|
|
|
|
case IOCTL_VIDEO_GET_CHILD_STATE:
|
|
{
|
|
VideoDebugPrint((Info, "BochsStartIO - Get child state\n"));
|
|
if (RequestPacket->OutputBufferLength < sizeof(ULONG))
|
|
{
|
|
RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
|
|
return FALSE;
|
|
}
|
|
return BochsGetChildState(DeviceExtension,
|
|
(PULONG)RequestPacket->OutputBuffer,
|
|
RequestPacket->StatusBlock);
|
|
}
|
|
|
|
default:
|
|
{
|
|
VideoDebugPrint((Warn, "BochsStartIO - Unknown IOCTL - 0x%08x\n",
|
|
RequestPacket->IoControlCode));
|
|
break;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
VP_STATUS NTAPI
|
|
BochsSetPowerState(
|
|
_In_ PVOID HwDeviceExtension,
|
|
_In_ ULONG HwId,
|
|
_In_ PVIDEO_POWER_MANAGEMENT VideoPowerControl)
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
VP_STATUS NTAPI
|
|
BochsGetPowerState(
|
|
_In_ PVOID HwDeviceExtension,
|
|
_In_ ULONG HwId,
|
|
_Out_ PVIDEO_POWER_MANAGEMENT VideoPowerControl)
|
|
{
|
|
return ERROR_DEVICE_REINITIALIZATION_NEEDED;
|
|
}
|
|
|
|
CODE_SEG("PAGE")
|
|
VP_STATUS NTAPI
|
|
BochsGetVideoChildDescriptor(
|
|
_In_ PVOID HwDeviceExtension,
|
|
_In_ PVIDEO_CHILD_ENUM_INFO ChildEnumInfo,
|
|
_Out_ PVIDEO_CHILD_TYPE VideoChildType,
|
|
_Out_ PUCHAR pChildDescriptor,
|
|
_Out_ PULONG UId,
|
|
_Out_ PULONG pUnused)
|
|
{
|
|
PBOCHS_DEVICE_EXTENSION DeviceExtension = HwDeviceExtension;
|
|
|
|
VideoDebugPrint((Info, "Bochs: BochsGetVideoChildDescriptor Entry\n"));
|
|
|
|
if (ChildEnumInfo->Size < sizeof(*VideoChildType))
|
|
return VIDEO_ENUM_NO_MORE_DEVICES;
|
|
|
|
if (ChildEnumInfo->ChildIndex == 0)
|
|
{
|
|
/* Ignore ACPI enumerations */
|
|
return VIDEO_ENUM_INVALID_DEVICE;
|
|
}
|
|
|
|
*pUnused = 0;
|
|
if (ChildEnumInfo->ChildIndex == DISPLAY_ADAPTER_HW_ID)
|
|
{
|
|
*VideoChildType = VideoChip;
|
|
return VIDEO_ENUM_MORE_DEVICES;
|
|
}
|
|
|
|
if (ChildEnumInfo->ChildIndex != 1)
|
|
return VIDEO_ENUM_NO_MORE_DEVICES;
|
|
|
|
*UId = 0;
|
|
*VideoChildType = Monitor;
|
|
|
|
if (pChildDescriptor &&
|
|
ChildEnumInfo->ChildDescriptorSize >= VBE_EDID_SIZE &&
|
|
!DeviceExtension->IoPorts.RangeInIoSpace)
|
|
{
|
|
memcpy(pChildDescriptor,
|
|
DeviceExtension->IoPorts.Mapped,
|
|
VBE_EDID_SIZE);
|
|
}
|
|
|
|
VideoDebugPrint((Info, "Bochs: BochsGetVideoChildDescriptor Exit Uid:%d\n", ChildEnumInfo->ChildIndex));
|
|
|
|
return VIDEO_ENUM_MORE_DEVICES;
|
|
}
|
|
|
|
ULONG NTAPI
|
|
DriverEntry(PVOID Context1, PVOID Context2)
|
|
{
|
|
VIDEO_HW_INITIALIZATION_DATA VideoInitData;
|
|
|
|
VideoDebugPrint((Info, "Bochs: DriverEntry\n"));
|
|
VideoPortZeroMemory(&VideoInitData, sizeof(VideoInitData));
|
|
VideoInitData.HwInitDataSize = sizeof(VideoInitData);
|
|
VideoInitData.HwFindAdapter = BochsFindAdapter;
|
|
VideoInitData.HwInitialize = BochsInitialize;
|
|
VideoInitData.HwStartIO = BochsStartIO;
|
|
VideoInitData.HwDeviceExtensionSize = sizeof(BOCHS_DEVICE_EXTENSION);
|
|
VideoInitData.HwSetPowerState = BochsSetPowerState;
|
|
VideoInitData.HwGetPowerState = BochsGetPowerState;
|
|
VideoInitData.HwGetVideoChildDescriptor = BochsGetVideoChildDescriptor;
|
|
|
|
return VideoPortInitialize(Context1, Context2, &VideoInitData, NULL);
|
|
}
|