bochsmp.c File Reference

#include "bochsmp.h"

Include dependency graph for bochsmp.c:

Go to the source code of this file.

Macros
#define	HEX(c)   (((c) >= 0 && (c) <= 9) ? (c) + L'0' : (c) - 10 + L'A')

Functions
static VOID	BochsFreeResources (_Inout_ PBOCHS_DEVICE_EXTENSION DeviceExtension)
static VOID	BochsWriteDispI (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _In_ ULONG Index, _In_ USHORT Value)
static USHORT	BochsReadDispI (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _In_ ULONG Index)
static BOOLEAN	BochsWriteDispIAndCheck (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _In_ ULONG Index, _In_ USHORT Value)
static BOOLEAN	BochsInitializeSuitableModeInfo (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _In_ ULONG PotentialModeCount)
static BOOLEAN	BochsGetControllerInfo (_Inout_ PBOCHS_DEVICE_EXTENSION DeviceExtension)
static VOID	BochsGetModeInfo (_In_ PBOCHS_SIZE AvailableModeInfo, _Out_ PVIDEO_MODE_INFORMATION ModeInfo, _In_ ULONG Index)
static BOOLEAN	BochsMapVideoMemory (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _In_ PVIDEO_MEMORY RequestedAddress, _Out_ PVIDEO_MEMORY_INFORMATION MapInformation, _Out_ PSTATUS_BLOCK StatusBlock)
static BOOLEAN NTAPI	BochsUnmapVideoMemory (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _In_ PVIDEO_MEMORY VideoMemory, _Out_ PSTATUS_BLOCK StatusBlock)
static BOOLEAN	BochsQueryNumAvailableModes (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _Out_ PVIDEO_NUM_MODES AvailableModes, _Out_ PSTATUS_BLOCK StatusBlock)
static BOOLEAN	BochsQueryAvailableModes (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _Out_ PVIDEO_MODE_INFORMATION ReturnedModes, _Out_ PSTATUS_BLOCK StatusBlock)
static BOOLEAN	BochsSetCurrentMode (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _In_ PVIDEO_MODE RequestedMode, _Out_ PSTATUS_BLOCK StatusBlock)
static BOOLEAN	BochsQueryCurrentMode (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _Out_ PVIDEO_MODE_INFORMATION VideoModeInfo, _Out_ PSTATUS_BLOCK StatusBlock)
static BOOLEAN	BochsResetDevice (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _Out_ PSTATUS_BLOCK StatusBlock)
static BOOLEAN	BochsGetChildState (_In_ PBOCHS_DEVICE_EXTENSION DeviceExtension, _Out_ PULONG pChildState, _Out_ PSTATUS_BLOCK StatusBlock)
VP_STATUS NTAPI	BochsFindAdapter (_In_ PVOID HwDeviceExtension, _In_ PVOID HwContext, _In_ PWSTR ArgumentString, _In_ PVIDEO_PORT_CONFIG_INFO ConfigInfo, _In_ PUCHAR Again)
BOOLEAN NTAPI	BochsInitialize (_In_ PVOID HwDeviceExtension)
BOOLEAN NTAPI	BochsStartIO (_In_ PVOID HwDeviceExtension, _Inout_ PVIDEO_REQUEST_PACKET RequestPacket)
VP_STATUS NTAPI	BochsSetPowerState (_In_ PVOID HwDeviceExtension, _In_ ULONG HwId, _In_ PVIDEO_POWER_MANAGEMENT VideoPowerControl)
VP_STATUS NTAPI	BochsGetPowerState (_In_ PVOID HwDeviceExtension, _In_ ULONG HwId, _Out_ PVIDEO_POWER_MANAGEMENT VideoPowerControl)
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)
ULONG NTAPI	DriverEntry (PVOID Context1, PVOID Context2)

Variables
static const BOCHS_SIZE	BochsAvailableResolutions []

Macro Definition Documentation

HEX

#define HEX

(

c

)

(((c) >= 0 && (c) <= 9) ? (c) + L'0' : (c) - 10 + L'A')

Function Documentation

BochsFindAdapter()

VP_STATUS NTAPI BochsFindAdapter	(	_In_ PVOID	HwDeviceExtension,
		_In_ PVOID	HwContext,
		_In_ PWSTR	ArgumentString,
		_In_ PVIDEO_PORT_CONFIG_INFO	ConfigInfo,
		_In_ PUCHAR	Again
	)

