VBoxMPWddm.cpp revision 359416647a711739d1b14addbf399178949a1a60
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * VBox WDDM Miniport driver
c7814cf6e1240a519cbec0441e033d0e2470ed00vboxsync * Copyright (C) 2011-2013 Oracle Corporation
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * available from http://www.virtualbox.org. This file is free software;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * you can redistribute it and/or modify it under the terms of the GNU
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * General Public License (GPL) as published by the Free Software
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#include <wingdi.h> /* needed for RGNDATA definition */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#include <VBoxDisplay.h> /* this is from Additions/WINNT/include/ to include escape codes */
384478d3896257fbce9ceb8c01e74040b969e6d7vboxsync#define VBOXWDDM_DUMMY_DMABUFFER_SIZE (sizeof (VBOXCMDVBVA_HDR) / 2)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return ExAllocatePoolWithTag(NonPagedPool, cbSize, VBOXWDDM_MEMTAG);
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsyncDECLINLINE(void) VBoxWddmOaHostIDReleaseLocked(PVBOXWDDM_OPENALLOCATION pOa)
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync PVBOXWDDM_ALLOCATION pAllocation = pOa->pAllocation;
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync Assert(pAllocation->AllocData.cHostIDRefs >= pOa->cHostIDRefs);
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsyncDECLINLINE(void) VBoxWddmOaHostIDCheckReleaseLocked(PVBOXWDDM_OPENALLOCATION pOa)
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsyncDECLINLINE(void) VBoxWddmOaRelease(PVBOXWDDM_OPENALLOCATION pOa)
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync PVBOXWDDM_ALLOCATION pAllocation = pOa->pAllocation;
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync KeAcquireSpinLock(&pAllocation->OpenLock, &OldIrql);
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsyncDECLINLINE(PVBOXWDDM_OPENALLOCATION) VBoxWddmOaSearchLocked(PVBOXWDDM_DEVICE pDevice, PVBOXWDDM_ALLOCATION pAllocation)
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync for (PLIST_ENTRY pCur = pAllocation->OpenList.Flink; pCur != &pAllocation->OpenList; pCur = pCur->Flink)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_OPENALLOCATION pCurOa = CONTAINING_RECORD(pCur, VBOXWDDM_OPENALLOCATION, ListEntry);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsyncDECLINLINE(PVBOXWDDM_OPENALLOCATION) VBoxWddmOaSearch(PVBOXWDDM_DEVICE pDevice, PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync KeAcquireSpinLock(&pAllocation->OpenLock, &OldIrql);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pOa = VBoxWddmOaSearchLocked(pDevice, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(int) VBoxWddmOaSetHostID(PVBOXWDDM_DEVICE pDevice, PVBOXWDDM_ALLOCATION pAllocation, uint32_t hostID, uint32_t *pHostID)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync KeAcquireSpinLock(&pAllocation->OpenLock, &OldIrql);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pOa = VBoxWddmOaSearchLocked(pDevice, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("hostID differ: alloc(%d), trying to assign(%d)", pAllocation->AllocData.hostID, hostID));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromHandle(PVBOXMP_DEVEXT pDevExt, D3DKMT_HANDLE hAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return (PVBOXWDDM_ALLOCATION)pDevExt->u.primary.DxgkInterface.DxgkCbGetHandleData(&GhData);
6902a98267d5180fb081cb5273751d0a628bf04dvboxsyncDECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromAllocList(PVBOXMP_DEVEXT pDevExt, DXGK_ALLOCATIONLIST *pAllocList)
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync PVBOXWDDM_OPENALLOCATION pOa = (PVBOXWDDM_OPENALLOCATION)pAllocList->hDeviceSpecificAllocation;
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsyncstatic void vboxWddmPopulateDmaAllocInfo(PVBOXWDDM_DMA_ALLOCINFO pInfo, PVBOXWDDM_ALLOCATION pAlloc, DXGK_ALLOCATIONLIST *pDmaAlloc)
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync pInfo->offAlloc = (VBOXVIDEOOFFSET)pDmaAlloc->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pInfo->srcId = pAlloc->AllocData.SurfDesc.VidPnSourceId;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsyncstatic void vboxWddmPopulateDmaAllocInfoWithOffset(PVBOXWDDM_DMA_ALLOCINFO pInfo, PVBOXWDDM_ALLOCATION pAlloc, DXGK_ALLOCATIONLIST *pDmaAlloc, uint32_t offStart)
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pInfo->offAlloc = (VBOXVIDEOOFFSET)pDmaAlloc->PhysicalAddress.QuadPart + offStart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pInfo->srcId = pAlloc->AllocData.SurfDesc.VidPnSourceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncint vboxWddmGhDisplayPostInfoScreen(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync void *p = VBoxHGSMIBufferAlloc (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = vboxWddmScreenInfoInit(pScreen, pAllocData, pVScreenPos, fFlags);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pScreen->u32StartOffset = 0; //(uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
6902a98267d5180fb081cb5273751d0a628bf04dvboxsync VBoxHGSMIBufferFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncint vboxWddmGhDisplayPostInfoView(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData)
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync VBOXVIDEOOFFSET offVram = vboxWddmAddrFramOffset(&pAllocData->Addr);
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync /* Issue the screen info command. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync void *p = VBoxHGSMIBufferAlloc (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pView->u32ViewIndex = pAllocData->SurfDesc.VidPnSourceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pView->u32ViewOffset = (uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pView->u32ViewSize = vboxWddmVramCpuVisibleSegmentSize(pDevExt)/VBoxCommonFromDeviceExt(pDevExt)->cDisplays;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
0593640ab087e5bf747a2576b1752a2046be83aavboxsync VBoxHGSMIBufferFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmGhDisplayPostResizeLegacy(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = vboxWddmGhDisplayPostInfoView(pDevExt, pAllocData);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxWddmGhDisplayPostInfoView failed %d", rc));
41fcf8465b641c7083d3b440451f17c1210fce33vboxsync rc = vboxWddmGhDisplayPostInfoScreen(pDevExt, pAllocData, pVScreenPos, fFlags);
41fcf8465b641c7083d3b440451f17c1210fce33vboxsync WARN(("vboxWddmGhDisplayPostInfoScreen failed %d", rc));
9c21eebec4d70f1e638002c8dfc6ea9d534d8710vboxsyncNTSTATUS vboxWddmGhDisplayPostResizeNew(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint16_t fFlags)
9c21eebec4d70f1e638002c8dfc6ea9d534d8710vboxsync int rc = VBoxCmdVbvaConCmdResize(pDevExt, pAllocData, pTargetMap, pVScreenPos, fFlags);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmGhDisplaySetMode(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVIDEOOFFSET offVram = vboxWddmAddrFramOffset(&pAllocData->Addr);;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync ULONG cbLine = VBOXWDDM_ROUNDBOUND(((width * bpp) + 7) / 8, 4);
4ecd4ad59281328476ad14f2baa51716b6f5f804vboxsync VBoxVideoSetModeRegisters(width, height, width, bpp, 0, (uint16_t)xOffset, (uint16_t)yOffset);
4ecd4ad59281328476ad14f2baa51716b6f5f804vboxsync /*@todo read back from port to check if mode switch was successful */
4ecd4ad59281328476ad14f2baa51716b6f5f804vboxsyncNTSTATUS vboxWddmGhDisplaySetInfoLegacy(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint8_t u8CurCyncState)
329df9696e709dc71611f504a4774f323545be0avboxsync uint16_t fu16Flags = fEnabled ? VBVA_SCREEN_F_ACTIVE : VBVA_SCREEN_F_DISABLED;
329df9696e709dc71611f504a4774f323545be0avboxsync if ((u8CurCyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) == VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY
329df9696e709dc71611f504a4774f323545be0avboxsync Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData);
329df9696e709dc71611f504a4774f323545be0avboxsync WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
329df9696e709dc71611f504a4774f323545be0avboxsync Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData);
329df9696e709dc71611f504a4774f323545be0avboxsync Status = vboxWddmGhDisplayPostResizeLegacy(pDevExt, pAllocData, pVScreenPos,
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
09f4b412099acda62997fd82c8608075c453b3ebvboxsync WARN(("vboxWddmGhDisplayPostResize failed, Status 0x%x", Status));
09f4b412099acda62997fd82c8608075c453b3ebvboxsync WARN(("vboxWddmGhDisplaySetMode failed, Status 0x%x", Status));
09f4b412099acda62997fd82c8608075c453b3ebvboxsyncNTSTATUS vboxWddmGhDisplaySetInfoNew(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint8_t u8CurCyncState)
09f4b412099acda62997fd82c8608075c453b3ebvboxsync uint16_t fu16Flags = fEnabled ? VBVA_SCREEN_F_ACTIVE : VBVA_SCREEN_F_DISABLED;
09f4b412099acda62997fd82c8608075c453b3ebvboxsync if ((u8CurCyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) == VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData);
09f4b412099acda62997fd82c8608075c453b3ebvboxsync WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData);
4ecd4ad59281328476ad14f2baa51716b6f5f804vboxsync Status = vboxWddmGhDisplayPostResizeNew(pDevExt, pAllocData, pTargetMap, pVScreenPos, fu16Flags);
09f4b412099acda62997fd82c8608075c453b3ebvboxsync Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData);
09f4b412099acda62997fd82c8608075c453b3ebvboxsync WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
09f4b412099acda62997fd82c8608075c453b3ebvboxsync WARN(("vboxWddmGhDisplayPostResizeNew failed, Status 0x%x", Status));
09f4b412099acda62997fd82c8608075c453b3ebvboxsync WARN(("vboxWddmGhDisplaySetMode failed, Status 0x%x", Status));
09f4b412099acda62997fd82c8608075c453b3ebvboxsyncbool vboxWddmGhDisplayCheckSetInfoFromSourceNew(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, bool fReportTargets)
09f4b412099acda62997fd82c8608075c453b3ebvboxsync if (pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL)
09f4b412099acda62997fd82c8608075c453b3ebvboxsync pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY;
09f4b412099acda62997fd82c8608075c453b3ebvboxsync return false;
09f4b412099acda62997fd82c8608075c453b3ebvboxsync return false;
4ecd4ad59281328476ad14f2baa51716b6f5f804vboxsync NTSTATUS Status = vboxWddmGhDisplaySetInfoNew(pDevExt, &pSource->AllocData, pTargetMap, &pSource->VScreenPos, pSource->u8SyncState);
09f4b412099acda62997fd82c8608075c453b3ebvboxsync if (fReportTargets && (pSource->u8SyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) != VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVidPnStTIterInit(pSource, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays, &Iter);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSource->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return true;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxWddmGhDisplaySetInfoNew failed, Status (0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncbool vboxWddmGhDisplayCheckSetInfoFromSourceLegacy(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, bool fReportTargets)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL)
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync return false;
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVidPnStTIterInit(pSource, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays, &Iter);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint8_t u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync VBOXWDDM_ALLOC_DATA AllocData = pSource->AllocData;
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter);
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync NTSTATUS Status = vboxWddmGhDisplaySetInfoLegacy(pDevExt, &AllocData, &pSource->VScreenPos, pSource->u8SyncState | pTarget->u8SyncState);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync WARN(("vboxWddmGhDisplaySetInfoLegacy failed, Status (0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return true;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncbool vboxWddmGhDisplayCheckSetInfoFromSourceEx(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, bool fReportTargets)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return vboxWddmGhDisplayCheckSetInfoFromSourceNew(pDevExt, pSource, fReportTargets);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return vboxWddmGhDisplayCheckSetInfoFromSourceLegacy(pDevExt, pSource, fReportTargets);
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsyncbool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bool fReportTargets = !pDevExt->cContextsDispIfResize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return vboxWddmGhDisplayCheckSetInfoFromSourceEx(pDevExt, pSource, fReportTargets);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncbool vboxWddmGhDisplayCheckSetInfoForDisabledTargetsNew(PVBOXMP_DEVEXT pDevExt)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bool fFound = false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pTarget->VidPnSourceId != D3DDDI_ID_UNINITIALIZED)
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync if (pTarget->u8SyncState != VBOXWDDM_HGSYNC_F_SYNCED_ALL)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVidPnAllocDataInit(&AllocData, D3DDDI_ID_UNINITIALIZED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxWddmGhDisplaySetInfoNew(pDevExt, &AllocData, aTargetMap, &VScreenPos, 0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxWddmGhDisplaySetInfoNew failed %#x", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pTarget->VidPnSourceId != D3DDDI_ID_UNINITIALIZED)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return true;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncbool vboxWddmGhDisplayCheckSetInfoForDisabledTargetsLegacy(PVBOXMP_DEVEXT pDevExt)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bool fFound = false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVidPnAllocDataInit(&AllocData, D3DDDI_ID_UNINITIALIZED);
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pTarget->VidPnSourceId != D3DDDI_ID_UNINITIALIZED)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pTarget->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxWddmGhDisplaySetInfoLegacy(pDevExt, &AllocData, &VScreenPos, 0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxWddmGhDisplaySetInfoLegacy failed, Status (0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncvoid vboxWddmGhDisplayCheckSetInfoForDisabledTargets(PVBOXMP_DEVEXT pDevExt)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmGhDisplayCheckSetInfoForDisabledTargetsNew(pDevExt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmGhDisplayCheckSetInfoForDisabledTargetsLegacy(pDevExt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncvoid vboxWddmGhDisplayCheckSetInfoForDisabledTargetsCheck(PVBOXMP_DEVEXT pDevExt)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bool fReportTargets = !pDevExt->cContextsDispIfResize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmGhDisplayCheckSetInfoForDisabledTargets(pDevExt);
105b1a31b6037dbe14acb8d09e60da540885202bvboxsyncvoid vboxWddmGhDisplayCheckSetInfoEx(PVBOXMP_DEVEXT pDevExt, bool fReportTargets)
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmGhDisplayCheckSetInfoFromSourceEx(pDevExt, pSource, fReportTargets);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmGhDisplayCheckSetInfoForDisabledTargets(pDevExt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncvoid vboxWddmGhDisplayCheckSetInfo(PVBOXMP_DEVEXT pDevExt)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bool fReportTargets = !pDevExt->cContextsDispIfResize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmGhDisplayCheckSetInfoEx(pDevExt, fReportTargets);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncPVBOXSHGSMI vboxWddmHgsmiGetHeapFromCmdOffset(PVBOXMP_DEVEXT pDevExt, HGSMIOFFSET offCmd)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if(HGSMIAreaContainsOffset(&pDevExt->u.primary.Vdma.CmdHeap.Heap.area, offCmd))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (HGSMIAreaContainsOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, offCmd))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return &VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsynctypedef enum
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncVBOXWDDM_HGSMICMD_TYPE vboxWddmHgsmiGetCmdTypeFromOffset(PVBOXMP_DEVEXT pDevExt, HGSMIOFFSET offCmd)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if(HGSMIAreaContainsOffset(&pDevExt->u.primary.Vdma.CmdHeap.Heap.area, offCmd))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (HGSMIAreaContainsOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, offCmd))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmPickResources(PVBOXMP_DEVEXT pDevExt, PDXGK_DEVICE_INFO pDeviceInfo, PVBOXWDDM_HWRESOURCES pHwResources)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pHwResources->cbVRAM = VBE_DISPI_TOTAL_VIDEO_MEMORY_BYTES;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVideoCmnPortWriteUshort(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_ID);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVideoCmnPortWriteUshort(VBE_DISPI_IOPORT_DATA, VBE_DISPI_ID2);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DispiId = VBoxVideoCmnPortReadUshort(VBE_DISPI_IOPORT_DATA);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Write some hardware information to registry, so that
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * it's visible in Windows property dialog.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Query the adapter's memory size. It's a bit of a hack, we just read
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * an ULONG from the data port without setting an index before.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pHwResources->cbVRAM = VBoxVideoCmnPortReadUlong(VBE_DISPI_IOPORT_DATA);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PCM_RESOURCE_LIST pRcList = pDeviceInfo->TranslatedResourceList;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: verify resources */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PCM_FULL_RESOURCE_DESCRIPTOR pFRc = &pRcList->List[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (ULONG j = 0; j < pFRc->PartialResourceList.Count; ++j)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PCM_PARTIAL_RESOURCE_DESCRIPTOR pPRc = &pFRc->PartialResourceList.PartialDescriptors[j];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we assume there is one memory segment */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pHwResources->ulApertureSize = pPRc->u.Memory.Length;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pHwResources->cbVRAM <= pHwResources->ulApertureSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: report a better status */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void vboxWddmDevExtZeroinit(PVBOXMP_DEVEXT pDevExt, CONST PDEVICE_OBJECT pPDO)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PWCHAR pName = (PWCHAR)(((uint8_t*)pDevExt) + VBOXWDDM_ROUNDBOUND(sizeof(VBOXMP_DEVEXT), 8));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVidPnSourcesInit(pDevExt->aSources, RT_ELEMENTS(pDevExt->aSources));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVidPnTargetsInit(pDevExt->aTargets, RT_ELEMENTS(pDevExt->aTargets));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void vboxWddmSetupDisplaysLegacy(PVBOXMP_DEVEXT pDevExt)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* For WDDM, we simply store the number of monitors as we will deal with
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * VidPN stuff later */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ULONG ulAvailable = VBoxCommonFromDeviceExt(pDevExt)->cbVRAM
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* Align down to 4096 bytes. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = vboxVdmaCreate (pDevExt, &pDevExt->u.primary.Vdma
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* can enable it right away since the host does not need any screen/FB info
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * for basic DMA functionality */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = vboxVdmaEnable(pDevExt, &pDevExt->u.primary.Vdma);
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync vboxVdmaDestroy(pDevExt, &pDevExt->u.primary.Vdma);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxVideoAMgrCreate(pDevExt, &pDevExt->AllocMgr, offset, ulSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ulSize /= VBoxCommonFromDeviceExt(pDevExt)->cDisplays;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* todo: ?? */
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync Assert(ulSize * VBoxCommonFromDeviceExt(pDevExt)->cDisplays < ulAvailable);
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync for (int i = VBoxCommonFromDeviceExt(pDevExt)->cDisplays-1; i >= 0; --i)
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync rc = vboxVbvaCreate(pDevExt, &pDevExt->aSources[i].Vbva, offset, ulSize, i);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = vboxVbvaEnable(pDevExt, &pDevExt->aSources[i].Vbva);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync /* @todo: de-initialize */
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync rc = VBoxMPCmnMapAdapterMemory(VBoxCommonFromDeviceExt(pDevExt), (void**)&pDevExt->pvVisibleVram,
9c21eebec4d70f1e638002c8dfc6ea9d534d8710vboxsyncstatic NTSTATUS vboxWddmSetupDisplaysNew(PVBOXMP_DEVEXT pDevExt)
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync ULONG cbAvailable = VBoxCommonFromDeviceExt(pDevExt)->cbVRAM
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync ULONG cbCmdVbvaApprox = VBOXCMDVBVA_BUFFERSIZE(4096);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync WARN(("too few VRAM memory %d, cmdVbva %d, while approximately needed %d, trying to adjust", cbAvailable, cbCmdVbva, cbCmdVbvaApprox));
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync cbCmdVbva = VBOXWDDM_ROUNDBOUND(cbCmdVbva, 0x1000);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync WARN(("too few VRAM memory fatal, %d, requested for CmdVbva %d", cbAvailable, cbCmdVbva));
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync int rc = VBoxCmdVbvaCreate(pDevExt, &pDevExt->CmdVbva, offCmdVbva, cbCmdVbva);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync rc = VBoxCmdVbvaEnable(pDevExt, &pDevExt->CmdVbva);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync rc = VBoxMPCmnMapAdapterMemory(VBoxCommonFromDeviceExt(pDevExt), (void**)&pDevExt->pvVisibleVram,
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync WARN(("VBoxMPCmnMapAdapterMemory failed, rc %d", rc));
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsyncstatic NTSTATUS vboxWddmSetupDisplays(PVBOXMP_DEVEXT pDevExt)
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync NTSTATUS Status = vboxWddmSetupDisplaysNew(pDevExt);
6b2a50fc09aa4f7ce2082284f082d97a2c738321vboxsync return VBoxCommonFromDeviceExt(pDevExt)->bHGSMI ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsyncstatic int vboxWddmFreeDisplays(PVBOXMP_DEVEXT pDevExt)
5159c4c6485473c77871b515c15b59c3caa60b46vboxsync VBoxMPCmnUnmapAdapterMemory(VBoxCommonFromDeviceExt(pDevExt), (void**)&pDevExt->pvVisibleVram);
5159c4c6485473c77871b515c15b59c3caa60b46vboxsync for (int i = VBoxCommonFromDeviceExt(pDevExt)->cDisplays-1; i >= 0; --i)
5159c4c6485473c77871b515c15b59c3caa60b46vboxsync rc = vboxVbvaDisable(pDevExt, &pDevExt->aSources[i].Vbva);
5159c4c6485473c77871b515c15b59c3caa60b46vboxsync rc = vboxVbvaDestroy(pDevExt, &pDevExt->aSources[i].Vbva);
5159c4c6485473c77871b515c15b59c3caa60b46vboxsync /* @todo: */
5159c4c6485473c77871b515c15b59c3caa60b46vboxsync rc = vboxVdmaDisable(pDevExt, &pDevExt->u.primary.Vdma);
6b2a50fc09aa4f7ce2082284f082d97a2c738321vboxsync rc = vboxVdmaDestroy(pDevExt, &pDevExt->u.primary.Vdma);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* driver callbacks */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiAddDevice function should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = IoGetDeviceProperty (PhysicalDeviceObject,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt = (PVBOXMP_DEVEXT)vboxWddmMemAllocZero(VBOXWDDM_ROUNDBOUND(sizeof(VBOXMP_DEVEXT), 8) + cbRegKeyBuf);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PWCHAR pName = (PWCHAR)(((uint8_t*)pDevExt) + VBOXWDDM_ROUNDBOUND(sizeof(VBOXMP_DEVEXT), 8));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmDevExtZeroinit(pDevExt, PhysicalDeviceObject);
67b8a5a52c43a79ea7e159dbbeec99687fb9cd3bvboxsync LOGF(("LEAVE, Status(0x%x), pDevExt(0x%x)", Status, pDevExt));
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync /* The DxgkDdiStartDevice function should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* Save DeviceHandle and function pointers supplied by the DXGKRNL_INTERFACE structure passed to DxgkInterface. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(&pDevExt->u.primary.DxgkInterface, DxgkInterface, sizeof (DXGKRNL_INTERFACE));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* Allocate a DXGK_DEVICE_INFO structure, and call DxgkCbGetDeviceInformation to fill in the members of that structure, which include the registry path, the PDO, and a list of translated resources for the display adapter represented by MiniportDeviceContext. Save selected members (ones that the display miniport driver will need later)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * of the DXGK_DEVICE_INFO structure in the context block represented by MiniportDeviceContext. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = pDevExt->u.primary.DxgkInterface.DxgkCbGetDeviceInformation (pDevExt->u.primary.DxgkInterface.DeviceHandle, &DeviceInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmPickResources(pDevExt, &DeviceInfo, &HwRc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->f3DEnabled = VBoxMpCrCtlConIs3DSupported();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->fTexPresentEnabled = !!(VBoxMpCrGetHostCaps() & CR_VBOX_CAP_TEX_PRESENT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->fCmdVbvaEnabled = !!(VBoxMpCrGetHostCaps() & CR_VBOX_CAP_CMDVBVA);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* Guest supports only HGSMI, the old VBVA via VMMDev is not supported.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * The host will however support both old and new interface to keep compatibility
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * with old guest additions.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxSetupDisplaysHGSMI(VBoxCommonFromDeviceExt(pDevExt),
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxFreeDisplaysHGSMI(VBoxCommonFromDeviceExt(pDevExt));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync *NumberOfVideoPresentSources = VBoxCommonFromDeviceExt(pDevExt)->cDisplays;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync *NumberOfChildren = VBoxCommonFromDeviceExt(pDevExt)->cDisplays;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOG(("sources(%d), children(%d)", *NumberOfVideoPresentSources, *NumberOfChildren));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxCommonFromDeviceExt(pDevExt)->fAnyX = VBoxVideoAnyWidthAllowed();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxMpCrShgsmiTransportCreate(&pDevExt->CrHgsmiTransport, pDevExt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = IoOpenDeviceRegistryKey(pDevExt->pPDO, PLUGPLAY_REGKEY_DRIVER, GENERIC_READ, &hKey);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("IoOpenDeviceRegistryKey failed, Status = 0x%x", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmRegQueryValueDword(hKey, VBOXWDDM_REG_DRV_FLAGS_NAME, &dwVal);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOG(("vboxWddmRegQueryValueDword failed, Status = 0x%x", Status));
e6ad2e18e663b076aeabfec994947514566a7accvboxsync for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (i == 0 || (pDevExt->dwDrvCfgFlags & VBOXWDDM_CFG_DRV_SECONDARY_TARGETS_CONNECTED) || !hKey)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync swprintf(aNameBuf, L"%s%d", VBOXWDDM_REG_DRV_DISPFLAGS_PREFIX, i);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmRegQueryValueDword(hKey, aNameBuf, &dwVal);
3ea1dbf096240fc221aea99352a74c17a367a9b6vboxsync pTarget->fConnected = !!(dwVal & VBOXWDDM_CFG_DRVTARGET_CONNECTED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxWddmRegQueryValueDword failed, Status = 0x%x", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = pDevExt->u.primary.DxgkInterface.DxgkCbAcquirePostDisplayOwnership(pDevExt->u.primary.DxgkInterface.DeviceHandle,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* display info may sometimes not be valid, e.g. on from-full-graphics wddm driver update
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * ensure we have something meaningful here */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmDiToAllocData(pDevExt, &DisplayInfo, &pSource->AllocData);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* init the rest source infos with some default values */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 1; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PhAddr.QuadPart += pSource->AllocData.SurfDesc.cbSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmDiToAllocData(pDevExt, &DisplayInfo, &pSource->AllocData);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("DxgkCbAcquirePostDisplayOwnership failed, Status 0x%x", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("HGSMI failed to initialize, returning err"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: report a better status */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("vboxWddmPickResources failed Status(0x%x), returning err", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("DxgkCbGetDeviceInformation failed Status(0x%x), returning err", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiStopDevice function should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, context(0x%p)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync VBoxMpCrShgsmiTransportTerm(&pDevExt->CrHgsmiTransport);
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync /* do everything we did on DxgkDdiStartDevice in the reverse order */
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync VBoxFreeDisplaysHGSMI(VBoxCommonFromDeviceExt(pDevExt));
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync /* revert back to the state we were right after the DxgkDdiAddDevice */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiRemoveDevice should be made pageable. */
c58dc77ef4af214d7ae06910fa5ab18587d2ae08vboxsync LOGF(("ENTER, context(0x%p)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, context(0x%p)", MiniportDeviceContext));
e6ad2e18e663b076aeabfec994947514566a7accvboxsync LOGF(("ENTER, context(0x%p), ctl(0x%x)", MiniportDeviceContext, VideoRequestPacket->IoControlCode));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (VideoRequestPacket->OutputBufferLength < sizeof(VIDEO_COLOR_CAPABILITIES))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VideoRequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
e6ad2e18e663b076aeabfec994947514566a7accvboxsync VIDEO_COLOR_CAPABILITIES *pCaps = (VIDEO_COLOR_CAPABILITIES*)VideoRequestPacket->OutputBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VideoRequestPacket->StatusBlock->Status = NO_ERROR;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VideoRequestPacket->StatusBlock->Information = sizeof (VIDEO_COLOR_CAPABILITIES);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (VideoRequestPacket->OutputBufferLength < sizeof(VIDEOPARAMETERS)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync || VideoRequestPacket->InputBufferLength < sizeof(VIDEOPARAMETERS))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VideoRequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Result = VBoxVideoResetDevice((PVBOXMP_DEVEXT)HwDeviceExtension,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VideoRequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
e6ad2e18e663b076aeabfec994947514566a7accvboxsync LOGF(("LEAVE, context(0x%p), ctl(0x%x)", MiniportDeviceContext, VideoRequestPacket->IoControlCode));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, context(0x%p), msg(0x%x)", MiniportDeviceContext, MessageNumber));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags) /* If HGSMI is enabled at all. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t flags = VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags->u32HostFlags;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxHGSMIClearIrq(&VBoxCommonFromDeviceExt(pDevExt)->hostCtx);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync bNeedDpc |= VBoxCmdVbvaCheckCompletedIrq(pDevExt, &pDevExt->CmdVbva);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* read the command offset */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HGSMIOFFSET offCmd = VBoxVideoCmnPortReadUlong(VBoxCommonFromDeviceExt(pDevExt)->guestCtx.port);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint8_t *pvCmd = HGSMIBufferDataAndChInfoFromOffset (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, offCmd, &chInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = VBoxSHGSMICommandProcessCompletion (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, (VBOXSHGSMIHEADER*)pvCmd, TRUE /*bool bIrq*/ , &CtlList);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync vboxVhwaPutList(&VhwaCmdList, (VBOXVHWACMD*)pvCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#endif /* # ifdef VBOX_WITH_VIDEOHWACCEL */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: FIXME: implement !!! */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync flags = VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags->u32HostFlags;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (1);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ASMAtomicWriteU32(&pDevExt->fCompletingCommands, 1);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVtListCat(&pDevExt->VhwaCmdList, &VhwaCmdList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ASMAtomicWriteU32(&pDevExt->fCompletingCommands, 1);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bNeedDpc |= !vboxVdmaDdiCmdIsCompletedListEmptyIsr(pDevExt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(¬ify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, ¬ify);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, context(0x%p), msg(0x%x)", MiniportDeviceContext, MessageNumber));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags) /* If HGSMI is enabled at all. */
441b60f8b0601cc1718368c9c3ef082223ad12a2vboxsync uint32_t flags = VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags->u32HostFlags;
441b60f8b0601cc1718368c9c3ef082223ad12a2vboxsync VBoxHGSMIClearIrq(&VBoxCommonFromDeviceExt(pDevExt)->hostCtx);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* read the command offset */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HGSMIOFFSET offCmd = VBoxVideoCmnPortReadUlong(VBoxCommonFromDeviceExt(pDevExt)->guestCtx.port);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_HGSMICMD_TYPE enmType = vboxWddmHgsmiGetCmdTypeFromOffset(pDevExt, offCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pHeap = &VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint8_t *pvCmd = HGSMIBufferDataAndChInfoFromOffset (&pHeap->Heap.area, offCmd, &chInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = VBoxSHGSMICommandProcessCompletion (pHeap, (VBOXSHGSMIHEADER*)pvCmd, TRUE /*bool bIrq*/ , pList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVhwaPutList(&VhwaCmdList, (VBOXVHWACMD*)pvCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#endif /* # ifdef VBOX_WITH_VIDEOHWACCEL */
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync /* @todo: FIXME: implement !!! */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync flags = VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags->u32HostFlags;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (1);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVtListCat(&pDevExt->VhwaCmdList, &VhwaCmdList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bNeedDpc |= !vboxVdmaDdiCmdIsCompletedListEmptyIsr(pDevExt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync memset(¬ify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, ¬ify);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#if 0 //def DEBUG_misha
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this is not entirely correct since host may concurrently complete some commands and raise a new IRQ while we are here,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * still this allows to check that the host flags are correctly cleared after the ISR */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t flags = VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags->u32HostFlags;
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, context(0x%p), bOur(0x%x)", MiniportDeviceContext, (ULONG)bOur));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync} VBOXWDDM_GETDPCDATA_CONTEXT, *PVBOXWDDM_GETDPCDATA_CONTEXT;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync PVBOXWDDM_GETDPCDATA_CONTEXT pdc = (PVBOXWDDM_GETDPCDATA_CONTEXT)Context;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync vboxVtListDetach2List(&pDevExt->CtlList, &pdc->data.CtlList);
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync vboxVtListDetach2List(&pDevExt->DmaCmdList, &pdc->data.DmaCmdList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVtListDetach2List(&pDevExt->VhwaCmdList, &pdc->data.VhwaCmdList);
b6b29a7e040f2b46480aa596fe0861bb16ce3da5vboxsync vboxVdmaDdiCmdGetCompletedListIsr(pDevExt, &pdc->data.CompletedDdiCmdQueue);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ASMAtomicWriteU32(&pDevExt->fCompletingCommands, 0);
b6b29a7e040f2b46480aa596fe0861bb16ce3da5vboxsync// LOGF(("ENTER, context(0x%p)", MiniportDeviceContext));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync pDevExt->u.primary.DxgkInterface.DxgkCbNotifyDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync if (ASMAtomicReadU32(&pDevExt->fCompletingCommands))
b6b29a7e040f2b46480aa596fe0861bb16ce3da5vboxsync /* get DPC data at IRQL */
b6b29a7e040f2b46480aa596fe0861bb16ce3da5vboxsync NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 0, /* IN ULONG MessageNumber */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // if (context.data.bNotifyDpc)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->u.primary.DxgkInterface.DxgkCbNotifyDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = VBoxSHGSMICommandPostprocessCompletion (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, &context.data.CtlList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVhwaCompletionListProcess(pDevExt, &context.data.VhwaCmdList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, context(0x%p)", MiniportDeviceContext));
4c98b8b05f3783351cf256cc90cd4478fb28b62bvboxsync// LOGF(("ENTER, context(0x%p)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync /* get DPC data at IRQL */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync 0, /* IN ULONG MessageNumber */
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync// if (context.data.bNotifyDpc)
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pDevExt->u.primary.DxgkInterface.DxgkCbNotifyDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = VBoxSHGSMICommandPostprocessCompletion (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, &context.data.CtlList);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync int rc = VBoxSHGSMICommandPostprocessCompletion (&pDevExt->u.primary.Vdma.CmdHeap, &context.data.DmaCmdList);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync vboxVhwaCompletionListProcess(pDevExt, &context.data.VhwaCmdList);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync vboxVdmaDdiCmdHandleCompletedList(pDevExt, &context.data.CompletedDdiCmdQueue);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync// LOGF(("LEAVE, context(0x%p)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiQueryChildRelations function should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(ChildRelationsSize == (VBoxCommonFromDeviceExt(pDevExt)->cDisplays + 1)*sizeof(DXGK_CHILD_DESCRIPTOR));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ChildRelations[i].ChildDeviceType = TypeVideoOutput;
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync ChildRelations[i].ChildCapabilities.Type.VideoOutput.InterfaceTechnology = D3DKMDT_VOT_HD15; /* VGA */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ChildRelations[i].ChildCapabilities.Type.VideoOutput.MonitorOrientationAwareness = D3DKMDT_MOA_NONE; //D3DKMDT_MOA_INTERRUPTIBLE; /* ?? D3DKMDT_MOA_NONE*/
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ChildRelations[i].ChildCapabilities.Type.VideoOutput.SupportsSdtvModes = FALSE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ChildRelations[i].ChildCapabilities.HpdAwareness = HpdAwarenessInterruptible; /* ?? HpdAwarenessAlwaysConnected; */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ChildRelations[i].ChildUid = i; /* should be == target id */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiQueryChildStatus should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[ChildStatus->ChildUid];
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync ChildStatus->HotPlug.Connected = !!pTarget->fConnected;
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync WARN(("ERROR: status type: %d", ChildStatus->Type));
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync LOGF(("LEAVE, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiQueryDeviceDescriptor should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, context(0x%x)", MiniportDeviceContext));
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync /* we do not support EDID */
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync /* The DxgkDdiSetPowerState function should be made pageable. */
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync LOGF(("ENTER, context(0x%x)", MiniportDeviceContext));
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync LOGF(("LEAVE, context(0x%x)", MiniportDeviceContext));
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync LOGF(("ENTER, MiniportDeviceContext(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, MiniportDeviceContext(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiResetDevice can be called at any IRQL, so it must be in nonpageable memory. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiUnload should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PRTLOGGER pLogger = RTLogRelSetDefaultInstance(NULL);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, MiniportDeviceContext(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, MiniportDeviceContext(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiQueryAdapterInfo
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiQueryAdapterInfo should be made pageable. */
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync LOGF(("ENTER, context(0x%x), Query type (%d)", hAdapter, pQueryAdapterInfo->Type));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync DXGK_DRIVERCAPS *pCaps = (DXGK_DRIVERCAPS*)pQueryAdapterInfo->pOutputData;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync /* driver talks to host in terms of page numbers when reffering to RAM
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync * we use uint32_t field to pass page index to host, so max would be (~0UL) << PAGE_OFFSET,
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync * which seems quite enough */
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pCaps->HighestAcceptableAddress.HighPart = PAGE_OFFSET_MASK;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pCaps->MaxPointerWidth = VBOXWDDM_C_POINTER_MAX_WIDTH;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pCaps->MaxPointerHeight = VBOXWDDM_C_POINTER_MAX_HEIGHT;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pCaps->PointerCaps.Value = 3; /* Monochrome , Color*/ /* MaskedColor == Value | 4, disable for now */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if ( pDevExt->aSources[i].Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->MaxOverlays += pDevExt->aSources[i].Vhwa.Settings.cOverlaysSupported;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->MaxQueuedFlipOnVSync = 0; /* do we need it? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* ? pCaps->FlipCaps.FlipOnVSyncWithNoWait = 1; */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we might need it for Aero.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Setting this flag means we support DeviceContext, i.e.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiCreateContext and DxgkDdiDestroyContext
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: this correlates with pCaps->SchedulingCaps.MultiEngineAware */
521d8df5a1a304406b911c2e2c7bf9214d6d9200vboxsync /* @todo: this correlates with pCaps->SchedulingCaps.MultiEngineAware */
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync pCaps->GpuEngineTopology.NbAsymetricProcessingNodes = VBOXWDDM_NUM_NODES;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* no need for DXGK_QUERYSEGMENTIN as it contains AGP aperture info, which (AGP aperture) we do not support
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DXGK_QUERYSEGMENTIN *pQsIn = (DXGK_QUERYSEGMENTIN*)pQueryAdapterInfo->pInputData; */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_QUERYSEGMENTOUT *pQsOut = (DXGK_QUERYSEGMENTOUT*)pQueryAdapterInfo->pOutputData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we are requested to provide the number of segments we support */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync else if (pQsOut->NbSegment != VBOXWDDM_SEGMENTS_COUNT)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_SEGMENTDESCRIPTOR* pDr = pQsOut->pSegmentDescriptor;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we are requested to provide segment information */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDr->CpuTranslatedAddress = VBoxCommonFromDeviceExt(pDevExt)->phVRAM;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* make sure the size is page aligned */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: need to setup VBVA buffers and adjust the mem size here */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDr->Size = vboxWddmVramCpuVisibleSegmentSize(pDevExt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* create cpu-invisible segment of the same size */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* make sure the size is page aligned */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: need to setup VBVA buffers and adjust the mem size here */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDr->Size = vboxWddmVramCpuInvisibleSegmentSize(pDevExt);
6d9d4a12f6f9f341c968f711765c2c17c9a5a28cvboxsync WARN(("unsupported Type (%d)", pQueryAdapterInfo->Type));
0cb5af53de7aed97b1b35311f93de8175756e4afvboxsync if (pQueryAdapterInfo->OutputDataSize == sizeof (VBOXWDDM_QI))
6d9d4a12f6f9f341c968f711765c2c17c9a5a28cvboxsync VBOXWDDM_QI * pQi = (VBOXWDDM_QI*)pQueryAdapterInfo->pOutputData;
6d9d4a12f6f9f341c968f711765c2c17c9a5a28cvboxsync pQi->cInfos = VBoxCommonFromDeviceExt(pDevExt)->cDisplays;
6d9d4a12f6f9f341c968f711765c2c17c9a5a28cvboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pQi->aInfos[i] = pDevExt->aSources[i].Vhwa.Settings;
6d9d4a12f6f9f341c968f711765c2c17c9a5a28cvboxsync WARN(("incorrect buffer size %d, expected %d", pQueryAdapterInfo->OutputDataSize, sizeof (VBOXWDDM_QI)));
6d9d4a12f6f9f341c968f711765c2c17c9a5a28cvboxsync WARN(("unsupported Type (%d)", pQueryAdapterInfo->Type));
6d9d4a12f6f9f341c968f711765c2c17c9a5a28cvboxsync LOGREL(("DXGKQAITYPE_QUERYSEGMENT3 treating as unsupported!"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("unsupported Type (%d)", pQueryAdapterInfo->Type));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, context(0x%x), Status(0x%x)", hAdapter, Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiCreateDevice
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiCreateDevice should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)vboxWddmMemAllocZero(sizeof (VBOXWDDM_DEVICE));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, context(0x%x), Status(0x%x)", hAdapter, Status));
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsyncPVBOXWDDM_RESOURCE vboxWddmResourceCreate(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_RCINFO pRcInfo)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_RESOURCE pResource = (PVBOXWDDM_RESOURCE)vboxWddmMemAllocZero(RT_OFFSETOF(VBOXWDDM_RESOURCE, aAllocations[pRcInfo->cAllocInfos]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncVOID vboxWddmResourceRetain(PVBOXWDDM_RESOURCE pResource)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic VOID vboxWddmResourceDestroy(PVBOXWDDM_RESOURCE pResource)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncVOID vboxWddmResourceWaitDereference(PVBOXWDDM_RESOURCE pResource)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncVOID vboxWddmResourceRelease(PVBOXWDDM_RESOURCE pResource)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cRefs = ASMAtomicDecU32(&pResource->cRefs);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncvoid vboxWddmAllocationDeleteFromResource(PVBOXWDDM_RESOURCE pResource, PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(&pResource->aAllocations[pAllocation->iIndex] == pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncVOID vboxWddmAllocationCleanupAssignment(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: do we need to notify host? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAssignPrimary(&pDevExt->aSources[pAllocation->AllocData.SurfDesc.VidPnSourceId], NULL, pAllocation->AllocData.SurfDesc.VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncVOID vboxWddmAllocationCleanup(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_SWAPCHAIN pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmSwapchainAllocRemove(pDevExt, pSwapchain, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncVOID vboxWddmAllocationDestroy(PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAllocationDeleteFromResource(pAllocation->pResource, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncPVBOXWDDM_ALLOCATION vboxWddmAllocationCreateFromResource(PVBOXWDDM_RESOURCE pResource, uint32_t iIndex)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pAllocation, 0, sizeof (VBOXWDDM_ALLOCATION));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(sizeof (VBOXWDDM_ALLOCATION));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmAllocationCreate(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_RESOURCE pResource, uint32_t iIndex, DXGK_ALLOCATIONINFO* pAllocationInfo)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAllocationInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pAllocationInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pAllocationInfo->pPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAllocation = vboxWddmAllocationCreateFromResource(pResource, iIndex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_NORMAL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->AllocData.Addr.offVram = VBOXVIDEOOFFSET_VOID;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->AllocData.SurfDesc = pAllocInfo->SurfDesc;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->AllocData.hostID = pAllocInfo->hostID;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocationInfo->Size = pAllocInfo->SurfDesc.cbSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* actually we can not "properly" issue create overlay commands to the host here
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * because we do not know source VidPn id here, i.e.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * the primary which is supposed to be overlayed,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * however we need to get some info like pitch & size from the host here */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = vboxVhwaHlpGetSurfInfo(pDevExt, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocationInfo->Size = pAllocation->AllocData.SurfDesc.cbSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_HIGH;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// if (!pAllocInfo->fFlags.SharedResource && !pAllocInfo->hostID)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pAllocationInfo->Flags.CpuVisible = 1;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->hSharedHandle = (HANDLE)pAllocInfo->hSharedHandle;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// if (pAllocInfo->hostID)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->UsageHint.v1.Format = pAllocInfo->SurfDesc.format;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->UsageHint.v1.Width = pAllocation->AllocData.SurfDesc.width;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->UsageHint.v1.Height = pAllocation->AllocData.SurfDesc.height;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->UsageHint.v1.Pitch = pAllocation->AllocData.SurfDesc.pitch;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocationInfo->pAllocationUsageHint = &pAllocation->UsageHint;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->fUhgsmiType = pAllocInfo->fUhgsmiType;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->AllocData.SurfDesc.cbSize = pAllocInfo->cbBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pAllocationInfo->Flags.SynchronousPaging = 1;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_MAXIMUM;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("ERROR: invalid alloc info type(%d)", pAllocInfo->enmType));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAllocationDeleteFromResource(pResource, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("ERROR: failed to create allocation description"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("ERROR: PrivateDriverDataSize(%d) less than header size(%d)", pAllocationInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiCreateAllocation should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pCreateAllocation->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pCreateAllocation->PrivateDriverDataSize < sizeof (VBOXWDDM_RCINFO))
a21a14c99f2698c3a8b6dc0a3086e087701fe719vboxsync WARN(("invalid private data size (%d)", pCreateAllocation->PrivateDriverDataSize));
a21a14c99f2698c3a8b6dc0a3086e087701fe719vboxsync PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)pCreateAllocation->pPrivateDriverData;
a21a14c99f2698c3a8b6dc0a3086e087701fe719vboxsync// Assert(pRcInfo->RcDesc.VidPnSourceId < VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pRcInfo->cAllocInfos != pCreateAllocation->NumAllocations)
a21a14c99f2698c3a8b6dc0a3086e087701fe719vboxsync WARN(("invalid number of allocations passed in, (%d), expected (%d)", pRcInfo->cAllocInfos, pCreateAllocation->NumAllocations));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* a check to ensure we do not get the allocation size which is too big to overflow the 32bit value */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(VBOXWDDM_RESOURCE, aAllocations) < pRcInfo->cAllocInfos)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("number of allocations passed too big (%d), max is (%d)", pRcInfo->cAllocInfos, VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(VBOXWDDM_RESOURCE, aAllocations)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pResource = (PVBOXWDDM_RESOURCE)vboxWddmMemAllocZero(RT_OFFSETOF(VBOXWDDM_RESOURCE, aAllocations[pRcInfo->cAllocInfos]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxWddmMemAllocZero failed for (%d) allocations", pRcInfo->cAllocInfos));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < pCreateAllocation->NumAllocations; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmAllocationCreate(pDevExt, pResource, i, &pCreateAllocation->pAllocationInfo[i]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxWddmAllocationCreate(%d) failed, Status(0x%x)", i, Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* note: i-th allocation is expected to be cleared in a fail handling code above */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT j = 0; j < i; ++j)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)pCreateAllocation->pAllocationInfo[j].hAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
521d8df5a1a304406b911c2e2c7bf9214d6d9200vboxsync CONST DXGKARG_DESTROYALLOCATION* pDestroyAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiDestroyAllocation should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_RESOURCE pRc = (PVBOXWDDM_RESOURCE)pDestroyAllocation->hResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRc->cAllocations == pDestroyAllocation->NumAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < pDestroyAllocation->NumAllocations; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pDestroyAllocation->pAllocationList[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAllocationCleanupAssignment(pDevExt, pAlloc);
a21a14c99f2698c3a8b6dc0a3086e087701fe719vboxsync /* wait for all current allocation-related ops are completed */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* wait for all current resource-related ops are completed */
a21a14c99f2698c3a8b6dc0a3086e087701fe719vboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
a21a14c99f2698c3a8b6dc0a3086e087701fe719vboxsync * DxgkDdiDescribeAllocation
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, hAdapter(0x%x)", hAdapter));
09f4b412099acda62997fd82c8608075c453b3ebvboxsync PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)pDescribeAllocation->hAllocation;
09f4b412099acda62997fd82c8608075c453b3ebvboxsync pDescribeAllocation->Width = pAllocation->AllocData.SurfDesc.width;
a21a14c99f2698c3a8b6dc0a3086e087701fe719vboxsync pDescribeAllocation->Height = pAllocation->AllocData.SurfDesc.height;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDescribeAllocation->Format = pAllocation->AllocData.SurfDesc.format;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset (&pDescribeAllocation->MultisampleMethod, 0, sizeof (pDescribeAllocation->MultisampleMethod));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDescribeAllocation->RefreshRate.Numerator = 60000;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDescribeAllocation->RefreshRate.Denominator = 1000;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDescribeAllocation->PrivateDriverFormatAttribute = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, hAdapter(0x%x)", hAdapter));
329df9696e709dc71611f504a4774f323545be0avboxsync * DxgkDdiGetStandardAllocationDriverData
70e6f03ca742e60292ae2d45811314790b16dab2vboxsync DXGKARG_GETSTANDARDALLOCATIONDRIVERDATA* pGetStandardAllocationDriverData)
70e6f03ca742e60292ae2d45811314790b16dab2vboxsync /* DxgkDdiGetStandardAllocationDriverData should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync switch (pGetStandardAllocationDriverData->StandardAllocationType)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync case D3DKMDT_STANDARDALLOCATION_SHAREDPRIMARYSURFACE:
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("D3DKMDT_STANDARDALLOCATION_SHAREDPRIMARYSURFACE"));
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync if(pGetStandardAllocationDriverData->pAllocationPrivateDriverData)
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync memset (pAllocInfo, 0, sizeof (VBOXWDDM_ALLOCINFO));
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE;
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync pAllocInfo->SurfDesc.width = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width;
09f4b412099acda62997fd82c8608075c453b3ebvboxsync pAllocInfo->SurfDesc.height = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Height;
70e6f03ca742e60292ae2d45811314790b16dab2vboxsync pAllocInfo->SurfDesc.format = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Format;
70e6f03ca742e60292ae2d45811314790b16dab2vboxsync pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->SurfDesc.format);
70e6f03ca742e60292ae2d45811314790b16dab2vboxsync pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width, pAllocInfo->SurfDesc.format);
09f4b412099acda62997fd82c8608075c453b3ebvboxsync pAllocInfo->SurfDesc.cbSize = vboxWddmCalcSize(pAllocInfo->SurfDesc.pitch, pAllocInfo->SurfDesc.height, pAllocInfo->SurfDesc.format);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pAllocInfo->SurfDesc.RefreshRate = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->RefreshRate;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pAllocInfo->SurfDesc.VidPnSourceId = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->VidPnSourceId;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO);
09f4b412099acda62997fd82c8608075c453b3ebvboxsync pGetStandardAllocationDriverData->ResourcePrivateDriverDataSize = 0;
3decc8a08d366ec11441c85d4e118c9448adc467vboxsync LOGF(("D3DKMDT_STANDARDALLOCATION_SHADOWSURFACE"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT bpp = vboxWddmCalcBitsPerPixel(pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Format);
7b6926b2bf44f326f40e1d9d1ce33a4dff0a2c67vboxsync UINT Pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width, pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Format);
7b6926b2bf44f326f40e1d9d1ce33a4dff0a2c67vboxsync pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Pitch = Pitch;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: need [d/q]word align?? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pGetStandardAllocationDriverData->pAllocationPrivateDriverData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.width = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.height = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Height;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.format = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Format;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->SurfDesc.format);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width, pAllocInfo->SurfDesc.format);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.cbSize = vboxWddmCalcSize(pAllocInfo->SurfDesc.pitch, pAllocInfo->SurfDesc.height, pAllocInfo->SurfDesc.format);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.RefreshRate.Denominator = 1000;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.VidPnSourceId = D3DDDI_ID_UNINITIALIZED;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Pitch = pAllocInfo->SurfDesc.pitch;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pGetStandardAllocationDriverData->ResourcePrivateDriverDataSize = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("Invalid format (%d)", pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Format));
521d8df5a1a304406b911c2e2c7bf9214d6d9200vboxsync LOGF(("D3DKMDT_STANDARDALLOCATION_STAGINGSURFACE"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if(pGetStandardAllocationDriverData->pAllocationPrivateDriverData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pAllocInfo->SurfDesc.width = pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Width;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.height = pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Height;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.format = D3DDDIFMT_X8R8G8B8; /* staging has always always D3DDDIFMT_X8R8G8B8 */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->SurfDesc.format);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Width, pAllocInfo->SurfDesc.format);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.cbSize = vboxWddmCalcSize(pAllocInfo->SurfDesc.pitch, pAllocInfo->SurfDesc.height, pAllocInfo->SurfDesc.format);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.RefreshRate.Denominator = 1000;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.VidPnSourceId = D3DDDI_ID_UNINITIALIZED;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Pitch = pAllocInfo->SurfDesc.pitch;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pGetStandardAllocationDriverData->ResourcePrivateDriverDataSize = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync//#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7)
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync// case D3DKMDT_STANDARDALLOCATION_GDISURFACE:
7b6926b2bf44f326f40e1d9d1ce33a4dff0a2c67vboxsync//# error port to Win7 DDI
7b6926b2bf44f326f40e1d9d1ce33a4dff0a2c67vboxsync LOGREL(("Invalid allocation type (%d)", pGetStandardAllocationDriverData->StandardAllocationType));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
7b6926b2bf44f326f40e1d9d1ce33a4dff0a2c67vboxsync DXGKARG_ACQUIRESWIZZLINGRANGE* pAcquireSwizzlingRange)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CONST DXGKARG_RELEASESWIZZLINGRANGE* pReleaseSwizzlingRange)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiPatch should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint8_t * pPrivateBuf = (uint8_t*)((uint8_t*)pPatch->pDmaBufferPrivateData + pPatch->DmaBufferPrivateDataSubmissionStartOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbPatchBuff = pPatch->DmaBufferPrivateDataSubmissionEndOffset - pPatch->DmaBufferPrivateDataSubmissionStartOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = pPatch->PatchLocationListSubmissionStart; i < pPatch->PatchLocationListSubmissionLength; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatchList->AllocationIndex < pPatch->AllocationListSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_ALLOCATIONLIST *pAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this is a dummy patch request, ignore */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("pPatchList->PatchOffset(%d) >= cbPatchBuff(%d)", pPatchList->PatchOffset, cbPatchBuff));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXCMDVBVAOFFSET *poffVram = (VBOXCMDVBVAOFFSET*)(pPrivateBuf + pPatchList->PatchOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!pAllocationList->PhysicalAddress.HighPart);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!(pAllocationList->PhysicalAddress.QuadPart & 0xfffUL)); /* <- just a check to ensure allocation offset does not go here */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync *poffVram = pAllocationList->PhysicalAddress.LowPart + pPatchList->AllocationOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiPatch should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* Value == 2 is Present
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Value == 4 is RedirectedPresent
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * we do not expect any other flags to be set here */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pPatch->Flags.Value == 2 || pPatch->Flags.Value == 4);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pPatch->DmaBufferPrivateDataSubmissionEndOffset - pPatch->DmaBufferPrivateDataSubmissionStartOffset >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatch->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_DMA_PRIVATEDATA_BASEHDR *pPrivateDataBase = (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR*)((uint8_t*)pPatch->pDmaBufferPrivateData + pPatch->DmaBufferPrivateDataSubmissionStartOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_BLT pBlt = (PVBOXWDDM_DMA_PRIVATEDATA_BLT)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatch->PatchLocationListSubmissionLength == 2);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatchList->AllocationIndex == DXGK_PRESENT_SOURCE_INDEX);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_ALLOCATIONLIST *pSrcAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBlt->Blt.SrcAlloc.segmentIdAlloc = pSrcAllocationList->SegmentId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBlt->Blt.SrcAlloc.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart + 1];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatchList->AllocationIndex == DXGK_PRESENT_DESTINATION_INDEX);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_ALLOCATIONLIST *pDstAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBlt->Blt.DstAlloc.segmentIdAlloc = pDstAllocationList->SegmentId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBlt->Blt.DstAlloc.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_FLIP pFlip = (PVBOXWDDM_DMA_PRIVATEDATA_FLIP)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatch->PatchLocationListSubmissionLength == 1);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatchList->AllocationIndex == DXGK_PRESENT_SOURCE_INDEX);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_ALLOCATIONLIST *pSrcAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pFlip->Flip.Alloc.segmentIdAlloc = pSrcAllocationList->SegmentId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pFlip->Flip.Alloc.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatch->PatchLocationListSubmissionLength == 1);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatchList->AllocationIndex == DXGK_PRESENT_DESTINATION_INDEX);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_ALLOCATIONLIST *pDstAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCF->ClrFill.Alloc.segmentIdAlloc = pDstAllocationList->SegmentId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCF->ClrFill.Alloc.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint8_t * pPrivateBuf = (uint8_t*)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = pPatch->PatchLocationListSubmissionStart; i < pPatch->PatchLocationListSubmissionLength; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatchList->AllocationIndex < pPatch->AllocationListSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_ALLOCATIONLIST *pAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_ALLOCATIONLIST *pAllocation2Patch = (DXGK_ALLOCATIONLIST*)(pPrivateBuf + pPatchList->PatchOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation2Patch->SegmentId = pAllocationList->SegmentId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation2Patch->PhysicalAddress.QuadPart = pAllocationList->PhysicalAddress.QuadPart + pPatchList->AllocationOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!(pAllocationList->PhysicalAddress.QuadPart & 0xfffUL)); /* <- just a check to ensure allocation offset does not go here */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint8_t *pBuf = ((uint8_t *)pPatch->pDmaBuffer) + pPatch->DmaBufferSubmissionStartOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = pPatch->PatchLocationListSubmissionStart; i < pPatch->PatchLocationListSubmissionLength; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatchList->AllocationIndex < pPatch->AllocationListSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_ALLOCATIONLIST *pAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatchList->PatchOffset < (pPatch->DmaBufferSubmissionEndOffset - pPatch->DmaBufferSubmissionStartOffset));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync *((VBOXVIDEOOFFSET*)(pBuf+pPatchList->PatchOffset)) = (VBOXVIDEOOFFSET)pAllocationList->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* sanity */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pPatch->Flags.Value == 2 || pPatch->Flags.Value == 4)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync else if (pPatch->DmaBufferPrivateDataSubmissionEndOffset == pPatch->DmaBufferPrivateDataSubmissionStartOffset)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this is a NOP, just return success */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOG(("null data size, treating as NOP"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("DmaBufferPrivateDataSubmissionEndOffset (%d) - DmaBufferPrivateDataSubmissionStartOffset (%d) < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR) (%d)",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CALL_ISR pdc = (PVBOXWDDM_CALL_ISR)Context;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return DxgkDdiInterruptRoutineNew(pDevExt, pdc->MessageNumber);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return DxgkDdiInterruptRoutineLegacy(pDevExt, pdc->MessageNumber);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 0, /* IN ULONG MessageNumber */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLCALLBACK(VOID) vboxWddmDmaCompleteChromiumCmd(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)pvContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHROMIUM_CMD);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiSubmitCommand runs at dispatch, should not be pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, context(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pSubmitCommand->hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cbCmd = pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset - pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cbDma = pSubmitCommand->DmaBufferSubmissionEndOffset - pSubmitCommand->DmaBufferSubmissionStartOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NopCmd.u2.complexCmdEl.u16CbCmdHost = sizeof (VBOXCMDVBVA_HDR);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pHdr = (VBOXCMDVBVA_HDR*)(((uint8_t*)pSubmitCommand->pDmaBufferPrivateData) + pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDstHdr = VBoxCmdVbvaSubmitLock(pDevExt, &pDevExt->CmdVbva, cbCmd + sizeof (VBOXCMDVBVA_HDR));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDstHdr = VBoxCmdVbvaSubmitLock(pDevExt, &pDevExt->CmdVbva, cbCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync phAddr.QuadPart = pSubmitCommand->DmaBufferPhysicalAddress.QuadPart + pSubmitCommand->DmaBufferSubmissionStartOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXCMDVBVA_SYSMEMCMD *pSysMem = (VBOXCMDVBVA_SYSMEMCMD*)pHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pSubmitCommand->DmaBufferPhysicalAddress.QuadPart & PAGE_OFFSET_MASK)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSysMem->phCmd = (VBOXCMDVBVAPHADDR)(pSubmitCommand->DmaBufferPhysicalAddress.QuadPart + pSubmitCommand->DmaBufferSubmissionStartOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cbRealDmaCmd = (pSysMem->Hdr.u8Flags | (pSysMem->Hdr.u.u8PrimaryID << 8));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pHdr = (VBOXCMDVBVA_HDR*)(((uint8_t*)pHdr) + cbCurCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCurDstCmd = (VBOXCMDVBVA_HDR*)(((uint8_t*)pCurDstCmd) + cbCurCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t u32FenceId = pSubmitCommand->SubmissionFenceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* nop the entire command on failure */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxCmdVbvaSubmitUnlock(pDevExt, &pDevExt->CmdVbva, pDstHdr, u32FenceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiSubmitCommand runs at dispatch, should not be pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, context(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pSubmitCommand->hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pPrivateDataBase = NULL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVDMACMD_TYPE enmCmd = VBOXVDMACMD_TYPE_UNDEFINED;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* the DMA command buffer is located in system RAM, the host will need to pick it from there */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync //BufInfo.fFlags = 0; /* see VBOXVDMACBUF_FLAG_xx */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset - pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPrivateDataBase = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)((uint8_t*)pSubmitCommand->pDmaBufferPrivateData + pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync else if (pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset == pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("DmaBufferPrivateDataSubmissionEndOffset (%d) - DmaBufferPrivateDataSubmissionStartOffset (%d) < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR) (%d)",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_BLT pBlt = (PVBOXWDDM_DMA_PRIVATEDATA_BLT)pPrivateData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync fDstChanged = vboxWddmAddrSetVram(&pDstAlloc->AllocData.Addr, pBlt->Blt.DstAlloc.segmentIdAlloc, pBlt->Blt.DstAlloc.offAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync fSrcChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pBlt->Blt.SrcAlloc.segmentIdAlloc, pBlt->Blt.SrcAlloc.offAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pDstAlloc->AllocData.SurfDesc.VidPnSourceId < VBOX_VIDEO_MAX_SCREENS);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (VBOXWDDM_IS_FB_ALLOCATION(pDevExt, pDstAlloc) && pDstAlloc->AllocData.hostID)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pSource->AllocData.hostID != pDstAlloc->AllocData.hostID)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSource->AllocData.hostID = pDstAlloc->AllocData.hostID;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaProcessBltCmd(pDevExt, pContext, pBlt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxVdmaProcessBltCmd failed, Status 0x%x", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NT_SUCCESS(Status) ? DXGK_INTERRUPT_DMA_COMPLETED : DXGK_INTERRUPT_DMA_FAULTED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip = (VBOXWDDM_DMA_PRIVATEDATA_FLIP*)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAddrSetVram(&pAlloc->AllocData.Addr, pFlip->Flip.Alloc.segmentIdAlloc, pFlip->Flip.Alloc.offAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAssignPrimary(pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NT_SUCCESS(Status) ? DXGK_INTERRUPT_DMA_COMPLETED : DXGK_INTERRUPT_DMA_FAULTED);
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pPrivateDataBase;
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync vboxWddmAddrSetVram(&pCF->ClrFill.Alloc.pAlloc->AllocData.Addr, pCF->ClrFill.Alloc.segmentIdAlloc, pCF->ClrFill.Alloc.offAlloc);
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync Status = vboxVdmaProcessClrFillCmd(pDevExt, pContext, pCF);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxVdmaProcessClrFillCmd failed, Status 0x%x", Status));
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NT_SUCCESS(Status) ? DXGK_INTERRUPT_DMA_COMPLETED : DXGK_INTERRUPT_DMA_FAULTED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#if 0 //def VBOX_WITH_VDMA
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, 0);
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync /* @todo: try flushing.. */
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync // vboxVdmaCBufDrCreate zero initializes the pDr
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync //pDr->fFlags = 0;
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync pDr->cbBuf = pSubmitCommand->DmaBufferSubmissionEndOffset - pSubmitCommand->DmaBufferSubmissionStartOffset;
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync pDr->u32FenceId = pSubmitCommand->SubmissionFenceId;
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync pDr->u64GuestContext = (uint64_t)pPrivateData->pContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // else // vboxVdmaCBufDrCreate zero initializes the pDr
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync // pDr->u64GuestContext = NULL;
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync pDr->Location.phBuf = pSubmitCommand->DmaBufferPhysicalAddress.QuadPart + pSubmitCommand->DmaBufferSubmissionStartOffset;
935a8412cc9b46bc9b5fc1a3bfaa0f6c73092e65vboxsync vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, context(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxCmdVbvaPreempt(pDevExt, &pDevExt->CmdVbva, pPreemptCommand->PreemptionFenceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: fixme: implement */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiBuildPagingBuffer
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiBuildPagingBuffer should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pBuildPagingBuffer->DmaBufferPrivateDataSize < sizeof (VBOXCMDVBVA_HDR))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXCMDVBVA_HDR *pHdr = (VBOXCMDVBVA_HDR*)pBuildPagingBuffer->pDmaBufferPrivateData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!pBuildPagingBuffer->Transfer.Flags.AllocationIsIdle)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pBuildPagingBuffer->DmaBufferPrivateDataSize < sizeof (VBOXCMDVBVA_SYSMEMCMD))
89bc55bf0a6b0d34d55c02ca2a0c1082fe598cdcvboxsync if ((!pBuildPagingBuffer->Transfer.Source.SegmentId) == (!pBuildPagingBuffer->Transfer.Destination.SegmentId))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("we only support RAM <-> VRAM moves, Src Seg(%d), Dst Seg(%d)", pBuildPagingBuffer->Transfer.Source.SegmentId, pBuildPagingBuffer->Transfer.Destination.SegmentId));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->Transfer.hAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pBuildPagingBuffer->DmaSize < sizeof (VBOXCMDVBVA_PAGING_TRANSFER))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("pBuildPagingBuffer->DmaSize(%d) < sizeof VBOXCMDVBVA_PAGING_TRANSFER (%d)", pBuildPagingBuffer->DmaSize , sizeof (VBOXCMDVBVA_PAGING_TRANSFER)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: can this actually happen? what status to return? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXCMDVBVA_PAGING_TRANSFER *pPaging = (VBOXCMDVBVA_PAGING_TRANSFER*)pBuildPagingBuffer->pDmaBuffer;
87150caf549846b0edba30c50dabe5092df70b5fvboxsync pPaging->Hdr.u8OpCode = VBOXCMDVBVA_OPTYPE_PAGING_TRANSFER;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* sanity */
89bc55bf0a6b0d34d55c02ca2a0c1082fe598cdcvboxsync pPaging->Hdr.u8State = VBOXCMDVBVA_STATE_SUBMITTED;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync SegmentId = pBuildPagingBuffer->Transfer.Source.SegmentId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!pBuildPagingBuffer->Transfer.Destination.SegmentId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!pBuildPagingBuffer->Transfer.Source.SegmentAddress.HighPart);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync offVRAM = pBuildPagingBuffer->Transfer.Source.SegmentAddress.LowPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pMdl = pBuildPagingBuffer->Transfer.Destination.pMdl;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync SegmentId = pBuildPagingBuffer->Transfer.Destination.SegmentId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pBuildPagingBuffer->Transfer.Destination.SegmentId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!pBuildPagingBuffer->Transfer.Source.SegmentId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!pBuildPagingBuffer->Transfer.Destination.SegmentAddress.HighPart);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync offVRAM = pBuildPagingBuffer->Transfer.Destination.SegmentAddress.LowPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!(pBuildPagingBuffer->Transfer.TransferSize & PAGE_OFFSET_MASK));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cPages = (uint32_t)(pBuildPagingBuffer->Transfer.TransferSize >> PAGE_SHIFT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(cPages > pBuildPagingBuffer->MultipassOffset);
87150caf549846b0edba30c50dabe5092df70b5fvboxsync uint32_t iFirstPage = pBuildPagingBuffer->MultipassOffset;
87150caf549846b0edba30c50dabe5092df70b5fvboxsync offVRAM += pBuildPagingBuffer->Transfer.TransferOffset + (pBuildPagingBuffer->MultipassOffset << PAGE_SHIFT);
87150caf549846b0edba30c50dabe5092df70b5fvboxsync pPaging->Hdr.u8Flags |= VBOXCMDVBVA_OPF_PAGING_TRANSFER_IN;
87150caf549846b0edba30c50dabe5092df70b5fvboxsync cbBuffer = VBoxCVDdiPTransferVRamSysBuildEls(pPaging, pMdl, iFirstPage, cPages, pBuildPagingBuffer->DmaSize, &cPagesWritten);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync pBuildPagingBuffer->MultipassOffset += cPagesWritten;
47e63965841090c9188901843e4d9c8e581e2971vboxsync VBOXCMDVBVA_SYSMEMCMD *pSysMemCmd = (VBOXCMDVBVA_SYSMEMCMD*)pBuildPagingBuffer->pDmaBufferPrivateData;
87150caf549846b0edba30c50dabe5092df70b5fvboxsync pSysMemCmd->Hdr.u8OpCode = VBOXCMDVBVA_OPTYPE_SYSMEMCMD;
87150caf549846b0edba30c50dabe5092df70b5fvboxsync pSysMemCmd->Hdr.u.u8PrimaryID = (cbBuffer >> 8) & 0xff;
87150caf549846b0edba30c50dabe5092df70b5fvboxsync pSysMemCmd->Hdr.u8State = VBOXCMDVBVA_STATE_SUBMITTED;
87150caf549846b0edba30c50dabe5092df70b5fvboxsync PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->Fill.hAllocation;
87150caf549846b0edba30c50dabe5092df70b5fvboxsync if (pAlloc->AllocData.hostID || pBuildPagingBuffer->Fill.Destination.SegmentId != 1)
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync if (pBuildPagingBuffer->DmaBufferPrivateDataSize < sizeof (VBOXCMDVBVA_PAGING_FILL))
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync VBOXCMDVBVA_PAGING_FILL *pFill = (VBOXCMDVBVA_PAGING_FILL*)pBuildPagingBuffer->pDmaBufferPrivateData;
38b63f3439b83c64725f86f987a02845f918e47avboxsync pFill->Hdr.u8OpCode = VBOXCMDVBVA_OPTYPE_PAGING_FILL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pFill->u32CbFill = (uint32_t)pBuildPagingBuffer->Fill.FillSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pFill->u32Pattern = pBuildPagingBuffer->Fill.FillPattern;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!pBuildPagingBuffer->Fill.Destination.SegmentAddress.HighPart);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pFill->offVRAM = pBuildPagingBuffer->Fill.Destination.SegmentAddress.LowPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->DiscardContent.hAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// WARN(("Do we need to do anything here?"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("unsupported op (%d)", pBuildPagingBuffer->Operation));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(cbPrivateData >= sizeof (VBOXCMDVBVA_HDR) || pBuildPagingBuffer->Operation == DXGK_OPERATION_DISCARD_CONTENT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pBuildPagingBuffer->Operation == DXGK_OPERATION_DISCARD_CONTENT || cbBuffer);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(cbBuffer == 0 || cbBuffer >= sizeof (VBOXCMDVBVA_PAGING_TRANSFER) || cbBuffer == VBOXWDDM_DUMMY_DMABUFFER_SIZE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pHdr->u2.complexCmdEl.u16CbCmdHost = cbPrivateData;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pBuildPagingBuffer->pDmaBuffer = ((uint8_t*)pBuildPagingBuffer->pDmaBuffer) + cbBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBuildPagingBuffer->pDmaBufferPrivateData = ((uint8_t*)pBuildPagingBuffer->pDmaBufferPrivateData) + cbPrivateData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiBuildPagingBuffer should be made pageable. */
6ee2125e4b083d65e10fa8b2ef8fc1d2303cedcbvboxsync /* @todo: */
6ee2125e4b083d65e10fa8b2ef8fc1d2303cedcbvboxsync if ((!pBuildPagingBuffer->Transfer.Source.SegmentId) != (!pBuildPagingBuffer->Transfer.Destination.SegmentId))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD pCmd = (PVBOXVDMACMD)pBuildPagingBuffer->pDmaBuffer;
6ee2125e4b083d65e10fa8b2ef8fc1d2303cedcbvboxsync pCmd->enmType = VBOXVDMACMD_TYPE_DMA_BPB_TRANSFER_VRAMSYS;
6ee2125e4b083d65e10fa8b2ef8fc1d2303cedcbvboxsync PVBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS pBody = VBOXVDMACMD_BODY(pCmd, VBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS);
6ee2125e4b083d65e10fa8b2ef8fc1d2303cedcbvboxsync uint32_t cPages = (pBuildPagingBuffer->Transfer.TransferSize + 0xfff) >> 12;
6ee2125e4b083d65e10fa8b2ef8fc1d2303cedcbvboxsync uint32_t iFirstPage = pBuildPagingBuffer->Transfer.MdlOffset + pBuildPagingBuffer->MultipassOffset;
6ee2125e4b083d65e10fa8b2ef8fc1d2303cedcbvboxsync uint64_t off = pBuildPagingBuffer->Transfer.Source.SegmentAddress.QuadPart;
6ee2125e4b083d65e10fa8b2ef8fc1d2303cedcbvboxsync off += pBuildPagingBuffer->Transfer.TransferOffset + (pBuildPagingBuffer->MultipassOffset << 12);
6ee2125e4b083d65e10fa8b2ef8fc1d2303cedcbvboxsync pBody->fFlags = 0;//VBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS_SYS2VRAM
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync uint64_t off = pBuildPagingBuffer->Transfer.Destination.SegmentAddress.QuadPart;
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync off += pBuildPagingBuffer->Transfer.TransferOffset + (pBuildPagingBuffer->MultipassOffset << 12);
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync pMdl = pBuildPagingBuffer->Transfer.Destination.pMdl;
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync pBody->fFlags = VBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS_SYS2VRAM;
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync uint32_t sbBufferUsed = vboxWddmBpbTransferVRamSysBuildEls(pBody, pMdl, iFirstPage, cPages, pBuildPagingBuffer->DmaSize, &cPagesRemaining);
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->Transfer.hAllocation;
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync && !pAlloc->fRcFlags.Overlay /* overlay surfaces actually contain a valid data */
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync && pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE /* shadow primary - also */
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync && pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER /* hgsmi buffer - also */
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync /* we do not care about the others for now */
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync UINT cbCmd = VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_BPB_TRANSFER);
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, cbCmd);
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync SIZE_T cbTransferSize = pBuildPagingBuffer->Transfer.TransferSize;
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
ea1cc8df95dba6fca9c36c94f565ef95c7802a36vboxsync // vboxVdmaCBufDrCreate zero initializes the pDr
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVDMACMD_DMA_BPB_TRANSFER *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_DMA_BPB_TRANSFER);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pBody->cbTransferSize = (uint32_t)pBuildPagingBuffer->Transfer.TransferSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync SIZE_T cSrcPages = (cbTransferSize + 0xfff ) >> 12;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync uint64_t off = pBuildPagingBuffer->Transfer.Source.SegmentAddress.QuadPart;
c7d2f5508ab9703a7a6c5cce5c9d4bf335af660avboxsync off += pBuildPagingBuffer->Transfer.TransferOffset + cbTransfered;
c7d2f5508ab9703a7a6c5cce5c9d4bf335af660avboxsync pBody->fFlags |= VBOXVDMACMD_DMA_BPB_TRANSFER_F_SRC_VRAMOFFSET;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync UINT index = pBuildPagingBuffer->Transfer.MdlOffset + (UINT)(cbTransfered>>12);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pBody->Src.phBuf = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Source.pMdl)[index] << 12;
1ff34f218a5354068e4df9017f77fc5871e6b7c6vboxsync PFN_NUMBER num = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Source.pMdl)[index];
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync for (UINT i = 1; i < ((cbTransferSize - cbTransfered + 0xfff) >> 12); ++i)
1ff34f218a5354068e4df9017f77fc5871e6b7c6vboxsync PFN_NUMBER cur = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Source.pMdl)[index+i];
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync if (pBuildPagingBuffer->Transfer.Destination.SegmentId)
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync uint64_t off = pBuildPagingBuffer->Transfer.Destination.SegmentAddress.QuadPart;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync off += pBuildPagingBuffer->Transfer.TransferOffset;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pBody->fFlags |= VBOXVDMACMD_DMA_BPB_TRANSFER_F_DST_VRAMOFFSET;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync UINT index = pBuildPagingBuffer->Transfer.MdlOffset + (UINT)(cbTransfered>>12);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pBody->Dst.phBuf = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Destination.pMdl)[index] << 12;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync PFN_NUMBER num = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Destination.pMdl)[index];
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync for (UINT i = 1; i < ((cbTransferSize - cbTransfered + 0xfff) >> 12); ++i)
38b63f3439b83c64725f86f987a02845f918e47avboxsync PFN_NUMBER cur = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Destination.pMdl)[index+i];
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync cbCurTransfer = RT_MIN(cbTransferSize - cbTransfered, cSrcPages << 12);
c7d2f5508ab9703a7a6c5cce5c9d4bf335af660avboxsync cbCurTransfer = RT_MIN(cbCurTransfer, cDstPages << 12);
42a1dd73c2da9540a7fe4abdb20f8a5cd1d1f961vboxsync int rc = vboxVdmaCBufDrSubmitSynch(pDevExt, &pDevExt->u.primary.Vdma, pDr);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync /* @todo: try flushing.. */
c7d2f5508ab9703a7a6c5cce5c9d4bf335af660avboxsync#endif /* #ifdef VBOX_WITH_VDMA */
656859094eb6056e3ab7e9cd8fb51a799d125ffcvboxsync PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->Fill.hAllocation;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync// pBuildPagingBuffer->pDmaBuffer = (uint8_t*)pBuildPagingBuffer->pDmaBuffer + VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_BPB_FILL);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync// AssertBreakpoint();
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync WARN(("unsupported op (%d)", pBuildPagingBuffer->Operation));
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pBuildPagingBuffer->pDmaBuffer = ((uint8_t*)pBuildPagingBuffer->pDmaBuffer) + cbCmdDma;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync /* @todo: fixme: implement */
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsyncBOOL vboxWddmPointerCopyColorData(CONST DXGKARG_SETPOINTERSHAPE* pSetPointerShape, PVIDEO_POINTER_ATTRIBUTES pPointerAttributes)
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync /* truncate masks if we exceed supported size */
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pPointerAttributes->Width = min(srcMaskW, VBOXWDDM_C_POINTER_MAX_WIDTH);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pPointerAttributes->Height = min(srcMaskH, VBOXWDDM_C_POINTER_MAX_HEIGHT);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pPointerAttributes->WidthInBytes = pPointerAttributes->Width * 4;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync /* cnstruct and mask from alpha color channel */
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync /* sanity check */
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync uint32_t cbData = RT_ALIGN_T(dstBytesPerLine*pPointerAttributes->Height, 4, ULONG)+
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pPointerAttributes->Height*pPointerAttributes->WidthInBytes;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync uint32_t cbPointerAttributes = RT_OFFSETOF(VIDEO_POINTER_ATTRIBUTES, Pixels[cbData]);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync Assert(VBOXWDDM_POINTER_ATTRIBUTES_SIZE >= cbPointerAttributes);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync if (VBOXWDDM_POINTER_ATTRIBUTES_SIZE < cbPointerAttributes)
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync LOGREL(("VBOXWDDM_POINTER_ATTRIBUTES_SIZE(%d) < cbPointerAttributes(%d)", VBOXWDDM_POINTER_ATTRIBUTES_SIZE, cbPointerAttributes));
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync memset(pDst, 0xFF, dstBytesPerLine*pPointerAttributes->Height);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync for (x=0, bit=7; x<pPointerAttributes->Width; ++x, --bit)
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync if (pSrc[y*pSetPointerShape->Pitch + x*4 + 3] > 0x7F)
c7d2f5508ab9703a7a6c5cce5c9d4bf335af660avboxsync /* copy 32bpp to XOR DIB, it start in pPointerAttributes->Pixels should be 4bytes aligned */
c7d2f5508ab9703a7a6c5cce5c9d4bf335af660avboxsync pDst = pPointerAttributes->Pixels + RT_ALIGN_T(dstBytesPerLine*pPointerAttributes->Height, 4, ULONG);
c7d2f5508ab9703a7a6c5cce5c9d4bf335af660avboxsync memcpy(pDst+y*dstBytesPerLine, pSrc+y*pSetPointerShape->Pitch, dstBytesPerLine);
c7d2f5508ab9703a7a6c5cce5c9d4bf335af660avboxsyncBOOL vboxWddmPointerCopyMonoData(CONST DXGKARG_SETPOINTERSHAPE* pSetPointerShape, PVIDEO_POINTER_ATTRIBUTES pPointerAttributes)
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync /* truncate masks if we exceed supported size */
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pPointerAttributes->Width = min(srcMaskW, VBOXWDDM_C_POINTER_MAX_WIDTH);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pPointerAttributes->Height = min(srcMaskH, VBOXWDDM_C_POINTER_MAX_HEIGHT);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pPointerAttributes->WidthInBytes = pPointerAttributes->Width * 4;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync /* copy AND mask */
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync memcpy(pDst+y*dstBytesPerLine, pSrc+y*pSetPointerShape->Pitch, dstBytesPerLine);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync /* convert XOR mask to RGB0 DIB, it start in pPointerAttributes->Pixels should be 4bytes aligned */
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pSrc = (BYTE*)pSetPointerShape->pPixels + srcMaskH*pSetPointerShape->Pitch;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pDst = pPointerAttributes->Pixels + RT_ALIGN_T(dstBytesPerLine*pPointerAttributes->Height, 4, ULONG);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync for (x=0, bit=7; x<pPointerAttributes->Width; ++x, --bit)
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync *(ULONG*)&pDst[y*dstBytesPerLine+x*4] = (pSrc[y*pSetPointerShape->Pitch+x/8] & RT_BIT(bit)) ? 0x00FFFFFF : 0;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsyncstatic BOOLEAN vboxVddmPointerShapeToAttributes(CONST DXGKARG_SETPOINTERSHAPE* pSetPointerShape, PVBOXWDDM_POINTER_INFO pPointerInfo)
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync PVIDEO_POINTER_ATTRIBUTES pPointerAttributes = &pPointerInfo->Attributes.data;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync /* pPointerAttributes maintains the visibility state, clear all except visibility */
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pPointerAttributes->Enable &= VBOX_MOUSE_POINTER_VISIBLE;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync Assert(pSetPointerShape->Flags.Value == 1 || pSetPointerShape->Flags.Value == 2);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync if (vboxWddmPointerCopyColorData(pSetPointerShape, pPointerAttributes))
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pPointerAttributes->Flags = VIDEO_MODE_COLOR_POINTER;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync pPointerAttributes->Enable |= VBOX_MOUSE_POINTER_ALPHA;
c30683beea9ebd049c548102f74645cf018daa23vboxsync if (vboxWddmPointerCopyMonoData(pSetPointerShape, pPointerAttributes))
c30683beea9ebd049c548102f74645cf018daa23vboxsync pPointerAttributes->Flags = VIDEO_MODE_MONO_POINTER;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("unsupported pointer type Flags.Value(0x%x)", pSetPointerShape->Flags.Value));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Enable |= VBOX_MOUSE_POINTER_SHAPE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * The hot spot coordinates and alpha flag will be encoded in the pPointerAttributes::Enable field.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * High word will contain hot spot info and low word - flags.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Enable |= (pSetPointerShape->YHot & 0xFF) << 24;
384478d3896257fbce9ceb8c01e74040b969e6d7vboxsync pPointerAttributes->Enable |= (pSetPointerShape->XHot & 0xFF) << 16;
706ec8d33965b04fc59fb0b1b0981b81ae23600dvboxsync CONST DXGKARG_SETPOINTERPOSITION* pSetPointerPosition)
706ec8d33965b04fc59fb0b1b0981b81ae23600dvboxsync// LOGF(("ENTER, hAdapter(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* mouse integration is ON */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_POINTER_INFO pPointerInfo = &pDevExt->aSources[pSetPointerPosition->VidPnSourceId].PointerInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_GLOBAL_POINTER_INFO pGlobalPointerInfo = &pDevExt->PointerInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVIDEO_POINTER_ATTRIBUTES pPointerAttributes = &pPointerInfo->Attributes.data;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync BOOLEAN fScreenVisState = !!(pPointerAttributes->Enable & VBOX_MOUSE_POINTER_VISIBLE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync BOOLEAN fScreenChanged = pGlobalPointerInfo->iLastReportedScreen != pSetPointerPosition->VidPnSourceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Enable |= VBOX_MOUSE_POINTER_VISIBLE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Enable &= ~VBOX_MOUSE_POINTER_VISIBLE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pGlobalPointerInfo->iLastReportedScreen = pSetPointerPosition->VidPnSourceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if ((fVisStateChanged || fScreenChanged) && VBoxQueryHostWantsAbsolute())
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync BOOLEAN bResult = VBoxMPCmnUpdatePointerShape(VBoxCommonFromDeviceExt(pDevExt), &pPointerInfo->Attributes.data, VBOXWDDM_POINTER_ATTRIBUTES_SIZE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // tell the host to use the guest's pointer
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* Visible and No Shape means Show the pointer.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * It is enough to init only this field.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PointerAttributes.Enable = pSetPointerPosition->Flags.Visible ? VBOX_MOUSE_POINTER_VISIBLE : 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync BOOLEAN bResult = VBoxMPCmnUpdatePointerShape(VBoxCommonFromDeviceExt(pDevExt), &PointerAttributes, sizeof (PointerAttributes));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, hAdapter(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, hAdapter(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* mouse integration is ON */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_POINTER_INFO pPointerInfo = &pDevExt->aSources[pSetPointerShape->VidPnSourceId].PointerInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: to avoid extra data copy and extra heap allocation,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * need to maintain the pre-allocated HGSMI buffer and convert the data directly to it */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (vboxVddmPointerShapeToAttributes(pSetPointerShape, pPointerInfo))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->PointerInfo.iLastReportedScreen = pSetPointerShape->VidPnSourceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (VBoxMPCmnUpdatePointerShape(VBoxCommonFromDeviceExt(pDevExt), &pPointerInfo->Attributes.data, VBOXWDDM_POINTER_ATTRIBUTES_SIZE))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, hAdapter(0x%x)", hAdapter));
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync /* @todo: fixme: implement */
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync/* the lpRgnData->Buffer comes to us as RECT
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync * to avoid extra memcpy we cast it to PRTRECT assuming
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync * they are identical */
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsyncAssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(RTRECT, xLeft));
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsyncAssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(RTRECT, yBottom));
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsyncAssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(RTRECT, xRight));
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsyncAssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(RTRECT, yTop));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, hAdapter(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE pEscapeHdr = (PVBOXDISPIFESCAPE)pEscape->pPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_UHGSMI_SUBMIT not supported for CmdVbva mode"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* submit VBOXUHGSMI command */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE_UHGSMI_SUBMIT pSubmit = (PVBOXDISPIFESCAPE_UHGSMI_SUBMIT)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_UHGSMI_SUBMIT)
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync && pEscape->PrivateDriverDataSize == RT_OFFSETOF(VBOXDISPIFESCAPE_UHGSMI_SUBMIT, aBuffers[pEscapeHdr->u32CmdSpecific]));
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync if (pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD)
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync && pEscape->PrivateDriverDataSize == RT_OFFSETOF(VBOXDISPIFESCAPE_UHGSMI_SUBMIT, aBuffers[pEscapeHdr->u32CmdSpecific]))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVideoAMgrCtxAllocSubmit(pDevExt, &pContext->AllocContext, pEscapeHdr->u32CmdSpecific, pSubmit->aBuffers);
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync /* allocate VBOXUHGSMI buffer */
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync WARN(("VBOXESC_UHGSMI_ALLOCATE not supported for CmdVbva mode"));
441b60f8b0601cc1718368c9c3ef082223ad12a2vboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync PVBOXDISPIFESCAPE_UHGSMI_ALLOCATE pAlocate = (PVBOXDISPIFESCAPE_UHGSMI_ALLOCATE)pEscapeHdr;
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync Assert(pEscape->PrivateDriverDataSize == sizeof (VBOXDISPIFESCAPE_UHGSMI_ALLOCATE));
c7d2f5508ab9703a7a6c5cce5c9d4bf335af660avboxsync if (pEscape->PrivateDriverDataSize == sizeof (VBOXDISPIFESCAPE_UHGSMI_ALLOCATE))
dfec9ba035ff0c77d470041bc230a60542d39e27vboxsync Status = vboxVideoAMgrCtxAllocCreate(&pContext->AllocContext, &pAlocate->Alloc);
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync WARN(("VBOXESC_UHGSMI_DEALLOCATE not supported for CmdVbva mode"));
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync /* deallocate VBOXUHGSMI buffer */
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync PVBOXDISPIFESCAPE_UHGSMI_DEALLOCATE pDealocate = (PVBOXDISPIFESCAPE_UHGSMI_DEALLOCATE)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pEscape->PrivateDriverDataSize == sizeof (VBOXDISPIFESCAPE_UHGSMI_DEALLOCATE));
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync if (pEscape->PrivateDriverDataSize == sizeof (VBOXDISPIFESCAPE_UHGSMI_DEALLOCATE))
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync Status = vboxVideoAMgrCtxAllocDestroy(&pContext->AllocContext, pDealocate->hAlloc);
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync WARN(("VBOXESC_CRHGSMICTLCON_CALL not supported for CmdVbva mode"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync PVBOXDISPIFESCAPE_CRHGSMICTLCON_CALL pCall = (PVBOXDISPIFESCAPE_CRHGSMICTLCON_CALL)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize >= sizeof (*pCall))
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync /* this is true due to the above condition */
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync Assert(pEscape->PrivateDriverDataSize > RT_OFFSETOF(VBOXDISPIFESCAPE_CRHGSMICTLCON_CALL, CallInfo));
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync int rc = VBoxMpCrCtlConCallUserData(&pDevExt->CrCtlCon, &pCall->CallInfo, pEscape->PrivateDriverDataSize - RT_OFFSETOF(VBOXDISPIFESCAPE_CRHGSMICTLCON_CALL, CallInfo));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = STATUS_SUCCESS; /* <- always return success here, otherwise the private data buffer modifications
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync * i.e. rc status stored in u32CmdSpecific will not be copied to user mode */
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync if (pEscape->PrivateDriverDataSize == sizeof (*pEscapeHdr))
340ee06f35257fee1bd68223ab3504cf2b1d0c3evboxsync pEscapeHdr->u32CmdSpecific = pContext->u32CrConClientID;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize == sizeof (*pEscapeHdr))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pEscapeHdr->u32CmdSpecific = VBoxMpCrGetHostCaps();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync WARN(("VBOXESC_SETVISIBLEREGION no context supplied!"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_SEAMLESS)
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync WARN(("VBOXESC_SETVISIBLEREGION invalid context supplied %d!", pContext->enmType));
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync /* visible regions for seamless */
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync LPRGNDATA lpRgnData = VBOXDISPIFESCAPE_DATA(pEscapeHdr, RGNDATA);
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync uint32_t cbData = VBOXDISPIFESCAPE_DATA_SIZE(pEscape->PrivateDriverDataSize);
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync uint32_t cbRects = cbData - RT_OFFSETOF(RGNDATA, Buffer);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* the lpRgnData->Buffer comes to us as RECT
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync * to avoid extra memcpy we cast it to PRTRECT assuming
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync * they are identical
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync * see AssertCompile's above */
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync LOG(("IOCTL_VIDEO_VBOX_SETVISIBLEREGION cRects=%d", cRects));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Inform the host about the visible region
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync sizeof (VMMDevVideoSetVisibleRegion) + (cRects-1)*sizeof(RTRECT),
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_SETVISIBLEREGION: incorrect buffer size (%d), reported count (%d)", cbRects, lpRgnData->rdh.nCount));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: implement */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* set swapchain information */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_SETCTXHOSTID: no context specified"));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE))
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("VBOXESC_SETCTXHOSTID: invalid data size %d", pEscape->PrivateDriverDataSize));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync int32_t hostID = (int32_t)pEscapeHdr->u32CmdSpecific;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("VBOXESC_SETCTXHOSTID: invalid hostID %d", hostID));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("VBOXESC_SETCTXHOSTID: context already has hostID specified"));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync /* set swapchain information */
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync Status = vboxWddmSwapchainCtxEscape(pDevExt, pContext, (PVBOXDISPIFESCAPE_SWAPCHAININFO)pEscapeHdr, pEscape->PrivateDriverDataSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_REINITVIDEOMODESBYMASK called without HardwareAccess flag set, failing"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* win8.1 does not allow context-based escapes for display-only mode */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_REINITVIDEOMODES no context supplied!"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_REINITVIDEOMODES invalid context supplied %d!", pContext->enmType));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_REINITVIDEOMODESBYMASK should be called instead"));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("VBOXESC_REINITVIDEOMODESBYMASK called without HardwareAccess flag set, failing"));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync /* win8.1 does not allow context-based escapes for display-only mode */
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("VBOXESC_REINITVIDEOMODESBYMASK no context supplied!"));
329df9696e709dc71611f504a4774f323545be0avboxsync if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_REINITVIDEOMODESBYMASK invalid context supplied %d!", pContext->enmType));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK))
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync WARN(("invalid private driver size %d", pEscape->PrivateDriverDataSize));
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync PVBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK pData = (PVBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK)pEscapeHdr;
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync VBoxWddmUpdateVideoModesInfoByMask(pDevExt, pData->ScreenMask);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_CONFIGURETARGETS called without HardwareAccess flag set, failing"));
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync /* win8.1 does not allow context-based escapes for display-only mode */
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync WARN(("VBOXESC_CONFIGURETARGETS no context supplied!"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_CONFIGURETARGETS invalid context supplied %d!", pContext->enmType));
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync if (pEscape->PrivateDriverDataSize != sizeof (*pEscapeHdr))
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync WARN(("VBOXESC_CONFIGURETARGETS invalid private driver size %d", pEscape->PrivateDriverDataSize));
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync WARN(("VBOXESC_CONFIGURETARGETS invalid command %d", pEscapeHdr->u32CmdSpecific));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync Status = vboxWddmChildStatusConnect(pDevExt, (uint32_t)i, TRUE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_CONFIGURETARGETS vboxWddmChildStatusConnectSecondaries failed Status 0x%x\n", Status));
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync Status = IoOpenDeviceRegistryKey(pDevExt->pPDO, PLUGPLAY_REGKEY_DRIVER, GENERIC_WRITE, &hKey);
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync WARN(("VBOXESC_CONFIGURETARGETS IoOpenDeviceRegistryKey failed, Status = 0x%x", Status));
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync swprintf(aNameBuf, L"%s%d", VBOXWDDM_REG_DRV_DISPFLAGS_PREFIX, i);
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync Status = vboxWddmRegSetValueDword(hKey, aNameBuf, VBOXWDDM_CFG_DRVTARGET_CONNECTED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_CONFIGURETARGETS vboxWddmRegSetValueDword (%d) failed Status 0x%x\n", aNameBuf, Status));
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync WARN(("VBOXESC_ADJUSTVIDEOMODES called without HardwareAccess flag set, failing"));
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync if (cModes > VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(VBOXDISPIFESCAPE_ADJUSTVIDEOMODES, aScreenInfos)
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync || pEscape->PrivateDriverDataSize != RT_OFFSETOF(VBOXDISPIFESCAPE_ADJUSTVIDEOMODES, aScreenInfos[cModes]))
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync PVBOXDISPIFESCAPE_ADJUSTVIDEOMODES pPodesInfo = (PVBOXDISPIFESCAPE_ADJUSTVIDEOMODES)pEscapeHdr;
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync VBoxWddmAdjustModes(pDevExt, cModes, pPodesInfo->aScreenInfos);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)pEscape->hDevice;
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync WARN(("VBOXESC_SETALLOCHOSTID called without no device specified, failing"));
d8785fca8584018f549392623631ba4ba5ef2429vboxsync if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_SETALLOCHOSTID))
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync WARN(("invalid buffer size for VBOXDISPIFESCAPE_SHRC_REF, was(%d), but expected (%d)",
7b4ea63789001468ec3662bdfcd6432bf89095dfvboxsync pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE_SHRC_REF)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_SETALLOCHOSTID not HardwareAccess"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE_SETALLOCHOSTID pSetHostID = (PVBOXDISPIFESCAPE_SETALLOCHOSTID)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromHandle(pDevExt, (D3DKMT_HANDLE)pSetHostID->hAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("setHostID: invalid allocation type: %d", pAlloc->enmType));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSetHostID->rc = VBoxWddmOaSetHostID(pDevice, pAlloc, pSetHostID->hostID, &pSetHostID->EscapeHdr.u32CmdSpecific);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAlloc->AllocData.SurfDesc.VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pSource->AllocData.hostID != pAlloc->AllocData.hostID)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSource->AllocData.hostID = pAlloc->AllocData.hostID;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)pEscape->hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("VBOXESC_SHRC_ADDREF|VBOXESC_SHRC_RELEASE called without no device specified, failing"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* query whether the allocation represanted by the given [wine-generated] shared resource handle still exists */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_SHRC_REF))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("invalid buffer size for VBOXDISPIFESCAPE_SHRC_REF, was(%d), but expected (%d)",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE_SHRC_REF)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE_SHRC_REF pShRcRef = (PVBOXDISPIFESCAPE_SHRC_REF)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromHandle(pDevExt, (D3DKMT_HANDLE)pShRcRef->hAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_OPENALLOCATION pOa = VBoxWddmOaSearch(pDevice, pAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("failed to get open allocation from alloc"));
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync pShRcRef->EscapeHdr.u32CmdSpecific = pAlloc->cShRcRefs;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_ISANYX))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("invalid private driver size %d", pEscape->PrivateDriverDataSize));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE_ISANYX pIsAnyX = (PVBOXDISPIFESCAPE_ISANYX)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pIsAnyX->u32IsAnyX = VBoxCommonFromDeviceExt(pDevExt)->fAnyX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* use RT_OFFSETOF instead of sizeof since sizeof will give an aligned size that might
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * be bigger than the VBOXDISPIFESCAPE_DBGPRINT with a data containing just a few chars */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pEscape->PrivateDriverDataSize >= RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, aStringBuf[1]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* only do DbgPrint when pEscape->PrivateDriverDataSize > RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, aStringBuf[1])
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * since == RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, aStringBuf[1]) means the buffer contains just \0,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * i.e. no need to print it */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize > RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, aStringBuf[1]))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE_DBGPRINT pDbgPrint = (PVBOXDISPIFESCAPE_DBGPRINT)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* ensure the last char is \0*/
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync *((uint8_t*)pDbgPrint + pEscape->PrivateDriverDataSize - 1) = '\0';
2fe5df8729b1c38fba7008d323bddf7988438ed2vboxsync Status = vboxUmdDumpBuf((PVBOXDISPIFESCAPE_DBGDUMPBUF)pEscapeHdr, pEscape->PrivateDriverDataSize);
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync WARN(("unsupported escape code (0x%x)", pEscapeHdr->escapeCode));
105b1a31b6037dbe14acb8d09e60da540885202bvboxsync WARN(("pEscape->PrivateDriverDataSize(%d) < (%d)", pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, hAdapter(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync} VBOXWDDM_QUERYCURFENCE_CB, *PVBOXWDDM_QUERYCURFENCE_CB;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic BOOLEAN vboxWddmQueryCurrentFenceCb(PVOID Context)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_QUERYCURFENCE_CB pdc = (PVBOXWDDM_QUERYCURFENCE_CB)Context;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync BOOL bRc = DxgkDdiInterruptRoutineLegacy(pDevExt, pdc->MessageNumber);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pdc->uLastCompletedCmdFenceId = pDevExt->u.primary.Vdma.uLastCompletedPagingBufferCmdFenceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCurrentFence->CurrentFence = VBoxCmdVbvaCheckCompleted(pDevExt, &pDevExt->CmdVbva, false);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 0, /* IN ULONG MessageNumber */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCurrentFence->CurrentFence = context.uLastCompletedCmdFenceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiIsSupportedVidPn should be made pageable. */
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync PVBOXMP_DEVEXT pContext = (PVBOXMP_DEVEXT)hAdapter;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync Status = pContext->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pIsSupportedVidPnArg->hDesiredVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync WARN(("DxgkCbQueryVidPnInterface failed Status()0x%x\n", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVidPnDumpVidPn("\n>>>>IS SUPPORTED VidPN : >>>>", pContext, pIsSupportedVidPnArg->hDesiredVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<");
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync Status = pVidPnInterface->pfnGetTopology(pIsSupportedVidPnArg->hDesiredVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync WARN(("pfnGetTopology failed Status()0x%x\n", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVidPnCheckTopology(hVidPnTopology, pVidPnTopologyInterface, &fSupported);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync WARN(("vboxVidPnCheckTopology failed Status()0x%x\n", Status));
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync pIsSupportedVidPnArg->IsVidPnSupported = fSupported;
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync LOGREL(("The Given VidPn is %ssupported\n", pIsSupportedVidPnArg->IsVidPnSupported ? "" : "!!NOT!! "));
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync CONST DXGKARG_RECOMMENDFUNCTIONALVIDPN* CONST pRecommendFunctionalVidPnArg
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync /* The DxgkDdiRecommendFunctionalVidPn should be made pageable. */
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync PVBOXWDDM_RECOMMENDVIDPN pVidPnInfo = pRecommendFunctionalVidPnArg->PrivateDriverDataSize >= sizeof (VBOXWDDM_RECOMMENDVIDPN) ?
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync (PVBOXWDDM_RECOMMENDVIDPN)pRecommendFunctionalVidPnArg->pPrivateDriverData : NULL;
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmGetAllVideoModesInfos(pDevExt);
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync /* @todo: check that we actually need the current source->target */
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync VIDEO_MODE_INFORMATION *pModeInfo = &pInfo->aModes[pInfo->iPreferredMode];
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync Status = vboxVidPnCheckAddMonitorModes(pDevExt, i, D3DKMDT_MCO_DRIVER, &Resolution, 1, 0);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync Status = vboxVidPnCheckAddMonitorModes(pDevExt, i, D3DKMDT_MCO_DRIVER, pInfo->aResolutions, pInfo->cResolutions, pInfo->iPreferredResolution);
4a9af9a8062589b741444d717d2dd1ed22b0f583vboxsync WARN(("vboxVidPnCheckAddMonitorModes failed Status(0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("DxgkCbQueryVidPnInterface failed Status(0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVidPnPathAdd(pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, pVidPnInterface, i, i);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxVidPnPathAdd failed Status(0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync VIDEO_MODE_INFORMATION *pModeInfo = &pInfo->aModes[pInfo->iPreferredMode];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = VBoxWddmGetModesForResolution(pInfo->aModes, pInfo->cModes, pInfo->iPreferredMode, &Resolution,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pResModes, cResModes, &cActualResModes, &iPreferableResMode);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(Status == STATUS_SUCCESS || Status == STATUS_BUFFER_TOO_SMALL);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pResModes = (VIDEO_MODE_INFORMATION*)vboxWddmMemAllocZero(sizeof (*pResModes) * cActualResModes);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = VBoxWddmGetModesForResolution(pInfo->aModes, pInfo->cModes, pInfo->iPreferredMode, &Resolution,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pResModes, cResModes, &cActualResModes, &iPreferableResMode);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVidPnCreatePopulateVidPnPathFromLegacy(pDevExt, pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, pVidPnInterface,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync i, i); /* srcId, tgtId */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("vboxVidPnCreatePopulateVidPnFromLegacy failed Status(0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVidPnDumpVidPn("\n>>>>Recommended VidPN: >>>>", pDevExt, pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n");
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CONST DXGKARG_ENUMVIDPNCOFUNCMODALITY* CONST pEnumCofuncModalityArg
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiEnumVidPnCofuncModality function should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pEnumCofuncModalityArg->hConstrainingVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("DxgkCbQueryVidPnInterface failed Status()0x%x\n", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVidPnDumpCofuncModalityArg(">>>>MODALITY Args: ", pEnumCofuncModalityArg, "\n");
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVidPnDumpVidPn(">>>>MODALITY VidPN (IN) : >>>>\n", pDevExt, pEnumCofuncModalityArg->hConstrainingVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n");
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = pVidPnInterface->pfnGetTopology(pEnumCofuncModalityArg->hConstrainingVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("pfnGetTopology failed Status()0x%x\n", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVidPnCheckTopology(hVidPnTopology, pVidPnTopologyInterface, &fSupported);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxVidPnCheckTopology failed Status()0x%x\n", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CbContext.pEnumCofuncModalityArg = pEnumCofuncModalityArg;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CbContext.pInfos = VBoxWddmGetAllVideoModesInfos(pDevExt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxVidPnEnumPaths failed Status()0x%x\n", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxVidPnCofuncModalityPathEnum failed Status()0x%x\n", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVidPnDumpVidPn("\n>>>>MODALITY VidPN (OUT) : >>>>\n", pDevExt, pEnumCofuncModalityArg->hConstrainingVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n\n");
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync CONST DXGKARG_SETVIDPNSOURCEADDRESS* pSetVidPnSourceAddress
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync /* The DxgkDdiSetVidPnSourceAddress function should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays > pSetVidPnSourceAddress->VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pSetVidPnSourceAddress->VidPnSourceId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceAddress->VidPnSourceId, &Pos);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (memcmp(&pSource->VScreenPos, &Pos, sizeof (Pos)))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if ((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays <= pSetVidPnSourceAddress->VidPnSourceId)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("invalid VidPnSourceId (%d), for displays(%d)", pSetVidPnSourceAddress->VidPnSourceId, VBoxCommonFromDeviceExt(pDevExt)->cDisplays));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pSetVidPnSourceAddress->hAllocation || pSource->pPrimaryAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert (pSetVidPnSourceAddress->Flags.Value < 2); /* i.e. 0 or 1 (ModeChange) */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation = (PVBOXWDDM_ALLOCATION)pSetVidPnSourceAddress->hAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAssignPrimary(pSource, pAllocation, pSetVidPnSourceAddress->VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAddrSetVram(&pAllocation->AllocData.Addr, pSetVidPnSourceAddress->PrimarySegment, (VBOXVIDEOOFFSET)pSetVidPnSourceAddress->PrimaryAddress.QuadPart);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* the VRAM here is an absolute address, nto an offset!
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync * convert to offset since all internal VBox functionality is offset-based */
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync vboxWddmAddrSetVram(&pSource->AllocData.Addr, pSetVidPnSourceAddress->PrimarySegment,
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync vboxWddmVramAddrToOffset(pDevExt, pSetVidPnSourceAddress->PrimaryAddress));
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync vboxWddmAddrSetVram(&pSource->AllocData.Addr, pSetVidPnSourceAddress->PrimarySegment,
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync CONST DXGKARG_SETVIDPNSOURCEVISIBILITY* pSetVidPnSourceVisibility
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync /* DxgkDdiSetVidPnSourceVisibility should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays > pSetVidPnSourceVisibility->VidPnSourceId);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pSetVidPnSourceVisibility->VidPnSourceId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId, &Pos);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync if (memcmp(&pSource->VScreenPos, &Pos, sizeof (Pos)))
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync if ((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays <= pSetVidPnSourceVisibility->VidPnSourceId)
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync WARN(("invalid VidPnSourceId (%d), for displays(%d)", pSetVidPnSourceVisibility->VidPnSourceId, VBoxCommonFromDeviceExt(pDevExt)->cDisplays));
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync PVBOXWDDM_ALLOCATION pAllocation = pSource->pPrimaryAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAllocation->bVisible == pSource->bVisible);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->bVisible = pSetVidPnSourceVisibility->Visible;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pSource->bVisible != pSetVidPnSourceVisibility->Visible)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSource->bVisible = pSetVidPnSourceVisibility->Visible;
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync// pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// if (pDevExt->fCmdVbvaEnabled || pSource->bVisible)
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync// vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_SOURCE *paSources = (VBOXWDDM_SOURCE*)RTMemAlloc(sizeof (VBOXWDDM_SOURCE) * VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync VBOXWDDM_TARGET *paTargets = (VBOXWDDM_TARGET*)RTMemAlloc(sizeof (VBOXWDDM_TARGET) * VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync VBoxVidPnSourcesInit(paSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync VBoxVidPnTargetsInit(paTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync VBoxVidPnSourcesCopy(paSources, pDevExt->aSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync VBoxVidPnTargetsCopy(paTargets, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL;
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pCommitVidPnArg->hFunctionalVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync WARN(("DxgkCbQueryVidPnInterface failed Status 0x%x", Status));
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync vboxVidPnDumpVidPn("\n>>>>COMMIT VidPN: >>>>", pDevExt, pCommitVidPnArg->hFunctionalVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n");
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pCommitVidPnArg->AffectedVidPnSourceId != D3DDDI_ID_ALL)
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync pCommitVidPnArg->hFunctionalVidPn, pVidPnInterface,
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync (PVBOXWDDM_ALLOCATION)pCommitVidPnArg->hPrimaryAllocation,
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync pCommitVidPnArg->AffectedVidPnSourceId, paSources, paTargets);
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync WARN(("VBoxVidPnCommitSourceModeForSrcId for current VidPn failed Status 0x%x", Status));
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync Status = VBoxVidPnCommitAll(pDevExt, pCommitVidPnArg->hFunctionalVidPn, pVidPnInterface,
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync (PVBOXWDDM_ALLOCATION)pCommitVidPnArg->hPrimaryAllocation,
8a33c8d4750c261fcee3537fb4d23abf313375cdvboxsync WARN(("VBoxVidPnCommitAll for current VidPn failed Status 0x%x", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->u.primary.hCommittedVidPn = pCommitVidPnArg->hFunctionalVidPn;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVidPnSourcesCopy(pDevExt->aSources, paSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVidPnTargetsCopy(pDevExt->aTargets, paTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CONST DXGKARG_UPDATEACTIVEVIDPNPRESENTPATH* CONST pUpdateActiveVidPnPresentPathArg
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CONST DXGKARG_RECOMMENDMONITORMODES* CONST pRecommendMonitorModesArg
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_VIDEOMODES_INFO pInfo = VBoxWddmGetVideoModesInfo(pDevExt, pRecommendMonitorModesArg->VideoPresentTargetId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVIDEO_MODE_INFORMATION pPreferredMode = &pInfo->aModes[pInfo->iPreferredMode];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DKMDT_MONITOR_SOURCE_MODE * pNewMonitorSourceModeInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = pRecommendMonitorModesArg->pMonitorSourceModeSetInterface->pfnCreateNewModeInfo(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRecommendMonitorModesArg->hMonitorSourceModeSet, &pNewMonitorSourceModeInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVidPnPopulateMonitorSourceModeInfoFromLegacy(pDevExt,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPreferredMode->VisScreenWidth == pInfo->aResolutions[i].cx
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pPreferredMode->VisScreenHeight == pInfo->aResolutions[i].cy);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = pRecommendMonitorModesArg->pMonitorSourceModeSetInterface->pfnAddMode(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRecommendMonitorModesArg->hMonitorSourceModeSet, pNewMonitorSourceModeInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* error has occurred, release & break */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRecommendMonitorModesArg->pMonitorSourceModeSetInterface->pfnReleaseModeInfo(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRecommendMonitorModesArg->hMonitorSourceModeSet, pNewMonitorSourceModeInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CONST DXGKARG_RECOMMENDVIDPNTOPOLOGY* CONST pRecommendVidPnTopologyArg
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = VBoxWddmSlGetScanLine(pDevExt, pGetScanLine);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = VBoxWddmSlEnableVSyncNotification(pDevExt, Enable);
87150caf549846b0edba30c50dabe5092df70b5fvboxsync WARN(("VSYNC Interrupt control failed Enable(%d), Status(0x%x)", Enable, Status));
9c21eebec4d70f1e638002c8dfc6ea9d534d8710vboxsync WARN(("Unexpected interrupt type! %d", InterruptType));
9c21eebec4d70f1e638002c8dfc6ea9d534d8710vboxsync WARN(("UNSUPPORTED interrupt type! %d", InterruptType));
87150caf549846b0edba30c50dabe5092df70b5fvboxsync PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)vboxWddmMemAllocZero(sizeof (VBOXWDDM_OVERLAY));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = vboxVhwaHlpOverlayCreate(pDevExt, pCreateOverlay->VidPnSourceId, &pCreateOverlay->OverlayInfo, pOverlay);
9c21eebec4d70f1e638002c8dfc6ea9d534d8710vboxsync /* DxgkDdiDestroyDevice should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiOpenAllocation
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync /* DxgkDdiOpenAllocation should be made pageable. */
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pOpenAllocation->PrivateDriverSize == sizeof (VBOXWDDM_RCINFO))
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pRcInfo = (PVBOXWDDM_RCINFO)pOpenAllocation->pPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRcInfo->cAllocInfos == pOpenAllocation->NumAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("Invalid PrivateDriverSize %d", pOpenAllocation->PrivateDriverSize));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_OPENALLOCATIONINFO* pInfo = &pOpenAllocation->pOpenAllocation[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAllocation = vboxWddmGetAllocationFromHandle(pDevExt, pInfo->hAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pInfo->PrivateDriverDataSize != sizeof (VBOXWDDM_ALLOCINFO)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
87150caf549846b0edba30c50dabe5092df70b5fvboxsync /* we have queried host for some surface info, like pitch & size,
09f4b412099acda62997fd82c8608075c453b3ebvboxsync * need to return it back to the UMD (User Mode Drive) */
09f4b412099acda62997fd82c8608075c453b3ebvboxsync pAllocInfo->SurfDesc = pAllocation->AllocData.SurfDesc;
87150caf549846b0edba30c50dabe5092df70b5fvboxsync /* success, just continue */
09f4b412099acda62997fd82c8608075c453b3ebvboxsync KeAcquireSpinLock(&pAllocation->OpenLock, &OldIrql);
09f4b412099acda62997fd82c8608075c453b3ebvboxsync pOa = VBoxWddmOaSearchLocked(pDevice, pAllocation);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync pOa = (PVBOXWDDM_OPENALLOCATION)vboxWddmMemAllocZero(sizeof (VBOXWDDM_OPENALLOCATION));
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync KeAcquireSpinLock(&pAllocation->OpenLock, &OldIrql);
87150caf549846b0edba30c50dabe5092df70b5fvboxsync pConcurrentOa = VBoxWddmOaSearchLocked(pDevice, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync InsertHeadList(&pAllocation->OpenList, &pOa->ListEntry);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT j = 0; j < i; ++j)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_OPENALLOCATIONINFO* pInfo2Free = &pOpenAllocation->pOpenAllocation[j];
3fa7a7e633f46a212052b510cdb8cee41f279a67vboxsync PVBOXWDDM_OPENALLOCATION pOa2Free = (PVBOXWDDM_OPENALLOCATION)pInfo2Free->hDeviceSpecificAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiCloseAllocation should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < pCloseAllocation->NumAllocations; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_OPENALLOCATION pOa2Free = (PVBOXWDDM_OPENALLOCATION)pCloseAllocation->pOpenHandleList[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAllocation = pOa2Free->pAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAllocation->cShRcRefs >= pOa2Free->cShRcRefs);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, hContext(0x%x)", hContext));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (pRender->DmaBufferPrivateDataSize < sizeof (VBOXCMDVBVA_HDR))
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("pRender->DmaBufferPrivateDataSize(%d) < sizeof VBOXCMDVBVA_HDR (%d)",
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->DmaBufferPrivateDataSize , sizeof (VBOXCMDVBVA_HDR)));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync /* @todo: can this actually happen? what status to return? */
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (pRender->CommandLength < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (pRender->PatchLocationListOutSize < pRender->AllocationListSize)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("pRender->PatchLocationListOutSize(%d) < pRender->AllocationListSize(%d)",
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->PatchLocationListOutSize, pRender->AllocationListSize));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pInputHdr = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)pRender->pCommand;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync VBOXCMDVBVA_HDR* pCmd = (VBOXCMDVBVA_HDR*)pRender->pDmaBufferPrivateData;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync if (pRender->AllocationListSize >= (UINT32_MAX - RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, aBufInfos))/ RT_SIZEOFMEMB(VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, aBufInfos[0]))
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("Invalid AllocationListSize %d", pRender->AllocationListSize));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync if (pRender->CommandLength != RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, aBufInfos[pRender->AllocationListSize]))
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("pRender->CommandLength (%d) != RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, aBufInfos[pRender->AllocationListSize](%d)",
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync pRender->CommandLength, RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, aBufInfos[pRender->AllocationListSize])));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync if (pRender->AllocationListSize >= (UINT32_MAX - RT_OFFSETOF(VBOXCMDVBVA_CRCMD, Cmd.aBuffers))/ RT_SIZEOFMEMB(VBOXCMDVBVA_CRCMD, Cmd.aBuffers[0]))
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("Invalid AllocationListSize %d", pRender->AllocationListSize));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync cbPrivateData = RT_OFFSETOF(VBOXCMDVBVA_CRCMD, Cmd.aBuffers[pRender->AllocationListSize]);
41fcf8465b641c7083d3b440451f17c1210fce33vboxsync if (pRender->DmaBufferPrivateDataSize < cbPrivateData)
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("pRender->DmaBufferPrivateDataSize too small %d, requested %d", pRender->DmaBufferPrivateDataSize, cbPrivateData));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("dma buffer %d too small", pRender->DmaSize));
e04dbee5ae65e4080ee6f0ddad90d3484bf8c8a3vboxsync // Assert(pRender->PatchLocationListOutSize == pRender->AllocationListSize);
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync if (pRender->PatchLocationListOutSize < pRender->AllocationListSize)
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("pRender->PatchLocationListOutSize too small %d, requested %d", pRender->PatchLocationListOutSize, pRender->AllocationListSize));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD pUmCmd = (PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD)pInputHdr;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync VBOXCMDVBVA_CRCMD* pChromiumCmd = (VBOXCMDVBVA_CRCMD*)pRender->pDmaBufferPrivateData;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)hContext;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync pChromiumCmd->Hdr.u8OpCode = VBOXCMDVBVA_OPTYPE_CRCMD;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync pChromiumCmd->Cmd.cBuffers = pRender->AllocationListSize;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync DXGK_ALLOCATIONLIST *pAllocationList = pRender->pAllocationList;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync VBOXCMDVBVA_CRCMD_BUFFER *pSubmInfo = pChromiumCmd->Cmd.aBuffers;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync PVBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO pSubmUmInfo = pUmCmd->aBufInfos;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync for (UINT i = 0; i < pRender->AllocationListSize; ++i, ++pRender->pPatchLocationListOut, ++pAllocationList, ++pSubmInfo, ++pSubmUmInfo)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO SubmUmInfo = *pSubmUmInfo;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync D3DDDI_PATCHLOCATIONLIST* pPLL = pRender->pPatchLocationListOut;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pAllocationList);
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (SubmUmInfo.offData >= pAlloc->AllocData.SurfDesc.cbSize
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync || SubmUmInfo.cbData > pAlloc->AllocData.SurfDesc.cbSize
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync || SubmUmInfo.offData + SubmUmInfo.cbData > pAlloc->AllocData.SurfDesc.cbSize)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pSubmInfo->offBuffer = pAllocationList->PhysicalAddress.LowPart + SubmUmInfo.offData;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pPLL->PatchOffset = RT_OFFSETOF(VBOXCMDVBVA_CRCMD, Cmd.aBuffers[i].offBuffer);
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (pRender->DmaBufferPrivateDataSize < cbPrivateData)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("pRender->DmaBufferPrivateDataSize too small %d, requested %d", pRender->DmaBufferPrivateDataSize, cbPrivateData));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("dma buffer %d too small", pRender->DmaSize));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync for (UINT i = 0; i < pRender->AllocationListSize; ++i, ++pRender->pPatchLocationListOut)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync D3DDDI_PATCHLOCATIONLIST* pPLL = pRender->pPatchLocationListOut;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("unsupported render command %d", pInputHdr->enmCmd));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->pDmaBufferPrivateData = ((uint8_t*)pRender->pDmaBufferPrivateData) + cbPrivateData;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->pDmaBuffer = ((uint8_t*)pRender->pDmaBuffer) + cbBuffer;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pCmd->u2.complexCmdEl.u16CbCmdHost = cbPrivateData;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync// LOGF(("LEAVE, hContext(0x%x)", hContext));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsyncstatic void vboxWddmPatchLocationInit(D3DDDI_PATCHLOCATIONLIST *pPatchLocationListOut, UINT idx, UINT offPatch)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync memset(pPatchLocationListOut, 0, sizeof (*pPatchLocationListOut));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync// LOGF(("ENTER, hContext(0x%x)", hContext));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (pRender->DmaBufferPrivateDataSize < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (pRender->CommandLength < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("pRender->DmaSize(%d) < pRender->CommandLength(%d)",
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (pRender->PatchLocationListOutSize < pRender->PatchLocationListInSize)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("pRender->PatchLocationListOutSize(%d) < pRender->PatchLocationListInSize(%d)",
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->PatchLocationListOutSize, pRender->PatchLocationListInSize));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (pRender->AllocationListSize != pRender->PatchLocationListInSize)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("pRender->AllocationListSize(%d) != pRender->PatchLocationListInSize(%d)",
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->AllocationListSize, pRender->PatchLocationListInSize));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pInputHdr = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)pRender->pCommand;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pPrivateData = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)pRender->pDmaBufferPrivateData;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->pDmaBufferPrivateData = (uint8_t*)pRender->pDmaBufferPrivateData + sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR);
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRender->pDmaBuffer = ((uint8_t*)pRender->pDmaBuffer) + pRender->CommandLength;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync for (UINT i = 0; i < pRender->PatchLocationListInSize; ++i)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (offPatch != pRender->pPatchLocationListIn[i].PatchOffset)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync if (i != pRender->pPatchLocationListIn[i].AllocationIndex)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync vboxWddmPatchLocationInit(&pRender->pPatchLocationListOut[i], i, offPatch);
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync WARN(("unsupported command %d", pInputHdr->enmCmd));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync// LOGF(("LEAVE, hContext(0x%x)", hContext));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync#define VBOXVDMACMD_DMA_PRESENT_BLT_MINSIZE() (VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_PRESENT_BLT))
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync#define VBOXVDMACMD_DMA_PRESENT_BLT_SIZE(_c) (VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, aDstSubRects[_c]))
ee22a6c5721a33311c883a3c7bde66d83313093avboxsyncDECLINLINE(VOID) vboxWddmRectlFromRect(const RECT *pRect, PVBOXVDMA_RECTL pRectl)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRectl->width = (uint16_t)(pRect->right - pRect->left);
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pRectl->height = (uint16_t)(pRect->bottom - pRect->top);
ee22a6c5721a33311c883a3c7bde66d83313093avboxsyncDECLINLINE(VBOXVDMA_PIXEL_FORMAT) vboxWddmFromPixFormat(D3DDDIFORMAT format)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsyncDECLINLINE(VOID) vboxWddmSurfDescFromAllocation(PVBOXWDDM_ALLOCATION pAllocation, PVBOXVDMA_SURF_DESC pDesc)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pDesc->width = pAllocation->AllocData.SurfDesc.width;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pDesc->height = pAllocation->AllocData.SurfDesc.height;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pDesc->format = vboxWddmFromPixFormat(pAllocation->AllocData.SurfDesc.format);
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pDesc->pitch = pAllocation->AllocData.SurfDesc.pitch;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsyncDECLINLINE(BOOLEAN) vboxWddmPixFormatConversionSupported(D3DDDIFORMAT From, D3DDDIFORMAT To)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsyncDECLINLINE(void) VBoxCVDdiFillAllocDescHostID(VBOXCMDVBVA_ALLOCDESC *pDesc, const VBOXWDDM_ALLOCATION *pAlloc)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync /* we do not care about wdth and height, zero them up though */
ee22a6c5721a33311c883a3c7bde66d83313093avboxsyncDECLINLINE(void) VBoxCVDdiFillAllocInfoOffVRAM(VBOXCMDVBVA_ALLOCINFO *pInfo, const DXGK_ALLOCATIONLIST *pList)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsyncDECLINLINE(void) VBoxCVDdiFillAllocDescOffVRAM(VBOXCMDVBVA_ALLOCDESC *pDesc, const VBOXWDDM_ALLOCATION *pAlloc, const DXGK_ALLOCATIONLIST *pList)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync VBoxCVDdiFillAllocInfoOffVRAM(&pDesc->Info, pList);
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pDesc->u16Width = (uint16_t)pAlloc->AllocData.SurfDesc.width;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync pDesc->u16Height = (uint16_t)pAlloc->AllocData.SurfDesc.height;
ee22a6c5721a33311c883a3c7bde66d83313093avboxsyncstatic NTSTATUS vboxWddmCmCmdBltIdNotIdFill(VBOXCMDVBVA_BLT_HDR *pBltHdr, const VBOXWDDM_ALLOCATION *pIdAlloc, const VBOXWDDM_ALLOCATION *pAlloc, const DXGK_ALLOCATIONLIST *pList,
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync BOOLEAN fToId, uint32_t *poffPatch, uint32_t *poffRects)
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync D3DDDIFORMAT enmFormat = vboxWddmFmtNoAlphaFormat(pAlloc->AllocData.SurfDesc.format);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pIdAlloc->AllocData.SurfDesc.width == pAlloc->AllocData.SurfDesc.width
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pIdAlloc->AllocData.SurfDesc.height == pAlloc->AllocData.SurfDesc.height)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync fFlags = VBOXCMDVBVA_OPF_BLT_TYPE_OFFPRIMSZFMT_OR_ID | VBOXCMDVBVA_OPF_OPERAND2_ISID;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXCMDVBVA_BLT_OFFPRIMSZFMT_OR_ID *pBlt = (VBOXCMDVBVA_BLT_OFFPRIMSZFMT_OR_ID*)pBltHdr;
07b405d3b41cfce6f5f989a6c95a5819af3841a1vboxsync VBoxCVDdiFillAllocInfoOffVRAM(&pBlt->alloc, pList);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync *poffPatch = RT_OFFSETOF(VBOXCMDVBVA_BLT_OFFPRIMSZFMT_OR_ID, alloc.u.offVRAM);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync *poffRects = RT_OFFSETOF(VBOXCMDVBVA_BLT_OFFPRIMSZFMT_OR_ID, aRects);
07b405d3b41cfce6f5f989a6c95a5819af3841a1vboxsync fFlags = VBOXCMDVBVA_OPF_BLT_TYPE_SAMEDIM_A8R8G8B8 | VBOXCMDVBVA_OPF_OPERAND2_ISID;
e1ea3023f7801c859836e8d0f329621bebe552ccvboxsync VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8 *pBlt = (VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8*)pBltHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxCVDdiFillAllocDescOffVRAM(&pBlt->alloc1, pAlloc, pList);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync *poffPatch = RT_OFFSETOF(VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8, alloc1.Info.u.offVRAM);
e6ad2e18e663b076aeabfec994947514566a7accvboxsync *poffRects = RT_OFFSETOF(VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8, aRects);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsyncstatic NTSTATUS vboxWddmCmCmdBltNotIdNotIdFill(VBOXCMDVBVA_BLT_HDR *pBltHdr, const VBOXWDDM_ALLOCATION *pSrcAlloc, const DXGK_ALLOCATIONLIST *pSrcList,
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync const VBOXWDDM_ALLOCATION *pDstAlloc, const DXGK_ALLOCATIONLIST *pDstList,
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync uint32_t *poffSrcPatch, uint32_t *poffDstPatch, uint32_t *poffRects)
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync if (pDstAlloc->AllocData.SurfDesc.width == pSrcAlloc->AllocData.SurfDesc.width
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync && pDstAlloc->AllocData.SurfDesc.height == pSrcAlloc->AllocData.SurfDesc.height)
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync pBltHdr->Hdr.u8Flags |= VBOXCMDVBVA_OPF_BLT_TYPE_SAMEDIM_A8R8G8B8;
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8 *pBlt = (VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8*)pBltHdr;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync VBoxCVDdiFillAllocDescOffVRAM(&pBlt->alloc1, pDstAlloc, pDstList);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync VBoxCVDdiFillAllocInfoOffVRAM(&pBlt->info2, pSrcList);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync *poffDstPatch = RT_OFFSETOF(VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8, alloc1.Info.u.offVRAM);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync *poffSrcPatch = RT_OFFSETOF(VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8, info2.u.offVRAM);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync *poffRects = RT_OFFSETOF(VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8, aRects);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync pBltHdr->Hdr.u8Flags |= VBOXCMDVBVA_OPF_BLT_TYPE_GENERIC_A8R8G8B8;
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync VBOXCMDVBVA_BLT_GENERIC_A8R8G8B8 *pBlt = (VBOXCMDVBVA_BLT_GENERIC_A8R8G8B8*)pBltHdr;
de2c791e625f644c92fd3bb70c2a18ecfdb445f7vboxsync VBoxCVDdiFillAllocDescOffVRAM(&pBlt->alloc1, pDstAlloc, pDstList);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync VBoxCVDdiFillAllocDescOffVRAM(&pBlt->alloc2, pSrcAlloc, pSrcList);
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync *poffDstPatch = RT_OFFSETOF(VBOXCMDVBVA_BLT_GENERIC_A8R8G8B8, alloc1.Info.u.offVRAM);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync *poffSrcPatch = RT_OFFSETOF(VBOXCMDVBVA_BLT_GENERIC_A8R8G8B8, alloc2.Info.u.offVRAM);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync *poffRects = RT_OFFSETOF(VBOXCMDVBVA_BLT_GENERIC_A8R8G8B8, aRects);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync * DxgkDdiPresent
9c21eebec4d70f1e638002c8dfc6ea9d534d8710vboxsync// LOGF(("ENTER, hContext(0x%x)", hContext));
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)hContext;
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync if (pPresent->DmaBufferPrivateDataSize < sizeof (VBOXCMDVBVA_HDR))
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync WARN(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXCMDVBVA_HDR (%d)", pPresent->DmaBufferPrivateDataSize , sizeof (VBOXCMDVBVA_HDR)));
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync /* @todo: can this actually happen? what status to return? */
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync VBOXCMDVBVA_HDR* pHdr = (VBOXCMDVBVA_HDR*)pPresent->pDmaBufferPrivateData;
1ff34f218a5354068e4df9017f77fc5871e6b7c6vboxsync if (pPresent->DmaSize < VBOXWDDM_DUMMY_DMABUFFER_SIZE)
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync WARN(("Present->DmaSize(%d) < VBOXWDDM_DUMMY_DMABUFFER_SIZE (%d)", pPresent->DmaSize , VBOXWDDM_DUMMY_DMABUFFER_SIZE));
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync /* @todo: can this actually happen? what status to return? */
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync Assert(pPresent->Flags.Value == 1); /* only Blt is set, we do not support anything else for now */
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync DXGK_ALLOCATIONLIST *pSrc = &pPresent->pAllocationList[DXGK_PRESENT_SOURCE_INDEX];
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync DXGK_ALLOCATIONLIST *pDst = &pPresent->pAllocationList[DXGK_PRESENT_DESTINATION_INDEX];
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync PVBOXWDDM_ALLOCATION pSrcAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pSrc);
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync /* this should not happen actually */
73ba84f95f918cc170be38908ad240fbb2f8f354vboxsync WARN(("failed to get Src Allocation info for hDeviceSpecificAllocation(0x%x)",pSrc->hDeviceSpecificAllocation));
ee22a6c5721a33311c883a3c7bde66d83313093avboxsync PVBOXWDDM_ALLOCATION pDstAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pDst);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync /* this should not happen actually */
7b6926b2bf44f326f40e1d9d1ce33a4dff0a2c67vboxsync WARN(("failed to get Dst Allocation info for hDeviceSpecificAllocation(0x%x)",pDst->hDeviceSpecificAllocation));
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync BOOLEAN fDstPrimary = (!pDstAlloc->AllocData.hostID
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync && pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync BOOLEAN fSrcPrimary = (!pSrcAlloc->AllocData.hostID
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync && pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync VBOXCMDVBVA_BLT_HDR *pBltHdr = (VBOXCMDVBVA_BLT_HDR*)pHdr;
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync pBltHdr->Pos.x = (int16_t)(pPresent->DstRect.left - pPresent->SrcRect.left);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync pBltHdr->Pos.y = (int16_t)(pPresent->DstRect.top - pPresent->SrcRect.top);
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync if (pPresent->DmaBufferPrivateDataSize < VBOXCMDVBVA_SIZEOF_BLTSTRUCT_MAX)
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync WARN(("Present->DmaBufferPrivateDataSize(%d) < (%d)", pPresent->DmaBufferPrivateDataSize , VBOXCMDVBVA_SIZEOF_BLTSTRUCT_MAX));
2721dfb0e330d57ba888311520f5a343c64e7cefvboxsync /* @todo: can this actually happen? what status to return? */
pHdr->u8Flags |= VBOXCMDVBVA_OPF_BLT_TYPE_OFFPRIMSZFMT_OR_ID | VBOXCMDVBVA_OPF_OPERAND1_ISID | VBOXCMDVBVA_OPF_OPERAND2_ISID;
NTSTATUS Status = vboxWddmCmCmdBltIdNotIdFill(pBltHdr, pSrcAlloc, pDstAlloc, pDst, FALSE, &u32DstPatch, &cbPrivateData);
return Status;
NTSTATUS Status = vboxWddmCmCmdBltIdNotIdFill(pBltHdr, pDstAlloc, pSrcAlloc, pSrc, TRUE, &u32SrcPatch, &cbPrivateData);
return Status;
vboxWddmCmCmdBltNotIdNotIdFill(pBltHdr, pSrcAlloc, pSrc, pDstAlloc, pDst, &u32SrcPatch, &u32DstPatch, &cbPrivateData);
if (fDstPrimary)
else if (fSrcPrimary)
WARN(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXCMDVBVA_FLIP (%d)", pPresent->DmaBufferPrivateDataSize , sizeof (VBOXCMDVBVA_FLIP)));
return STATUS_INVALID_PARAMETER;
if (!pSrcAlloc)
WARN(("failed to get pSrc Allocation info for hDeviceSpecificAllocation(0x%x)",pSrc->hDeviceSpecificAllocation));
return STATUS_INVALID_HANDLE;
Assert((UINT)pSrcAlloc->AllocData.SurfDesc.VidPnSourceId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
#ifdef DEBUG_misha
Assert(pPresent->Flags.Value == 2); /* only ColorFill is set, we do not support anything else for now */
if (!pDstAlloc)
WARN(("failed to get pDst Allocation info for hDeviceSpecificAllocation(0x%x)",pDst->hDeviceSpecificAllocation));
return STATUS_INVALID_HANDLE;
WARN(("Present->DmaBufferPrivateDataSize(%d) < VBOXCMDVBVA_SIZEOF_CLRFILLSTRUCT_MAX (%d)", pPresent->DmaBufferPrivateDataSize , VBOXCMDVBVA_SIZEOF_CLRFILLSTRUCT_MAX));
return STATUS_INVALID_PARAMETER;
if (fDstPrimary)
return STATUS_NOT_SUPPORTED;
if (paRects)
if (fPatchSrc)
if (fPatchDst)
return STATUS_SUCCESS;
static NTSTATUS
PAGED_CODE();
LOGREL(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR (%d)", pPresent->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR)));
return STATUS_INVALID_PARAMETER;
PVBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR pPrivateData = (PVBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR)pPresent->pDmaBufferPrivateData;
if (!pSrcAlloc)
WARN(("failed to get Src Allocation info for hDeviceSpecificAllocation(0x%x)",pSrc->hDeviceSpecificAllocation));
goto done;
if (!pDstAlloc)
WARN(("failed to get Dst Allocation info for hDeviceSpecificAllocation(0x%x)",pDst->hDeviceSpecificAllocation));
goto done;
memcpy(&pBlt->Blt.DstRects.UpdateRects.aRects[pPresent->MultipassOffset], &pPresent->pDstSubRects[pPresent->MultipassOffset], cbRects);
memcpy(&pBlt->Blt.DstRects.UpdateRects.aRects[pPresent->MultipassOffset], &pPresent->pDstSubRects[pPresent->MultipassOffset], cbFitingRects);
if (!pSrcAlloc)
WARN(("failed to get pSrc Allocation info for hDeviceSpecificAllocation(0x%x)",pSrc->hDeviceSpecificAllocation));
goto done;
Assert(pPresent->Flags.Value == 2); /* only ColorFill is set, we do not support anything else for now */
if (!pDstAlloc)
WARN(("failed to get pDst Allocation info for hDeviceSpecificAllocation(0x%x)",pDst->hDeviceSpecificAllocation));
goto done;
memcpy(&pCF->ClrFill.Rects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbFitingRects);
done:
return Status;
return Status;
return Status;
return Status;
PAGED_CODE();
WARN(("Invalid NodeOrdinal (%d), expected to be less that (%d)\n", pCreateContext->NodeOrdinal, VBOXWDDM_NUM_NODES));
return STATUS_INVALID_PARAMETER;
if (pContext)
#ifdef VBOX_WITH_CROGL
int rc = VBoxMpCrCtlConConnect(pDevExt, &pDevExt->CrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pContext->u32CrConClientID);
PVBOXWDDM_CREATECONTEXT_INFO pInfo = (PVBOXWDDM_CREATECONTEXT_INFO)pCreateContext->pPrivateDriverData;
#ifdef VBOX_WITH_CROGL
Status = vboxVideoCmCtxAdd(&pDevice->pAdapter->CmMgr, &pContext->CmContext, (HANDLE)pInfo->hUmEvent, pInfo->u64UmInfo);
Status = vboxVideoCmCtxAdd(&pDevice->pAdapter->SeamlessCtxMgr, &pContext->CmContext, (HANDLE)pInfo->hUmEvent, pInfo->u64UmInfo);
return Status;
if (!cContexts)
#ifdef VBOX_WITH_CROGL
#ifdef VBOX_WITH_CROGL
return Status;
return STATUS_NOT_IMPLEMENTED;
return STATUS_SUCCESS;
return STATUS_SUCCESS;
#ifdef VBOX_WDDM_WIN8
return STATUS_SUCCESS;
if (!bUpdateRectInited)
vboxVdmaGgDmaBltPerform(pDevExt, &SrcAllocData, &pPresentDisplayOnly->pMoves[i].DestRect, &pSource->AllocData, &pPresentDisplayOnly->pMoves[i].DestRect);
vboxVdmaGgDmaBltPerform(pDevExt, &SrcAllocData, &pPresentDisplayOnly->pDirtyRect[i], &pSource->AllocData, &pPresentDisplayOnly->pDirtyRect[i]);
if (!bUpdateRectInited)
return STATUS_SUCCESS;
return STATUS_NOT_SUPPORTED;
return STATUS_NOT_SUPPORTED;
return STATUS_SUCCESS;
return STATUS_SUCCESS;
return STATUS_SUCCESS;
return STATUS_SUCCESS;
static NTSTATUS vboxWddmInitDisplayOnlyDriver(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pRegistryPath)
DriverInitializationData.DxgkDdiStopDeviceAndReleasePostDisplayOwnership = DxgkDdiStopDeviceAndReleasePostDisplayOwnership;
return Status;
static NTSTATUS vboxWddmInitFullGraphicsDriver(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pRegistryPath, BOOLEAN fCmdVbva)
#ifdef VBOX_WITH_CROGL
DriverInitializationData.DxgkDdiInterruptRoutine = VBOXWDDM_CALLBACK_NAME(DxgkDdiInterruptRoutine, fCmdVbva);
DriverInitializationData.DxgkDdiGetStandardAllocationDriverData = DxgkDdiGetStandardAllocationDriverData;
DriverInitializationData.DxgkDdiSubmitCommand = VBOXWDDM_CALLBACK_NAME(DxgkDdiSubmitCommand, fCmdVbva);
DriverInitializationData.DxgkDdiPreemptCommand = VBOXWDDM_CALLBACK_NAME(DxgkDdiPreemptCommand, fCmdVbva);
DriverInitializationData.DxgkDdiBuildPagingBuffer = VBOXWDDM_CALLBACK_NAME(DxgkDdiBuildPagingBuffer, fCmdVbva);
DriverInitializationData.DxgkDdiQueryCurrentFence = VBOXWDDM_CALLBACK_NAME(DxgkDdiQueryCurrentFence, fCmdVbva);
DriverInitializationData.DxgkDdiSetDisplayPrivateDriverFormat = DxgkDdiSetDisplayPrivateDriverFormat;
// DriverInitializationData.DxgkDdiUpdateActiveVidPnPresentPath = DxgkDdiUpdateActiveVidPnPresentPath;
return Status;
PAGED_CODE();
#ifdef VBOX_WDDM_WIN8
LOGREL(("VBox WDDM Driver for Windows 8, %d bit; Built %s %s", (sizeof (void*) << 3), __DATE__, __TIME__));
LOGREL(("VBox WDDM Driver for Windows Vista and 7, %d bit; Built %s %s", (sizeof (void*) << 3), __DATE__, __TIME__));
return STATUS_INVALID_PARAMETER;
#ifdef VBOX_WITH_CROGL
if (!VBoxMpCrCtlConIs3DSupported())
#ifdef VBOX_WDDM_WIN8
if (f3DRequired)
LOGREL(("3D is NOT supported by the host, but is required for the current guest version using this driver.."));
LOGREL(("3D is NOT supported by the host, but is NOT required for the current guest version using this driver, continuing with Disabled 3D.."));
LOGREL(("Current win8 video driver only supports display-only mode no matter whether or not host 3D is enabled!"));
#ifdef VBOX_WITH_CROGL
#ifdef VBOX_WDDM_WIN8
if (g_VBoxDisplayOnly)
#ifdef VBOX_WITH_CROGL
return Status;
#ifdef VBOX_WITH_CROGL
VBoxVrTerm();
#ifdef VBOX_WITH_CROGL
if (pLogger)
if (pLogger)
return Status;