DWORD XenVesaMapVideoMemory(PPDEV pDev)
{
DWORD dwRet, dwRetBytes;
VIDEO_MEMORY videoMem;
VIDEO_MEMORY_INFORMATION videoMemInfo;
videoMem.RequestedVirtualAddress = 0;
dwRet = EngDeviceIoControl(pDev->hDriver,
IOCTL_VIDEO_MAP_VIDEO_MEMORY,
&videoMem, sizeof(VIDEO_MEMORY),
&videoMemInfo,
sizeof(VIDEO_MEMORY_INFORMATION), &dwRetBytes);
if (dwRet != 0 )
{
XenVesaDebugPrint(DEBUG_LEVEL_ERROR,
"Unable to map video memory! Error - %d\n",
dwRet);
pDev->pFrameBuffer = (PULONG) NULL;
return dwRet;
}
pDev->pFrameBuffer = (PULONG) videoMemInfo.FrameBufferBase;
return dwRet;
}
DWORD XenVesaGetNumModesFromMiniport(HANDLE hDrv, PDWORD pNumModes,
PDWORD pModeInfoSize)
{
DWORD dwRet, dwRetBytes;
VIDEO_NUM_MODES videoNumModes;
if ( pNumModes == NULL || pModeInfoSize == NULL )
{
XenVesaDebugPrint(DEBUG_LEVEL_ERROR,
"GetNumModesFromMiniport: Invalid input!\n");
return -1;
}
dwRet = EngDeviceIoControl(hDrv, IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES,
NULL, 0, &videoNumModes,
sizeof(VIDEO_NUM_MODES), &dwRetBytes);
if ( dwRet != 0 )
{
XenVesaDebugPrint(DEBUG_LEVEL_ERROR,
"Unable to query number of available modes. Error - %d\n",
dwRet);
return dwRet;
}
*pModeInfoSize = videoNumModes.ModeInformationLength;
*pNumModes = videoNumModes.NumModes;
return dwRet;
}
DWORD XenVesaGetModesFromMiniport(HANDLE hDrv,
PVIDEO_MODE_INFORMATION pModeInfo,
DWORD dwModeInfoSize, DWORD dwNumModes)
{
DWORD dwRet, dwRetBytes, dwTotalModeInfoSize;
if ( dwModeInfoSize == 0 || dwNumModes == 0 || pModeInfo == NULL )
{
XenVesaDebugPrint(DEBUG_LEVEL_ERROR,
"XenVesaGetModesFromMiniport: Invalid input!\n");
return -1;
}
dwTotalModeInfoSize = dwModeInfoSize * dwNumModes;
dwRet = EngDeviceIoControl(hDrv, IOCTL_VIDEO_QUERY_AVAIL_MODES,
NULL, 0, pModeInfo,
dwTotalModeInfoSize, &dwRetBytes);
if ( dwRet != 0 )
{
XenVesaDebugPrint(DEBUG_LEVEL_ERROR,
"Unable to query available modes! Error - %d\n",
dwRet);
return dwRet;
}
return dwRet;
}
BOOL NTAPI bInitPointer(PPDEV ppdev, DEVINFO *pdevinfo)
{
DWORD returnedDataLength;
ppdev->pPointerAttributes = (PVIDEO_POINTER_ATTRIBUTES) NULL;
ppdev->cjPointerAttributes = 0; // initialized in screen.c
//
// Ask the miniport whether it provides pointer support.
//
if (EngDeviceIoControl(ppdev->hDriver,
IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES,
NULL,
0,
&ppdev->PointerCapabilities,
sizeof(ppdev->PointerCapabilities),
&returnedDataLength))
{
return(FALSE);
}
//
// If neither mono nor color hardware pointer is supported, there's no
// hardware pointer support and we're done.
//
if ((!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_MONO_POINTER)) &&
(!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_COLOR_POINTER)))
{
return(TRUE);
}
//
// Note: The buffer itself is allocated after we set the
// mode. At that time we know the pixel depth and we can
// allocate the correct size for the color pointer if supported.
//
//
// Set the asynchronous support status (async means miniport is capable of
// drawing the Pointer at any time, with no interference with any ongoing
// drawing operation)
//
if (ppdev->PointerCapabilities.Flags & VIDEO_MODE_ASYNC_POINTER)
{
pdevinfo->flGraphicsCaps |= GCAPS_ASYNCMOVE;
}
else
{
pdevinfo->flGraphicsCaps &= ~GCAPS_ASYNCMOVE;
}
return(TRUE);
}
int VBoxDispMPDisablePointer(HANDLE hDriver)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_DISABLE_POINTER, NULL, 0, NULL, 0, &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
int VBoxDispMPResetDevice(HANDLE hDriver)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_RESET_DEVICE, NULL, 0, NULL, 0, &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
int VBoxDispMPSetColorRegisters(HANDLE hDriver, PVIDEO_CLUT pClut, DWORD cbClut)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_SET_COLOR_REGISTERS, pClut, cbClut, NULL, 0, &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
BOOL bInit256ColorPalette(PPDEV ppdev)
{
BYTE ajClutSpace[MAX_CLUT_SIZE];
PVIDEO_CLUT pScreenClut;
ULONG ulReturnedDataLength;
ULONG cColors;
PVIDEO_CLUTDATA pScreenClutData;
if (ppdev->ulBitCount == 8)
{
//
// Fill in pScreenClut header info:
//
pScreenClut = (PVIDEO_CLUT) ajClutSpace;
pScreenClut->NumEntries = 256;
pScreenClut->FirstEntry = 0;
//
// Copy colours in:
//
cColors = 256;
pScreenClutData = (PVIDEO_CLUTDATA) (&(pScreenClut->LookupTable[0]));
while(cColors--)
{
pScreenClutData[cColors].Red = ppdev->pPal[cColors].peRed >>
ppdev->cPaletteShift;
pScreenClutData[cColors].Green = ppdev->pPal[cColors].peGreen >>
ppdev->cPaletteShift;
pScreenClutData[cColors].Blue = ppdev->pPal[cColors].peBlue >>
ppdev->cPaletteShift;
pScreenClutData[cColors].Unused = 0;
}
//
// Set palette registers:
//
if (EngDeviceIoControl(ppdev->hDriver,
IOCTL_VIDEO_SET_COLOR_REGISTERS,
pScreenClut,
MAX_CLUT_SIZE,
NULL,
0,
&ulReturnedDataLength))
{
DISPDBG((0, "Failed bEnablePalette"));
return(FALSE);
}
}
BOOL DrvSetPalette (DHPDEV dhpdev,
PALOBJ *ppalo,
FLONG fl,
ULONG iStart,
ULONG cColors)
{
BYTE ajClutSpace[MAX_CLUT_SIZE];
PVIDEO_CLUT pScreenClut = (PVIDEO_CLUT) ajClutSpace;
PPALETTEENTRY pape;
ULONG ulTemp = 256;
UNREFERENCED_PARAMETER (fl);
DISPBLTDBG ((1, "TGA.DLL!DrvSetPalette - Entry\n"));
DISPBLTDBG ((2, "TGA.DLL!DrvSetPalette - ppalo [%x], fl [%x], iStart [%d], cColors [%d]\n", ppalo, fl, iStart, cColors));
// Fill in pScreenClut header info
pScreenClut->NumEntries = (USHORT)cColors;
pScreenClut->FirstEntry = (USHORT)iStart;
pape = (PPALETTEENTRY) (pScreenClut->LookupTable);
if (cColors != PALOBJ_cGetColors (ppalo, iStart, cColors, (PULONG) pape))
{
RIP ("DISP DrvSetPalette failed PALOBJ_cGetColors\n");
return FALSE;
}
// Set the high reserved byte in each palette entry to 0.
while (cColors--)
pape[cColors].peFlags = 0;
// Set palette registers
if (EngDeviceIoControl (((PPDEV)(dhpdev))->hDriver,
IOCTL_VIDEO_SET_COLOR_REGISTERS,
pScreenClut,
MAX_CLUT_SIZE,
NULL,
0,
&cColors))
{
RIP ("DISP DrvSetPalette failed EngDeviceIoControl\n");
return FALSE;
}
DISPBLTDBG ((1, "TGA.DLL!DrvSetPalette - Exit\n"));
return TRUE;
}
int VBoxDispMPSetPointerPosition(HANDLE hDriver, PVIDEO_POINTER_POSITION pPos)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_SET_POINTER_POSITION, pPos, sizeof(VIDEO_POINTER_POSITION),
NULL, 0, &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
DWORD XenVesaResetDevice(PPDEV pDev)
{
DWORD dwRet, dwRetBytes;
dwRet = EngDeviceIoControl(pDev->hDriver, IOCTL_VIDEO_RESET_DEVICE,
0, 0, 0, 0, &dwRetBytes);
if ( dwRet != 0)
XenVesaDebugPrint(DEBUG_LEVEL_ERROR,
"Reset device failed with error - %d\n",
dwRet);
return dwRet;
}
int VBoxDispMPSetVisibleRegion(HANDLE hDriver, PRTRECT pRects, DWORD cRects)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_VBOX_SETVISIBLEREGION, pRects, cRects*sizeof(RTRECT),
NULL, 0, &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
int VBoxDispMPUnshareVideoMemory(HANDLE hDriver, PVIDEO_SHARE_MEMORY pSMem)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY, pSMem, sizeof(VIDEO_SHARE_MEMORY),
NULL, 0, &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
/* Set device mode */
int VBoxDispMPSetCurrentMode(HANDLE hDriver, ULONG ulMode)
{
DWORD dwrc;
ULONG cbReturned;
VIDEO_MODE mode;
LOGF_ENTER();
mode.RequestedMode = ulMode;
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_SET_CURRENT_MODE, &mode, sizeof(VIDEO_MODE), NULL, 0, &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
int VBoxDispMPShareVideoMemory(HANDLE hDriver, PVIDEO_SHARE_MEMORY pSMem, PVIDEO_SHARE_MEMORY_INFORMATION pSMemInfo)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_SHARE_VIDEO_MEMORY, pSMem, sizeof(VIDEO_SHARE_MEMORY),
pSMemInfo, sizeof(VIDEO_SHARE_MEMORY_INFORMATION), &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_SHARE_VIDEO_MEMORY", cbReturned,
sizeof(VIDEO_SHARE_MEMORY_INFORMATION), VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
int VBoxDispMPHGSMIQueryPortProcs(HANDLE hDriver, HGSMIQUERYCPORTPROCS *pPortProcs)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
memset(pPortProcs, 0, sizeof(HGSMIQUERYCPORTPROCS));
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_HGSMI_QUERY_PORTPROCS, NULL, 0,
pPortProcs, sizeof(HGSMIQUERYCPORTPROCS), &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_HGSMI_QUERY_PORTPROCS", cbReturned, sizeof(HGSMIQUERYCPORTPROCS), VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
int VBoxDispMPSetPointerAttrs(PVBOXDISPDEV pDev)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
Assert(pDev->pointer.pAttrs);
dwrc = EngDeviceIoControl(pDev->hDriver, IOCTL_VIDEO_SET_POINTER_ATTR, pDev->pointer.pAttrs, pDev->pointer.cbAttrs,
NULL, 0, &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
int VBoxDispMPVHWAQueryInfo(HANDLE hDriver, VHWAQUERYINFO *pInfo)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
memset(pInfo, 0, sizeof(VHWAQUERYINFO));
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_VHWA_QUERY_INFO, NULL, 0,
pInfo, sizeof(VHWAQUERYINFO), &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_VHWA_QUERY_INFO", cbReturned, sizeof(VHWAQUERYINFO), VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
int VBoxDispMPQueryHGSMICallbacks(HANDLE hDriver, HGSMIQUERYCALLBACKS *pCallbacks)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
memset(pCallbacks, 0, sizeof(HGSMIQUERYCALLBACKS));
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS, NULL, 0,
pCallbacks, sizeof(HGSMIQUERYCALLBACKS), &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS", cbReturned, sizeof(HGSMIQUERYCALLBACKS), VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
DWORD XenVesaSetCurrentDisplayMode(PPDEV pDev)
{
DWORD dwRet, dwRetBytes;
VIDEO_MODE vMode;
vMode.RequestedMode = pDev->ulMode;
dwRet = EngDeviceIoControl(pDev->hDriver,
IOCTL_VIDEO_SET_CURRENT_MODE, &vMode,
sizeof(VIDEO_MODE), 0, 0, &dwRetBytes);
if (dwRet != 0 )
XenVesaDebugPrint(DEBUG_LEVEL_ERROR,
"Unable to set current display mode! Error - %d\n",
dwRet);
return dwRet;
}
int VBoxDispMPUnmapMemory(PVBOXDISPDEV pDev)
{
DWORD dwrc;
ULONG cbReturned;
VIDEO_MEMORY vMem;
LOGF_ENTER();
vMem.RequestedVirtualAddress = pDev->memInfo.VideoRamBase;
dwrc = EngDeviceIoControl(pDev->hDriver, IOCTL_VIDEO_UNMAP_VIDEO_MEMORY, &vMem, sizeof(vMem), NULL, 0, &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
memset(&pDev->memInfo, 0, sizeof(VIDEO_MEMORY_INFORMATION));
LOGF_LEAVE();
return VINF_SUCCESS;
}
/* Query miniport for mouse pointer caps */
int VBoxDispMPGetPointerCaps(HANDLE hDriver, PVIDEO_POINTER_CAPABILITIES pCaps)
{
DWORD dwrc;
ULONG cbReturned;
LOGF_ENTER();
memset(pCaps, 0, sizeof(VIDEO_POINTER_CAPABILITIES));
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES, NULL, 0,
pCaps, sizeof(VIDEO_POINTER_CAPABILITIES), &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES", cbReturned, sizeof(VIDEO_POINTER_CAPABILITIES), VERR_DEV_IO_ERROR);
LOGF_LEAVE();
return VINF_SUCCESS;
}
BOOL bEnablePalette(PDEV* ppdev)
{
BYTE ajClutSpace[MAX_CLUT_SIZE];
PVIDEO_CLUT pScreenClut;
ULONG ulReturnedDataLength;
PALETTEENTRY* ppalFrom;
PALETTEENTRY* ppalTo;
PALETTEENTRY* ppalEnd;
if (ppdev->iBitmapFormat == BMF_8BPP)
{
// Fill in pScreenClut header info:
pScreenClut = (PVIDEO_CLUT) ajClutSpace;
pScreenClut->NumEntries = 256;
pScreenClut->FirstEntry = 0;
// Copy Colors in.
ppalFrom = ppdev->pPal;
ppalTo = (PALETTEENTRY*) pScreenClut->LookupTable;
ppalEnd = &ppalTo[256];
for (; ppalTo < ppalEnd; ppalFrom++, ppalTo++)
{
ppalTo->peRed = ppalFrom->peRed >> 2;
ppalTo->peGreen = ppalFrom->peGreen >> 2;
ppalTo->peBlue = ppalFrom->peBlue >> 2;
ppalTo->peFlags = 0;
}
// Set palette registers:
if (EngDeviceIoControl(ppdev->hDriver,
IOCTL_VIDEO_SET_COLOR_REGISTERS,
pScreenClut,
MAX_CLUT_SIZE,
NULL,
0,
&ulReturnedDataLength))
{
DISPDBG((0, "Failed bEnablePalette"));
return(FALSE);
}
}
VOID NTAPI vDisableSURF(PPDEV ppdev)
{
DWORD returnedDataLength;
VIDEO_MEMORY videoMemory;
videoMemory.RequestedVirtualAddress = (PVOID) ppdev->pjScreen;
if (EngDeviceIoControl(ppdev->hDriver,
IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
&videoMemory,
sizeof(VIDEO_MEMORY),
NULL,
0,
&returnedDataLength))
{
RIP("DISP vDisableSURF failed IOCTL_VIDEO_UNMAP\n");
}
}
BOOL bInit256ColorPalette (PPDEV ppdev)
{
BYTE ajClutSpace[MAX_CLUT_SIZE];
PVIDEO_CLUT pScreenClut = (PVIDEO_CLUT) ajClutSpace;
ULONG ulReturnedDataLength;
DISPBLTDBG ((1, "TGA.DLL!bInit256ColorPalette - Entry\n"));
// Fill in pScreenClut header info
pScreenClut->NumEntries = 256;
pScreenClut->FirstEntry = 0;
// make sure that we have a palette
if (ppdev->pPal == NULL)
{
RIP ("DISP bInit256ColorPalette -- pPal == NULL\n");
return FALSE;
}
// Copy Colors in.
RtlCopyMemory (pScreenClut->LookupTable, ppdev->pPal, sizeof(ULONG) * 256);
// Set palette registers
if (EngDeviceIoControl (ppdev->hDriver,
IOCTL_VIDEO_SET_COLOR_REGISTERS,
pScreenClut,
MAX_CLUT_SIZE,
NULL,
0,
&ulReturnedDataLength))
{
RIP ("DISP bInit256ColorPalette failed EngDeviceIoControl\n");
return FALSE;
}
DISPBLTDBG ((1, "TGA.DLL!bInit256ColorPalette - Exit\n"));
return TRUE;
}
int VBoxDispMPQueryRegistryFlags(HANDLE hDriver, ULONG *pulFlags)
{
DWORD dwrc;
ULONG cbReturned;
ULONG ulInfoLevel;
LOGF_ENTER();
*pulFlags = 0;
ulInfoLevel = VBOXVIDEO_INFO_LEVEL_REGISTRY_FLAGS;
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_QUERY_VBOXVIDEO_INFO, &ulInfoLevel, sizeof(DWORD),
pulFlags, sizeof(DWORD), &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_QUERY_INFO", cbReturned, sizeof(DWORD), VERR_DEV_IO_ERROR);
if (*pulFlags != 0)
LogRel(("VBoxDisp: video flags 0x%08X\n", *pulFlags));
LOGF_LEAVE();
return VINF_SUCCESS;
}
DWORD XenVesaUnmapVideoMemory(PPDEV pDev)
{
DWORD dwRet, dwRetBytes;
VIDEO_MEMORY videoMem;
if ( pDev->pFrameBuffer == NULL )
return 0;
videoMem.RequestedVirtualAddress = pDev->pFrameBuffer;
dwRet = EngDeviceIoControl(pDev->hDriver,
IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
&videoMem, sizeof(VIDEO_MEMORY),
0, 0, &dwRetBytes);
pDev->pFrameBuffer = (PULONG) NULL;
if (dwRet != 0 )
XenVesaDebugPrint(DEBUG_LEVEL_ERROR,
"Unable to unmap video memory! Error - %d\n",
dwRet);
return dwRet;
}
BOOL DeinitVGA(PPDEV ppdev)
{
VIDEO_MEMORY VideoMemory;
ULONG ReturnedDataLength;
VideoMemory.RequestedVirtualAddress = (PVOID)ppdev->fbScreen;
if (EngDeviceIoControl(ppdev->KMDriver,
IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
(PVOID)&VideoMemory,
sizeof(VIDEO_MEMORY),
NULL,
0,
&ReturnedDataLength))
{
DPRINT1("Failed to unmap video memory.\n");
EngDebugBreak();
return FALSE;
}
return TRUE;
}
BOOL DrvAssertMode(
DHPDEV dhpdev,
BOOL bEnable)
{
PPDEV ppdev = (PPDEV) dhpdev;
ULONG ulReturn;
if (bEnable)
{
//
// The screen must be reenabled, reinitialize the device to clean state.
//
return (bInitSURF(ppdev, FALSE));
}
else
{
//
// We must give up the display.
// Call the kernel driver to reset the device to a known state.
//
if (EngDeviceIoControl(ppdev->hDriver,
IOCTL_VIDEO_RESET_DEVICE,
NULL,
0,
NULL,
0,
&ulReturn))
{
RIP("DISP DrvAssertMode failed IOCTL");
return FALSE;
}
else
{
return TRUE;
}
}
}
/* Map device framebuffer and VRAM to our virtual address space */
int VBoxDispMPMapMemory(PVBOXDISPDEV pDev, PVIDEO_MEMORY_INFORMATION pMemInfo)
{
DWORD dwrc;
ULONG cbReturned;
VIDEO_MEMORY vMem;
VIDEO_MEMORY_INFORMATION vMemInfo;
LOGF_ENTER();
Assert(!pDev->memInfo.FrameBufferBase && !pDev->memInfo.VideoRamBase);
vMem.RequestedVirtualAddress = NULL;
dwrc = EngDeviceIoControl(pDev->hDriver, IOCTL_VIDEO_MAP_VIDEO_MEMORY, &vMem, sizeof(vMem), &vMemInfo, sizeof(vMemInfo), &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_MAP_VIDEO_MEMORY", cbReturned, sizeof(vMemInfo), VERR_DEV_IO_ERROR);
if (vMemInfo.FrameBufferBase != vMemInfo.VideoRamBase)
{
WARN(("FrameBufferBase!=VideoRamBase."));
return VERR_GENERAL_FAILURE;
}
/* Check if we can access mapped memory */
uint32_t magic = (*(ULONG *)vMemInfo.FrameBufferBase == 0xDEADF00D) ? 0xBAADF00D : 0xDEADF00D;
ASMAtomicWriteU32((uint32_t *)vMemInfo.FrameBufferBase, magic);
if (ASMAtomicReadU32((uint32_t *)vMemInfo.FrameBufferBase) != magic)
{
WARN(("can't write to framebuffer memory!"));
return VERR_GENERAL_FAILURE;
}
memcpy(pMemInfo, &vMemInfo, sizeof(vMemInfo));
LOGF_LEAVE();
return VINF_SUCCESS;
}