Definition at line 445 of file bochsmp.c.

{
    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;
}

Referenced by DriverEntry().

BochsFreeResources()

static VOID BochsFreeResources ( _Inout_ PBOCHS_DEVICE_EXTENSION  DeviceExtension )

static

Definition at line 38 of file bochsmp.c.

{
    if (DeviceExtension->AvailableModeInfo)
    {
        VideoPortFreePool(DeviceExtension, DeviceExtension->AvailableModeInfo);
        DeviceExtension->AvailableModeInfo = NULL;
    }
}

Referenced by BochsInitialize().

BochsGetChildState()

static BOOLEAN BochsGetChildState ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _Out_ PULONG  pChildState, _Out_ PSTATUS_BLOCK  StatusBlock  )

static

Definition at line 431 of file bochsmp.c.

{
    *pChildState = VIDEO_CHILD_ACTIVE;
 
    StatusBlock->Information = sizeof(*pChildState);
    StatusBlock->Status = NO_ERROR;
    return TRUE;
}

Referenced by BochsStartIO().

BochsGetControllerInfo()

static BOOLEAN BochsGetControllerInfo ( _Inout_ PBOCHS_DEVICE_EXTENSION  DeviceExtension )

static

Definition at line 125 of file bochsmp.c.

{
    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;
}

Referenced by BochsInitialize().

BochsGetModeInfo()

static VOID BochsGetModeInfo ( _In_ PBOCHS_SIZE  AvailableModeInfo, _Out_ PVIDEO_MODE_INFORMATION  ModeInfo, _In_ ULONG  Index  )

static

Definition at line 201 of file bochsmp.c.

{
    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;
}

Referenced by BochsQueryAvailableModes(), and BochsQueryCurrentMode().

BochsGetPowerState()

VP_STATUS NTAPI BochsGetPowerState	(	_In_ PVOID	HwDeviceExtension,
		_In_ ULONG	HwId,
		_Out_ PVIDEO_POWER_MANAGEMENT	VideoPowerControl
	)

Definition at line 691 of file bochsmp.c.

{
    return ERROR_DEVICE_REINITIALIZATION_NEEDED;
}

Referenced by DriverEntry().

BochsGetVideoChildDescriptor()

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
	)

Definition at line 701 of file bochsmp.c.

{
    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;
}

Referenced by DriverEntry().

BochsInitialize()

BOOLEAN NTAPI BochsInitialize

(

_In_ PVOID

HwDeviceExtension

)

Definition at line 513 of file bochsmp.c.

{
    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;
}

Referenced by DriverEntry().

BochsInitializeSuitableModeInfo()

static BOOLEAN BochsInitializeSuitableModeInfo ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _In_ ULONG  PotentialModeCount  )

static

Definition at line 96 of file bochsmp.c.

{
    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;
}

Referenced by BochsInitialize().

BochsMapVideoMemory()

static BOOLEAN BochsMapVideoMemory ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _In_ PVIDEO_MEMORY  RequestedAddress, _Out_ PVIDEO_MEMORY_INFORMATION  MapInformation, _Out_ PSTATUS_BLOCK  StatusBlock  )

static

Definition at line 234 of file bochsmp.c.

{
    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;
}

Referenced by BochsStartIO().

BochsQueryAvailableModes()

static BOOLEAN BochsQueryAvailableModes ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _Out_ PVIDEO_MODE_INFORMATION  ReturnedModes, _Out_ PSTATUS_BLOCK  StatusBlock  )

static

Definition at line 316 of file bochsmp.c.

{
    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;
}

Referenced by BochsStartIO().

BochsQueryCurrentMode()

static BOOLEAN BochsQueryCurrentMode ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _Out_ PVIDEO_MODE_INFORMATION  VideoModeInfo, _Out_ PSTATUS_BLOCK  StatusBlock  )

static

Definition at line 393 of file bochsmp.c.

{
    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;
}

Referenced by BochsStartIO().

BochsQueryNumAvailableModes()

static BOOLEAN BochsQueryNumAvailableModes ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _Out_ PVIDEO_NUM_MODES  AvailableModes, _Out_ PSTATUS_BLOCK  StatusBlock  )

static

Definition at line 301 of file bochsmp.c.

{
    AvailableModes->NumModes = DeviceExtension->AvailableModeCount;
    AvailableModes->ModeInformationLength = sizeof(VIDEO_MODE_INFORMATION);
 
    StatusBlock->Information = sizeof(*AvailableModes);
    StatusBlock->Status = NO_ERROR;
    return TRUE;
}

