VBoxMPMisc.cpp revision ad290511521ce8388a9926b165241ecf83c330a7
/* $Id$ */
/** @file
* VBox WDDM Miniport driver
*/
/*
* Copyright (C) 2011-2013 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#include "VBoxMPWddm.h"
#include <stdio.h>
/* simple handle -> value table API */
{
{
return STATUS_SUCCESS;
}
return STATUS_NO_MEMORY;
}
{
return;
}
{
return iIndex+1;
}
{
return hHandle-1;
}
{
{
if (!pvNewData)
{
return STATUS_NO_MEMORY;
}
return STATUS_SUCCESS;
}
{
AssertFailed();
return STATUS_NOT_IMPLEMENTED;
}
return STATUS_INVALID_PARAMETER;
}
{
{
if (Status != STATUS_SUCCESS)
return VBOXWDDM_HANDLE_INVALID;
}
{
{
++pTbl->iNext2Search;
return vboxWddmHTableIndex2Handle(i);
}
}
Assert(0);
return VBOXWDDM_HANDLE_INVALID;
}
{
{
return pvData;
}
return NULL;
}
{
return NULL;
}
{
}
{
}
{
{
{
{
if (phHandle)
}
}
}
if (phHandle)
return NULL;
}
{
if (hHandle)
{
return pRet;
}
return NULL;
}
#ifdef VBOX_WITH_CROGL
{
PVBOXWDDM_SWAPCHAIN pSwapchain = (PVBOXWDDM_SWAPCHAIN)vboxWddmMemAllocZero(sizeof (VBOXWDDM_SWAPCHAIN));
if (pSwapchain)
{
/* init to some invalid value so that the pos get submitted */
pSwapchain->width = w;
pSwapchain->height = h;
}
return pSwapchain;
}
{
{
return TRUE;
}
return FALSE;
}
{
return bRc;
}
{
if (!cRefs)
{
}
}
PVBOXWDDM_SWAPCHAIN vboxWddmSwapchainRetainByAllocData(PVBOXMP_DEVEXT pDevExt, const struct VBOXWDDM_ALLOC_DATA *pAllocData)
{
pSwapchain = NULL;
return pSwapchain;
}
PVBOXWDDM_SWAPCHAIN vboxWddmSwapchainRetainByAlloc(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOCATION *pAlloc)
{
}
VOID vboxWddmSwapchainAllocRemove(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SWAPCHAIN pSwapchain, PVBOXWDDM_ALLOCATION pAlloc)
{
}
BOOLEAN vboxWddmSwapchainAllocAdd(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SWAPCHAIN pSwapchain, PVBOXWDDM_ALLOCATION pAlloc)
{
if (bRc)
{
{
}
}
return bRc;
}
#define VBOXSCENTRY_2_ALLOC(_pE) ((PVBOXWDDM_ALLOCATION)((uint8_t*)(_pE) - RT_OFFSETOF(VBOXWDDM_ALLOCATION, SwapchainEntry)))
static VOID vboxWddmSwapchainAllocRemoveAllInternal(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SWAPCHAIN pSwapchain, BOOLEAN bOnDestroy)
{
do
{
{
++cRemoved;
}
else
break;
} while (1);
if (bOnDestroy)
}
{
}
{
}
static BOOLEAN vboxWddmSwapchainCtxAddLocked(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain)
{
{
return TRUE;
}
return FALSE;
}
static VOID vboxWddmSwapchainCtxRemoveLocked(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain)
{
}
/* adds the given swapchain to the context's swapchain list
* @return true on success */
BOOLEAN vboxWddmSwapchainCtxAdd(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain)
{
return bRc;
}
/* removes the given swapchain from the context's swapchain list
* */
VOID vboxWddmSwapchainCtxRemove(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain)
{
}
/* destroys all swapchains for the given context
* */
{
do
{
if (!pSwapchain)
break;
/* yes, we can call remove locked even when using iterator */
/* we must not do vboxWddmSwapchainDestroy inside a context mutex */
/* start from the very beginning, we will quit the loop when no swapchains left */
} while (1);
/* no swapchains left, we exiteed the while loop via the "break", and we still owning the mutex */
}
/* process the swapchain info passed from user-mode display driver & synchronizes the driver state with it */
NTSTATUS vboxWddmSwapchainCtxEscape(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXDISPIFESCAPE_SWAPCHAININFO pSwapchainInfo, UINT cbSize)
{
{
return STATUS_INVALID_PARAMETER;
}
if (cbSize < RT_OFFSETOF(VBOXDISPIFESCAPE_SWAPCHAININFO, SwapchainInfo.ahAllocs[pSwapchainInfo->SwapchainInfo.cAllocs]))
{
return STATUS_INVALID_PARAMETER;
}
{
WARN(("Zero winHostID specified!"));
return STATUS_INVALID_PARAMETER;
}
if (!pContext)
{
WARN(("vboxWddmSwapchainCtxEscape: no context specified"));
return STATUS_INVALID_PARAMETER;
}
do {
{
/* ensure we do not overflow the 32bit buffer size value */
{
WARN(("number of allocations passed in too big (%d), max is (%d)", pSwapchainInfo->SwapchainInfo.cAllocs, VBOXWDDM_ARRAY_MAXELEMENTSU32(VBOXWDDM_ALLOCATION)));
break;
}
apAlloc = (PVBOXWDDM_ALLOCATION *)vboxWddmMemAlloc(sizeof (PVBOXWDDM_ALLOCATION) * pSwapchainInfo->SwapchainInfo.cAllocs);
if (!apAlloc)
{
break;
}
{
PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pDevExt->u.primary.DxgkInterface.DxgkCbGetHandleData(&GhData);
if (!pAlloc)
{
break;
}
}
if (!NT_SUCCESS(Status))
break;
}
{
pSwapchain = (PVBOXWDDM_SWAPCHAIN)vboxWddmHTableGet(&pContext->Swapchains, (VBOXWDDM_HANDLE)pSwapchainInfo->SwapchainInfo.hSwapchainKm);
if (!pSwapchain)
{
break;
}
{
break;
}
}
{
pSwapchain = vboxWddmSwapchainCreate(apAlloc[0]->AllocData.SurfDesc.width, apAlloc[0]->AllocData.SurfDesc.height);
if (!pSwapchain)
{
break;
}
}
else
{
break;
}
/* do not zero up the view rect since it may still be valid */
// memset(&pSwapchain->ViewRect, 0, sizeof (pSwapchain->ViewRect));
/* @todo: do we really need to zero this up here ? */
{
{
}
{
}
}
else
{
}
{
}
else
{
}
} while (0);
/* cleanup */
if (apAlloc)
return Status;
}
{
if (!NT_SUCCESS(Status))
{
return Status;
}
return STATUS_SUCCESS;
}
{
}
#endif
NTSTATUS vboxWddmRegQueryDrvKeyName(PVBOXMP_DEVEXT pDevExt, ULONG cbBuf, PWCHAR pBuf, PULONG pcbResult)
{
bool bFallback = false;
if (cbBuf > sizeof(VBOXWDDM_REG_DRVKEY_PREFIX))
{
}
else
{
cbBuf = sizeof (fallBackBuf);
bFallback = true;
}
&cbBuf);
if (Status == STATUS_BUFFER_TOO_SMALL)
return Status;
}
NTSTATUS vboxWddmRegQueryDisplaySettingsKeyName(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId,
{
bool bFallback = false;
const WCHAR* pKeyPrefix;
if (!pVGuid)
return STATUS_UNSUCCESSFUL;
{
}
else
{
}
{
pSuffix[0] = L'\\';
pSuffix += 1;
}
else
{
}
return Status;
}
NTSTATUS vboxWddmRegQueryVideoGuidString(PVBOXMP_DEVEXT pDevExt, ULONG cbBuf, PWCHAR pBuf, PULONG pcbResult)
{
NTSTATUS Status = IoOpenDeviceRegistryKey(pDevExt->pPDO, PLUGPLAY_REGKEY_DEVICE, GENERIC_READ, &hKey);
if (NT_SUCCESS(Status))
{
struct
{
} KeyData;
&RtlStr,
sizeof(KeyData),
&cbResult);
if (NT_SUCCESS(Status))
{
{
{
}
else
}
}
else
{
}
}
else
{
}
if (fNewMethodSucceeded)
return Status;
else
WARN(("failed to acquire the VideoID, falling back to the old impl"));
if (Status == STATUS_SUCCESS)
{
struct
{
} Buf;
{
/* we should not encounter STATUS_NO_MORE_ENTRIES here since this would mean we did not find our entry */
if (Status != STATUS_SUCCESS)
break;
memcpy(pSubBuf, VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY_SUBKEY, sizeof (VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY_SUBKEY));
if (Status == STATUS_SUCCESS)
{
struct
{
} KeyData;
&RtlStr,
sizeof(KeyData),
&cbResult);
if (Status == STATUS_SUCCESS)
{
{
{
{
{
}
else
{
}
}
}
}
}
}
else
break;
}
}
return Status;
}
NTSTATUS vboxWddmRegOpenKeyEx(OUT PHANDLE phKey, IN HANDLE hRootKey, IN PWCHAR pName, IN ACCESS_MASK fAccess)
{
InitializeObjectAttributes(&ObjAttr, &RtlStr, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, hRootKey, NULL);
}
{
}
NTSTATUS vboxWddmRegOpenDisplaySettingsKey(IN PVBOXMP_DEVEXT pDeviceExtension, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, OUT PHANDLE phKey)
{
NTSTATUS Status = vboxWddmRegQueryDisplaySettingsKeyName(pDeviceExtension, VidPnSourceId, cbBuf, Buf, &cbBuf);
if (Status == STATUS_SUCCESS)
{
if(Status == STATUS_SUCCESS)
return STATUS_SUCCESS;
}
/* fall-back to make the subsequent VBoxVideoCmnRegXxx calls treat the fail accordingly
* basically needed to make as less modifications to the current XPDM code as possible */
return Status;
}
{
NTSTATUS Status = vboxWddmRegQueryValueDword(hKey, VBOXWDDM_REG_DISPLAYSETTINGS_ATTACH_RELX, &dwVal);
if (Status == STATUS_SUCCESS)
{
}
return Status;
}
{
NTSTATUS Status = vboxWddmRegQueryValueDword(hKey, VBOXWDDM_REG_DISPLAYSETTINGS_ATTACH_RELY, &dwVal);
if (Status == STATUS_SUCCESS)
{
}
return Status;
}
NTSTATUS vboxWddmDisplaySettingsQueryPos(IN PVBOXMP_DEVEXT pDeviceExtension, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, POINT * pPos)
{
if (Status == STATUS_SUCCESS)
{
int x, y;
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
pPos->x = x;
pPos->y = y;
}
}
}
return Status;
}
{
NTSTATUS Status = IoOpenDeviceRegistryKey(pDevExt->pPDO, PLUGPLAY_REGKEY_DRIVER, GENERIC_WRITE, &hKey);
if (!NT_SUCCESS(Status))
{
return Status;
}
if (!NT_SUCCESS(Status))
return Status;
}
{
NTSTATUS Status = IoOpenDeviceRegistryKey(pDevExt->pPDO, PLUGPLAY_REGKEY_DRIVER, GENERIC_READ, &hKey);
if (!NT_SUCCESS(Status))
{
return fDefault;
}
if (!NT_SUCCESS(Status))
{
}
return dwVal;
}
{
struct
{
} Buf;
&RtlStr,
sizeof(Buf),
&cbBuf);
if (Status == STATUS_SUCCESS)
{
{
return STATUS_SUCCESS;
}
}
return STATUS_INVALID_PARAMETER;
}
{
NULL, /* IN ULONG TitleIndex OPTIONAL, reserved */
&val,
sizeof(val));
}
{
NTSTATUS Status = vboxWddmRegQueryVideoGuidString(pDevExt ,cbVideoGuidBuf, VideoGuidBuf, &cbVideoGuidBuf);
if (Status == STATUS_SUCCESS)
{
if (pBuf)
{
}
}
return NULL;
}
{
{
}
}
/* mm */
{
if (!pBuf)
{
Assert(0);
return STATUS_NO_MEMORY;
}
return STATUS_SUCCESS;
}
{
if (iPage == 0xFFFFFFFF)
{
Assert(0);
return VBOXWDDM_MM_VOID;
}
return iPage;
}
{
}
{
return STATUS_SUCCESS;
}
typedef struct VBOXVIDEOCM_ALLOC
{
typedef struct VBOXVIDEOCM_ALLOC_REF
{
{
if (iPage != VBOXWDDM_MM_VOID)
{
return STATUS_SUCCESS;
Assert(0);
}
else
{
Assert(0);
}
return Status;
}
{
}
NTSTATUS vboxVideoAMgrAllocCreate(PVBOXVIDEOCM_ALLOC_MGR pMgr, UINT cbSize, PVBOXVIDEOCM_ALLOC *ppAlloc)
{
if (pAlloc)
{
if (Status == STATUS_SUCCESS)
{
return STATUS_SUCCESS;
}
Assert(0);
}
else
{
Assert(0);
}
return Status;
}
{
}
NTSTATUS vboxVideoAMgrCtxAllocMap(PVBOXVIDEOCM_ALLOC_CONTEXT pContext, PVBOXVIDEOCM_ALLOC pAlloc, PVBOXVIDEOCM_UM_ALLOC pUmAlloc)
{
{
Status = ObReferenceObjectByHandle((HANDLE)pUmAlloc->hSynch, EVENT_MODIFY_STATE, *ExEventObjectType, UserMode,
(PVOID*)&pSynchEvent,
NULL);
}
if (Status == STATUS_SUCCESS)
{
PVBOXVIDEOCM_ALLOC_REF pAllocRef = (PVBOXVIDEOCM_ALLOC_REF)vboxWddmMemAllocZero(sizeof (*pAllocRef) + sizeof (PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(BaseVa, cbLength));
if (pAllocRef)
{
{
}
{
Assert(0);
}
if (Status == STATUS_SUCCESS)
{
NULL, /* PVOID BaseAddress */
FALSE, /* ULONG BugCheckOnFailure */
if (pvUm)
{
{
return STATUS_SUCCESS;
}
}
else
{
Assert(0);
}
}
}
else
{
Assert(0);
}
if (pSynchEvent)
}
else
{
Assert(0);
}
return Status;
}
NTSTATUS vboxVideoAMgrCtxAllocUnmap(PVBOXVIDEOCM_ALLOC_CONTEXT pContext, VBOXDISP_KMHANDLE hSesionHandle, PVBOXVIDEOCM_ALLOC *ppAlloc)
{
PVBOXVIDEOCM_ALLOC_REF pAllocRef = (PVBOXVIDEOCM_ALLOC_REF)vboxWddmHTableRemove(&pContext->AllocTable, hSesionHandle);
if (pAllocRef)
{
/* wait for the dereference, i.e. for all commands involving this allocation to complete */
if (pAllocRef->pSynchEvent)
}
else
{
Assert(0);
}
return Status;
}
static PVBOXVIDEOCM_ALLOC_REF vboxVideoAMgrCtxAllocRefAcquire(PVBOXVIDEOCM_ALLOC_CONTEXT pContext, VBOXDISP_KMHANDLE hSesionHandle)
{
PVBOXVIDEOCM_ALLOC_REF pAllocRef = (PVBOXVIDEOCM_ALLOC_REF)vboxWddmHTableGet(&pContext->AllocTable, hSesionHandle);
if (pAllocRef)
return pAllocRef;
}
{
Assert(cRefs >= 1); /* we do not do cleanup-on-zero here, instead we wait for the cRefs to reach 1 in vboxVideoAMgrCtxAllocUnmap before unmapping */
}
NTSTATUS vboxVideoAMgrCtxAllocCreate(PVBOXVIDEOCM_ALLOC_CONTEXT pContext, PVBOXVIDEOCM_UM_ALLOC pUmAlloc)
{
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
return STATUS_SUCCESS;
else
{
Assert(0);
}
}
else
{
Assert(0);
}
return Status;
}
NTSTATUS vboxVideoAMgrCtxAllocDestroy(PVBOXVIDEOCM_ALLOC_CONTEXT pContext, VBOXDISP_KMHANDLE hSesionHandle)
{
if (Status == STATUS_SUCCESS)
{
}
else
{
Assert(0);
}
return Status;
}
#ifdef VBOX_WITH_CRHGSMI
static DECLCALLBACK(VOID) vboxVideoAMgrAllocSubmitCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
{
/* we should be called from our DPC routine */
{
if (!pBufCmd->u32GuestData)
{
/* signal completion */
if (pRef->pSynchEvent)
}
}
}
/* submits a set of chromium uhgsmi buffers to host for processing */
NTSTATUS vboxVideoAMgrCtxAllocSubmit(PVBOXMP_DEVEXT pDevExt, PVBOXVIDEOCM_ALLOC_CONTEXT pContext, UINT cBuffers, VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE *paBuffers)
{
/* ensure we do not overflow the 32bit buffer size value */
{
WARN(("number of buffers passed too big (%d), max is (%d)", cBuffers, VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(VBOXVDMACMD_CHROMIUM_CMD, aBuffers)));
return STATUS_INVALID_PARAMETER;
}
UINT cbCmd = VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[cBuffers]));
if (pDr)
{
// vboxVdmaCBufDrCreate zero initializes the pDr
pHdr->u32CmdSpecific = 0;
{
if (pRef)
{
#ifdef DEBUG_misha
#endif
pBufCmd->u32GuestData = 0;
}
else
{
/* release all previously acquired aloc references */
for (UINT j = 0; j < i; ++j)
{
}
break;
}
}
if (Status == STATUS_SUCCESS)
{
/* mark command as submitted & invisible for the dx runtime since dx did not originate it */
if (RT_SUCCESS(rc))
{
return STATUS_SUCCESS;
}
/* failure branch */
/* release all previously acquired aloc references */
{
}
}
}
else
{
Assert(0);
/* @todo: try flushing.. */
LOGREL(("vboxVdmaCBufDrCreate returned NULL"));
}
return Status;
}
#endif
NTSTATUS vboxVideoAMgrCreate(PVBOXMP_DEVEXT pDevExt, PVBOXVIDEOCM_ALLOC_MGR pMgr, uint32_t offData, uint32_t cbData)
{
if (!cbData)
return STATUS_INVALID_PARAMETER;
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
PHYSICAL_ADDRESS PhysicalAddress = {0};
{
return STATUS_SUCCESS;
}
else
{
}
}
}
return Status;
}
{
return STATUS_SUCCESS;
}
{
{
if (Status == STATUS_SUCCESS)
{
return STATUS_SUCCESS;
}
}
return Status;
}
{
return STATUS_SUCCESS;
do
{
if (!pRef)
break;
Assert(0);
if (Status != STATUS_SUCCESS)
break;
// vboxWddmHTableIterRemoveCur(&Iter);
} while (1);
if (Status == STATUS_SUCCESS)
{
}
return Status;
}
{
}
{
{
}
}
/* dump user-mode driver debug info */
static char g_aVBoxUmdD3DCAPS9[304];
{
{
}
switch (cData)
{
case 3:
break;
case 2:
break;
case 1:
break;
default:
break;
}
}
{
LOGREL(("*****Start Dumping D3DCAPS9:*******"));
LOGREL(("*****End Dumping D3DCAPS9**********"));
}
{
{
WARN(("Buffer too small"));
return STATUS_BUFFER_TOO_SMALL;
}
{
{
if (cbString != sizeof (g_aVBoxUmdD3DCAPS9))
{
break;
}
{
break;
WARN(("caps do not match!"));
break;
}
}
}
return Status;
}
#if 0
{
}
{
}
{
if (!hSharedRc)
{
WARN(("invalid call with zero shared handle!"));
return FALSE;
}
}
#define PVBOXWDDM_ALLOCATION_FROM_SHRCTREENODE(_p) ((PVBOXWDDM_ALLOCATION)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXWDDM_ALLOCATION, ShRcTreeEntry)))
{
if (!pNode)
return NULL;
return pAlloc;
}
{
if (!hSharedRc)
{
WARN(("invalid call with zero shared handle!"));
return FALSE;
}
if (!pNode)
return NULL;
return !!pRetAlloc;
}
#endif
{
InitializeObjectAttributes(&ObjAttr, pRegStr, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
if (!NT_SUCCESS(Status))
{
return Status;
}
if (NT_SUCCESS(Status))
return Status;
}
NTSTATUS vboxWddmThreadCreate(PKTHREAD * ppThread, PKSTART_ROUTINE pStartRoutine, PVOID pStartContext)
{
if (!NT_SUCCESS(fStatus))
return fStatus;
return STATUS_SUCCESS;
}
#ifdef VBOX_VDMA_WITH_WATCHDOG
{
int rc = VINF_SUCCESS;
PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
if (pCmd)
{
const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pCmd);
if (pHdr)
{
do
{
HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pHdr);
if (offCmd != HGSMIOFFSET_VOID)
{
if (RT_SUCCESS(rc))
{
}
break;
}
else
/* fail to submit, cancel it */
} while (0);
}
}
else
{
LOGREL(("HGSMIHeapAlloc failed"));
}
return rc;
}
/* if null g_VBoxWdTimeout / 2 is used */
static uint32_t g_VBoxWdTimerPeriod = 0;
{
int rc;
while (1)
{
if (!bExit)
{
}
else
{
break;
}
if (Status != STATUS_TIMEOUT)
}
}
{
if (!NT_SUCCESS(Status))
{
}
return Status;
}
{
return STATUS_SUCCESS;
return STATUS_SUCCESS;
}
#endif
{
int rc = VINF_SUCCESS;
/* Allocate the IO buffer. */
sizeof (VBVASCANLINECFG), HGSMI_CH_VBVA,
if (pCfg)
{
/* Prepare data to be sent to the host. */
if (RT_SUCCESS(rc))
{
}
/* Free the IO buffer. */
}
else
rc = VERR_NO_MEMORY;
return rc;
}
{
return STATUS_SUCCESS;
if (!fEnable)
{
}
else
{
}
return STATUS_SUCCESS;
}
{
if (pTarget->HeightTotal)
{
{
WARN(("vsync time is less than the one stored in device"));
curScanLine = 0;
}
else
{
/* time is in 100ns, */
if (pDevExt->bVSyncTimerEnabled)
{
curScanLine = 0;
}
else
{
}
}
}
else
{
pGetScanLine->ScanLine = 0;
}
return STATUS_SUCCESS;
}
{
{
if (pTarget->fConnected)
{
pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, ¬ify);
}
}
if (bNeedDpc)
{
}
return FALSE;
}
static VOID vboxWddmSlVSyncDpc(
)
{
0, /* IN ULONG MessageNumber */
&bDummy);
if (!NT_SUCCESS(Status))
}
{
pDevExt->fVSyncInVBlank = 0;
return STATUS_SUCCESS;
}
{
return STATUS_SUCCESS;
}
#ifdef VBOX_WDDM_WIN8
void vboxWddmDiInitDefault(DXGK_DISPLAY_INFORMATION *pInfo, PHYSICAL_ADDRESS PhAddr, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
{
}
void vboxWddmDiToAllocData(PVBOXMP_DEVEXT pDevExt, const DXGK_DISPLAY_INFORMATION *pInfo, PVBOXWDDM_ALLOC_DATA pAllocData)
{
/* the address here is not a VRAM offset! so convert it to offset */
}
void vboxWddmDmAdjustDefaultVramLocations(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId)
{
for (UINT i = ModifiedVidPnSourceId + 1; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
{
/* increaze the phaddr based on the previous source size info */
}
}
#endif