Referenced by BochsStartIO().

BochsReadDispI()

static USHORT BochsReadDispI ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _In_ ULONG  Index  )

static

Definition at line 68 of file bochsmp.c.

{
    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));
    }
}

Referenced by BochsGetControllerInfo(), and BochsWriteDispIAndCheck().

BochsResetDevice()

static BOOLEAN BochsResetDevice ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _Out_ PSTATUS_BLOCK  StatusBlock  )

static

Definition at line 417 of file bochsmp.c.

{
    VideoDebugPrint((Info, "Bochs:BochsResetDevice Entry\n"));
 
    StatusBlock->Status = NO_ERROR;
 
    VideoDebugPrint((Info, "Bochs:BochsResetDevice Exit\n"));
    return TRUE;
}

Referenced by BochsStartIO().

BochsSetCurrentMode()

static BOOLEAN BochsSetCurrentMode ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _In_ PVIDEO_MODE  RequestedMode, _Out_ PSTATUS_BLOCK  StatusBlock  )

static

Definition at line 341 of file bochsmp.c.

{
    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;
}

Referenced by BochsStartIO().

BochsSetPowerState()

VP_STATUS NTAPI BochsSetPowerState	(	_In_ PVOID	HwDeviceExtension,
		_In_ ULONG	HwId,
		_In_ PVIDEO_POWER_MANAGEMENT	VideoPowerControl
	)

Definition at line 681 of file bochsmp.c.

{
    return NO_ERROR;
}

Referenced by DriverEntry().

BochsStartIO()

BOOLEAN NTAPI BochsStartIO	(	_In_ PVOID	HwDeviceExtension,
		_Inout_ PVIDEO_REQUEST_PACKET	RequestPacket
	)

Definition at line 550 of file bochsmp.c.

{
    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;
}

Referenced by DriverEntry().

BochsUnmapVideoMemory()

static BOOLEAN NTAPI BochsUnmapVideoMemory ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _In_ PVIDEO_MEMORY  VideoMemory, _Out_ PSTATUS_BLOCK  StatusBlock  )

static

Definition at line 276 of file bochsmp.c.

{
    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);
}

Referenced by BochsStartIO().

BochsWriteDispI()

static VOID BochsWriteDispI ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _In_ ULONG  Index, _In_ USHORT  Value  )

static

Definition at line 50 of file bochsmp.c.

{
    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);
    }
}

Referenced by BochsGetControllerInfo(), BochsSetCurrentMode(), and BochsWriteDispIAndCheck().

BochsWriteDispIAndCheck()

static BOOLEAN BochsWriteDispIAndCheck ( _In_ PBOCHS_DEVICE_EXTENSION  DeviceExtension, _In_ ULONG  Index, _In_ USHORT  Value  )

static

Definition at line 85 of file bochsmp.c.

{
    BochsWriteDispI(DeviceExtension, Index, Value);
    return BochsReadDispI(DeviceExtension, Index) == Value;
}

Referenced by BochsGetControllerInfo(), and BochsSetCurrentMode().

DriverEntry()

ULONG NTAPI DriverEntry	(	PVOID	Context1,
		PVOID	Context2
	)

Definition at line 750 of file bochsmp.c.

{
    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);
}

Variable Documentation

BochsAvailableResolutions

const BOCHS_SIZE BochsAvailableResolutions[]

static

Initial value:

= {
    { 640, 480 },   
    { 800, 600 },   
    { 1024, 600 },  
    { 1024, 768 },  
    { 1152, 864 },  
    { 1280, 720 },  
    { 1280, 768 },  
    { 1280, 960 },  
    { 1280, 1024 }, 
    { 1368, 768 },  
    { 1400, 1050 }, 
    { 1440, 900 },  
    { 1600, 900 },  
    { 1600, 1200 }, 
    { 1680, 1050 }, 
    { 1920, 1080 }, 
    { 2048, 1536 }, 
    { 2560, 1440 }, 
    { 2560, 1600 }, 
    { 2560, 2048 }, 
    { 2800, 2100 }, 
    { 3200, 2400 }, 
    { 3840, 2160 }, 
}

Definition at line 10 of file bochsmp.c.

Referenced by BochsInitialize(), and BochsInitializeSuitableModeInfo().