VBoxMPWddm.cpp revision 5793d23a719d4902824a3649b6fef3822ddd5fc7
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * VBox WDDM Miniport driver
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Copyright (C) 2011 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 */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return ExAllocatePoolWithTag(NonPagedPool, cbSize, VBOXWDDM_MEMTAG);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromOpenData(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_OPENALLOCATION pOa)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return (PVBOXWDDM_ALLOCATION)pDevExt->u.primary.DxgkInterface.DxgkCbGetHandleData(&GhData);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromAllocList(PVBOXMP_DEVEXT pDevExt, DXGK_ALLOCATIONLIST *pAllocList)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return vboxWddmGetAllocationFromOpenData(pDevExt, (PVBOXWDDM_OPENALLOCATION)pAllocList->hDeviceSpecificAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void vboxWddmPopulateDmaAllocInfo(PVBOXWDDM_DMA_ALLOCINFO pInfo, PVBOXWDDM_ALLOCATION pAlloc, DXGK_ALLOCATIONLIST *pDmaAlloc)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pInfo->offAlloc = (VBOXVIDEOOFFSET)pDmaAlloc->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void vboxWddmPopulateDmaAllocInfoWithOffset(PVBOXWDDM_DMA_ALLOCINFO pInfo, PVBOXWDDM_ALLOCATION pAlloc, DXGK_ALLOCATIONLIST *pDmaAlloc, uint32_t offStart)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pInfo->offAlloc = (VBOXVIDEOOFFSET)pDmaAlloc->PhysicalAddress.QuadPart + offStart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync//VBOXVIDEOOFFSET vboxWddmVRAMAddressToOffset(PVBOXMP_DEVEXT pDevExt, PHYSICAL_ADDRESS phAddress)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(phAddress.QuadPart >= VBE_DISPI_LFB_PHYSICAL_ADDRESS);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// if (phAddress.QuadPart < VBE_DISPI_LFB_PHYSICAL_ADDRESS)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// return VBOXVIDEOOFFSET_VOID;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// VBOXVIDEOOFFSET off = phAddress.QuadPart - VBE_DISPI_LFB_PHYSICAL_ADDRESS;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(off < pDevExt->u.primary.cbVRAM);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// if (off >= pDevExt->u.primary.cbVRAM)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// return VBOXVIDEOOFFSET_VOID;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// return off;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncVBOXVIDEOOFFSET vboxWddmValidatePrimary(PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmGhDisplayPostInfoScreenBySDesc (PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SURFACE_DESC pDesc, POINT * pVScreenPos, uint16_t fFlags)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync void *p = VBoxHGSMIBufferAlloc (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pScreen->u32StartOffset = 0; //(uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxHGSMIBufferFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmGhDisplayPostInfoScreen (PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAllocation, POINT * pVScreenPos)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxWddmGhDisplayPostInfoScreenBySDesc(pDevExt, &pAllocation->SurfDesc, pVScreenPos, VBVA_SCREEN_F_ACTIVE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmGhDisplayPostInfoView(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* Issue the screen info command. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync void *p = VBoxHGSMIBufferAlloc (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pView->u32ViewIndex = pAllocation->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 VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxHGSMIBufferFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmGhDisplaySetMode(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (/*pPrimaryInfo->*/pAllocation->SurfDesc.VidPnSourceId)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ULONG cbLine = VBOXWDDM_ROUNDBOUND(((width * bpp) + 7) / 8, 4);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ULONG yOffset = (ULONG)pAllocation->offVram / cbLine;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ULONG xOffset = (ULONG)pAllocation->offVram % cbLine;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxVideoSetModeRegisters(width, height, width, bpp, 0, (uint16_t)xOffset, (uint16_t)yOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /*@todo read back from port to check if mode switch was successful */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmGhDisplayUpdateScreenPos(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, POINT *pVScreenPos)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAllocation = VBOXWDDM_FB_ALLOCATION(pSource);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxWddmGhDisplayPostInfoScreen(pDevExt, pAllocation, &pSource->VScreenPos);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmGhDisplaySetInfo(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAllocation = VBOXWDDM_FB_ALLOCATION(pSource);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVIDEOOFFSET offVram = vboxWddmValidatePrimary(pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Set the current mode into the hardware.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// NTSTATUS Status= vboxWddmDisplaySettingsQueryPos(pDevExt, VidPnSourceId, &pSource->VScreenPos);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(Status == STATUS_SUCCESS);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmGhDisplayPostInfoView(pDevExt, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmGhDisplayPostInfoScreen(pDevExt, pAllocation, &pSource->VScreenPos);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncbool vboxWddmCheckUpdateShadowAddress(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, UINT SegmentId, VBOXVIDEOOFFSET offVram)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pSource->pPrimaryAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxWddmGhDisplaySetInfo(pDevExt, pSource, VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync WARN(("vboxWddmGhDisplaySetInfo failed, Status (0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return true;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncHGSMIHEAP* vboxWddmHgsmiGetHeapFromCmdOffset(PVBOXMP_DEVEXT pDevExt, HGSMIOFFSET offCmd)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if(HGSMIAreaContainsOffset(&pDevExt->u.primary.Vdma.CmdHeap.area, offCmd))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (HGSMIAreaContainsOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.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.area, offCmd))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (HGSMIAreaContainsOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.area, offCmd))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmPickResources(PVBOXMP_DEVEXT pContext, PDXGK_DEVICE_INFO pDeviceInfo, PULONG pAdapterMemorySize)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync *pAdapterMemorySize = 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 *pAdapterMemorySize = 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 /* @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 for (int i = 0; i < RT_ELEMENTS(pDevExt->aSources); ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->aSources[i].offVram = VBOXVIDEOOFFSET_VOID;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void vboxWddmSetupDisplays(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);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVdmaDestroy(pDevExt, &pDevExt->u.primary.Vdma);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxVideoAMgrCreate(pDevExt, &pDevExt->AllocMgr, offset, ulSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ulSize /= VBoxCommonFromDeviceExt(pDevExt)->cDisplays;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* todo: ?? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(ulSize * VBoxCommonFromDeviceExt(pDevExt)->cDisplays < ulAvailable);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int i = VBoxCommonFromDeviceExt(pDevExt)->cDisplays-1; i >= 0; --i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = vboxVbvaCreate(pDevExt, &pDevExt->aSources[i].Vbva, offset, ulSize, i);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = vboxVbvaEnable(pDevExt, &pDevExt->aSources[i].Vbva);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: de-initialize */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = VBoxMPCmnMapAdapterMemory(VBoxCommonFromDeviceExt(pDevExt), (void**)&pDevExt->pvVisibleVram,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int vboxWddmFreeDisplays(PVBOXMP_DEVEXT pDevExt)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxMPCmnUnmapAdapterMemory(VBoxCommonFromDeviceExt(pDevExt), (void**)&pDevExt->pvVisibleVram);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int i = VBoxCommonFromDeviceExt(pDevExt)->cDisplays-1; i >= 0; --i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = vboxVbvaDisable(pDevExt, &pDevExt->aSources[i].Vbva);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = vboxVbvaDestroy(pDevExt, &pDevExt->aSources[i].Vbva);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync rc = vboxVdmaDisable(pDevExt, &pDevExt->u.primary.Vdma);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, Status(0x%x), pDevExt(0x%x)", Status, pDevExt));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiStartDevice function should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pContext = (PVBOXMP_DEVEXT)MiniportDeviceContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* Save DeviceHandle and function pointers supplied by the DXGKRNL_INTERFACE structure passed to DxgkInterface. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(&pContext->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 = pContext->u.primary.DxgkInterface.DxgkCbGetDeviceInformation (pContext->u.primary.DxgkInterface.DeviceHandle, &DeviceInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmPickResources(pContext, &DeviceInfo, &AdapterMemorySize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* Initialize VBoxGuest library, which is used for requests which go through VMMDev. */
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(pContext),
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxFreeDisplaysHGSMI(VBoxCommonFromDeviceExt(pContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync *NumberOfVideoPresentSources = VBoxCommonFromDeviceExt(pContext)->cDisplays;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync *NumberOfChildren = VBoxCommonFromDeviceExt(pContext)->cDisplays;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOG(("sources(%d), children(%d)", *NumberOfVideoPresentSources, *NumberOfChildren));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVdmaDdiQueueInit(pContext, &pContext->DdiCmdQueue);
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;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* do everything we did on DxgkDdiStartDevice in the reverse order */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxFreeDisplaysHGSMI(VBoxCommonFromDeviceExt(pDevExt));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* revert back to the state we were right after the DxgkDdiAddDevice */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiRemoveDevice should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, context(0x%p)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, context(0x%p)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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 /* 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->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 */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: FIXME: implement !!! */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync flags = VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags->u32HostFlags;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (1);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxSHGSMIListCat(&pDevExt->DmaCmdList, &DmaCmdList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxSHGSMIListCat(&pDevExt->VhwaCmdList, &VhwaCmdList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bNeedDpc |= !vboxVdmaDdiCmdIsCompletedListEmptyIsr(&pDevExt->DdiCmdQueue);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(bNeedDpc == TRUE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pDevExt->bNotifyDxDpc = TRUE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pDevExt->bSetNotifyDxDpc = FALSE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBoxHGSMIClearIrq(&VBoxCommonFromDeviceExt(pDevExt)->hostCtx);
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;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync BOOLEAN bDpcQueued = pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, context(0x%p), bOur(0x%x)", MiniportDeviceContext, (ULONG)bOur));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync} VBOXWDDM_GETDPCDATA_CONTEXT, *PVBOXWDDM_GETDPCDATA_CONTEXT;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_GETDPCDATA_CONTEXT pdc = (PVBOXWDDM_GETDPCDATA_CONTEXT)Context;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxSHGSMIListDetach2List(&pdc->pDevExt->CtlList, &pdc->data.CtlList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxSHGSMIListDetach2List(&pdc->pDevExt->DmaCmdList, &pdc->data.DmaCmdList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxSHGSMIListDetach2List(&pdc->pDevExt->VhwaCmdList, &pdc->data.VhwaCmdList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVdmaDdiCmdGetCompletedListIsr(&pdc->pDevExt->DdiCmdQueue, &pdc->data.CompletedDdiCmdQueue);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, context(0x%p)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* get DPC data at IRQL */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 0, /* IN ULONG MessageNumber */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->u.primary.DxgkInterface.DxgkCbNotifyDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = VBoxSHGSMICommandPostprocessCompletion (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, &context.data.CtlList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!vboxSHGSMIListIsEmpty(&context.data.DmaCmdList))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = VBoxSHGSMICommandPostprocessCompletion (&pDevExt->u.primary.Vdma.CmdHeap, &context.data.DmaCmdList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!vboxSHGSMIListIsEmpty(&context.data.VhwaCmdList))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVhwaCompletionListProcess(pDevExt, &context.data.VhwaCmdList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVdmaDdiCmdHandleCompletedList(pDevExt, &pDevExt->DdiCmdQueue, &context.data.CompletedDdiCmdQueue);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// 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;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ChildRelations[i].ChildCapabilities.Type.VideoOutput.InterfaceTechnology = D3DKMDT_VOT_HD15; /* VGA */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ChildRelations[i].ChildCapabilities.Type.VideoOutput.MonitorOrientationAwareness = D3DKMDT_MOA_INTERRUPTIBLE; /* ?? D3DKMDT_MOA_NONE*/
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ChildRelations[i].ChildCapabilities.Type.VideoOutput.SupportsSdtvModes = FALSE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync ChildRelations[i].ChildCapabilities.HpdAwareness = HpdAwarenessAlwaysConnected; //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 LOGREL(("ERROR: status type: %d", ChildStatus->Type));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we do not support EDID */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiSetPowerState function should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// vboxVDbgBreakF();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, context(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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 LOGF(("ENTER, MiniportDeviceContext(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, MiniportDeviceContext(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiQueryAdapterInfo
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiQueryAdapterInfo should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, context(0x%x), Query type (%d)", hAdapter, pQueryAdapterInfo->Type));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pContext = (PVBOXMP_DEVEXT)hAdapter;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_DRIVERCAPS *pCaps = (DXGK_DRIVERCAPS*)pQueryAdapterInfo->pOutputData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->HighestAcceptableAddress.QuadPart = ~((uintptr_t)0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->MaxPointerWidth = VBOXWDDM_C_POINTER_MAX_WIDTH;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->MaxPointerHeight = VBOXWDDM_C_POINTER_MAX_HEIGHT;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->PointerCaps.Value = 3; /* Monochrome , Color*/ /* MaskedColor == Value | 4, dosable for now */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pContext)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if ( pContext->aSources[i].Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->MaxOverlays += pContext->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 */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: this correlates with pCaps->SchedulingCaps.MultiEngineAware */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->GpuEngineTopology.NbAsymetricProcessingNodes = 1;
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 LOGREL(("NbSegment (%d) != 1", pQsOut->NbSegment));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_SEGMENTDESCRIPTOR* pDr = pQsOut->pSegmentDescriptor;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we are requested to provide segment information */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDr->BaseAddress.QuadPart = 0; /* VBE_DISPI_LFB_PHYSICAL_ADDRESS; */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDr->CpuTranslatedAddress.QuadPart = VBE_DISPI_LFB_PHYSICAL_ADDRESS;
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(pContext);
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(pContext);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pQsOut->PagingBufferPrivateDataSize = 0; /* @todo: do we need a private buffer ? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert (pQueryAdapterInfo->OutputDataSize >= sizeof (VBOXWDDM_QI));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pQueryAdapterInfo->OutputDataSize >= sizeof (VBOXWDDM_QI))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_QI * pQi = (VBOXWDDM_QI*)pQueryAdapterInfo->pOutputData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pQi->cInfos = VBoxCommonFromDeviceExt(pContext)->cDisplays;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pContext)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pQi->aInfos[i] = pContext->aSources[i].Vhwa.Settings;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("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 PVBOXMP_DEVEXT pContext = (PVBOXMP_DEVEXT)hAdapter;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)vboxWddmMemAllocZero(sizeof (VBOXWDDM_DEVICE));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// AssertBreakpoint(); /* we do not support custom contexts for now */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGREL(("we do not support custom devices for now, hAdapter (0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, context(0x%x), Status(0x%x)", hAdapter, Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncPVBOXWDDM_ALLOCATION vboxWddmAllocationCreateFromResource(PVBOXWDDM_RESOURCE pResource, uint32_t iIndex)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pAllocation, 0, sizeof (VBOXWDDM_ALLOCATION));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(sizeof (VBOXWDDM_ALLOCATION));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncvoid vboxWddmAllocationDeleteFromResource(PVBOXWDDM_RESOURCE pResource, PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(&pResource->aAllocations[pAllocation->iIndex] == pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmDestroyAllocation(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: do we need to notify host? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[pAllocation->SurfDesc.VidPnSourceId], NULL, pAllocation->SurfDesc.VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAllocation->SurfDesc.VidPnSourceId != D3DDDI_ID_UNINITIALIZED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: do we need to notify host? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAssignShadow(pDevExt, &pDevExt->aSources[pAllocation->SurfDesc.VidPnSourceId], NULL, pAllocation->SurfDesc.VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync//#ifdef VBOX_WITH_VIDEOHWACCEL
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// if (pAllocation->fRcFlags.Overlay)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// vboxVhwaHlpDestroyOverlay(pDevExt, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_SWAPCHAIN pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmSwapchainAllocRemove(pDevExt, pSwapchain, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAllocationDeleteFromResource(pAllocation->pResource, pAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS vboxWddmCreateAllocation(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 pAllocationInfo->Size = pAllocInfo->SurfDesc.cbSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#if 0 //defined(VBOXWDDM_RENDER_FROM_SHADOW)
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->SurfDesc.cbSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_HIGH;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->UsageHint.v1.Format = pAllocInfo->SurfDesc.format;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->UsageHint.v1.Width = pAllocation->SurfDesc.width;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->UsageHint.v1.Height = pAllocation->SurfDesc.height;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->UsageHint.v1.Pitch = pAllocation->SurfDesc.pitch;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocationInfo->pAllocationUsageHint = &pAllocation->UsageHint;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->enmSynchType = pAllocInfo->enmSynchType;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->SurfDesc.cbSize = pAllocInfo->cbBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pAllocationInfo->Flags.SynchronousPaging = 1;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_MAXIMUM;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = ObReferenceObjectByHandle((HANDLE)pAllocInfo->hSynch, EVENT_MODIFY_STATE, *ExEventObjectType, UserMode,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = ObReferenceObjectByHandle((HANDLE)pAllocInfo->hSynch, EVENT_MODIFY_STATE, *ExSemaphoreObjectType, UserMode,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("ERROR: invalid synch info type(%d)", pAllocInfo->enmSynchType));
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))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)pCreateAllocation->pPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pRcInfo->RcDesc.VidPnSourceId < VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRcInfo->cAllocInfos == pCreateAllocation->NumAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pResource = (PVBOXWDDM_RESOURCE)vboxWddmMemAllocZero(RT_OFFSETOF(VBOXWDDM_RESOURCE, aAllocations[pRcInfo->cAllocInfos]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: Implement Resource Data Handling */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("WARNING: Implement Resource Data Handling"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < pCreateAllocation->NumAllocations; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmCreateAllocation(pDevExt, pResource, i, &pCreateAllocation->pAllocationInfo[i]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("ERROR: vboxWddmCreateAllocation error (0x%x)", 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 vboxWddmDestroyAllocation(pDevExt, (PVBOXWDDM_ALLOCATION)pCreateAllocation->pAllocationInfo[j].hAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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 vboxWddmDestroyAllocation((PVBOXMP_DEVEXT)hAdapter, pAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiDescribeAllocation
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, hAdapter(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)pDescribeAllocation->hAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDescribeAllocation->Width = pAllocation->SurfDesc.width;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDescribeAllocation->Height = pAllocation->SurfDesc.height;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDescribeAllocation->Format = pAllocation->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));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiGetStandardAllocationDriverData
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGKARG_GETSTANDARDALLOCATIONDRIVERDATA* pGetStandardAllocationDriverData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiGetStandardAllocationDriverData should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync switch (pGetStandardAllocationDriverData->StandardAllocationType)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync case D3DKMDT_STANDARDALLOCATION_SHAREDPRIMARYSURFACE:
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("D3DKMDT_STANDARDALLOCATION_SHAREDPRIMARYSURFACE"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if(pGetStandardAllocationDriverData->pAllocationPrivateDriverData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset (pAllocInfo, 0, sizeof (VBOXWDDM_ALLOCINFO));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.width = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.height = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Height;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.format = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Format;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->SurfDesc.format);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width, pAllocInfo->SurfDesc.bpp);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.RefreshRate = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->RefreshRate;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.VidPnSourceId = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->VidPnSourceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pGetStandardAllocationDriverData->ResourcePrivateDriverDataSize = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("D3DKMDT_STANDARDALLOCATION_SHADOWSURFACE"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT bpp = vboxWddmCalcBitsPerPixel(pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Format);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT Pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width, bpp);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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.bpp);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
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));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("D3DKMDT_STANDARDALLOCATION_STAGINGSURFACE"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if(pGetStandardAllocationDriverData->pAllocationPrivateDriverData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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.bpp);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.RefreshRate.Denominator = 1000;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocInfo->SurfDesc.VidPnSourceId = D3DDDI_ID_UNINITIALIZED;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// case D3DKMDT_STANDARDALLOCATION_GDISURFACE:
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync//# error port to Win7 DDI
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("Invalid allocation type (%d)", pGetStandardAllocationDriverData->StandardAllocationType));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGKARG_ACQUIRESWIZZLINGRANGE* pAcquireSwizzlingRange)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CONST DXGKARG_RELEASESWIZZLINGRANGE* pReleaseSwizzlingRange)
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 Assert(pPatch->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPatch->DmaBufferPrivateDataSubmissionEndOffset - pPatch->DmaBufferPrivateDataSubmissionStartOffset >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pPatch->DmaBufferPrivateDataSubmissionEndOffset - pPatch->DmaBufferPrivateDataSubmissionStartOffset >= 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_SHADOW2PRIMARY pS2P = (PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY)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 pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc = pSrcAllocationList->SegmentId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pS2P->Shadow2Primary.ShadowAlloc.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart + 1];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pPatchList->AllocationIndex == DXGK_PRESENT_DESTINATION_INDEX);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pPatchList->PatchOffset == 4);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// const DXGK_ALLOCATIONLIST *pDstAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pDstAllocationList->SegmentId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pPrivateData->DstAllocInfo.segmentIdAlloc = pDstAllocationList->SegmentId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pPrivateData->DstAllocInfo.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart;
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 LOGREL(("DmaBufferPrivateDataSubmissionEndOffset (%d) - DmaBufferPrivateDataSubmissionStartOffset (%d) < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR) (%d)",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CALL_ISR pdc = (PVBOXWDDM_CALL_ISR)Context;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return DxgkDdiInterruptRoutine(pdc->pDevExt, pdc->MessageNumber);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 0, /* IN ULONG MessageNumber */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic NTSTATUS vboxWddmSubmitCmd(PVBOXMP_DEVEXT pDevExt, VBOXVDMAPIPE_CMD_DMACMD *pCmd)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxVdmaDdiCmdSubmitted(pDevExt, &pDevExt->DdiCmdQueue, &pCmd->DdiCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cNew = ASMAtomicIncU32(&pDevExt->cUnlockedVBVADisabled);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS submStatus = vboxVdmaGgCmdSubmit(&pDevExt->u.primary.Vdma.DmaGg, &pCmd->Hdr);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cNew = ASMAtomicDecU32(&pDevExt->cUnlockedVBVADisabled);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, &pCmd->DdiCmd, DXGK_INTERRUPT_DMA_FAULTED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic NTSTATUS vboxWddmSubmitBltCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, UINT u32FenceId, PVBOXWDDM_DMA_PRIVATEDATA_BLT pBlt, VBOXVDMAPIPE_FLAGS_DMACMD fBltFlags)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMAPIPE_CMD_DMACMD_BLT pBltCmd = (PVBOXVDMAPIPE_CMD_DMACMD_BLT)vboxVdmaGgCmdCreate(&pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_DMACMD, RT_OFFSETOF(VBOXVDMAPIPE_CMD_DMACMD_BLT, Blt.DstRects.UpdateRects.aRects[pBlt->Blt.DstRects.UpdateRects.cRects]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pBlt->Blt.DstAlloc.srcId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVdmaDdiCmdInit(&pBltCmd->Hdr.DdiCmd, u32FenceId, pContext, vboxVdmaGgDdiCmdDestroy, pBltCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBltCmd->Hdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_BLT;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(&pBltCmd->Blt, &pBlt->Blt, RT_OFFSETOF(VBOXVDMA_BLT, DstRects.UpdateRects.aRects[pBlt->Blt.DstRects.UpdateRects.cRects]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, u32FenceId, DXGK_INTERRUPT_DMA_FAULTED);
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 VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* signal completion */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBufCmd->u64GuesData;
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 /* 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 Assert(pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset - pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset - pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("DmaBufferPrivateDataSubmissionEndOffset (%d) - DmaBufferPrivateDataSubmissionStartOffset (%d) < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR) (%d)",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pPrivateDataBase = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)((uint8_t*)pSubmitCommand->pDmaBufferPrivateData + pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY pS2P = (PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pS2P->Shadow2Primary.VidPnSourceId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pSrcAlloc = pS2P->Shadow2Primary.ShadowAlloc.pAlloc;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pS2P->Shadow2Primary.VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmCheckUpdateShadowAddress(pDevExt, pSource, pS2P->Shadow2Primary.VidPnSourceId,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc, pS2P->Shadow2Primary.ShadowAlloc.offAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &pS2P->Shadow2Primary.SrcRect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &pS2P->Shadow2Primary.SrcRect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* get DPC data at IRQL */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
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 uint32_t cContexts3D = ASMAtomicReadU32(&pDevExt->cContexts3D);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->SurfDesc.VidPnSourceId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->SurfDesc.VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDstAlloc->SurfDesc.VidPnSourceId, pBlt->Blt.SrcAlloc.segmentIdAlloc, pBlt->Blt.SrcAlloc.offAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (vboxVhwaHlpOverlayListIsEmpty(pDevExt, pDstAlloc->SurfDesc.VidPnSourceId))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 1; i < pBlt->Blt.DstRects.UpdateRects.cRects; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmRectUnited(&rect, &rect, &pBlt->Blt.DstRects.UpdateRects.aRects[i]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &rect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &rect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmSubmitBltCmd(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, pBlt, fBltFlags);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmSubmitBltCmd(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, pBlt, fBltFlags);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(vboxWddmRectIsEqual(&pBlt->Blt.SrcRect, &pBlt->Blt.DstRects.ContextRect));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pBlt->Blt.DstRects.UpdateRects.cRects == 1);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(vboxWddmRectIsEqual(&pBlt->Blt.SrcRect, pBlt->Blt.DstRects.UpdateRects.aRects));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pDstAlloc->SurfDesc.VidPnSourceId != D3DDDI_ID_UNINITIALIZED &&
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync !vboxVhwaHlpOverlayListIsEmpty(pDevExt, pDstAlloc->SurfDesc.VidPnSourceId))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmSubmitBltCmd(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, pBlt, fBltFlags);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD *pChromiumCmd = (VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD*)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbCmd = VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[pChromiumCmd->Base.u32CmdReserved]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, cbCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: try flushing.. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // vboxVdmaCBufDrCreate zero initializes the pDr
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHROMIUM_CMD);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBody->cBuffers = pChromiumCmd->Base.u32CmdReserved;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < pChromiumCmd->Base.u32CmdReserved; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_UHGSMI_BUFFER_SUBMIT_INFO *pBufInfo = &pChromiumCmd->aBufInfos[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBufCmd->u32GuesData = pBufInfo->bDoNotSignalCompletion;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBufCmd->u64GuesData = (uint64_t)pBufInfo->Alloc.pAlloc;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVdmaDdiCmdInit(pDdiCmd, pSubmitCommand->SubmissionFenceId, pContext, vboxWddmDmaCompleteChromiumCmd, pDr);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxVdmaDdiCmdSubmitted(pDevExt, &pDevExt->DdiCmdQueue, pDdiCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip = (VBOXWDDM_DMA_PRIVATEDATA_FLIP*)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlipCmd = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)vboxVdmaGgCmdCreate(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync &pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_DMACMD, sizeof (VBOXVDMAPIPE_CMD_DMACMD_FLIP));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pFlip->Flip.Alloc.srcId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVdmaDdiCmdInit(&pFlipCmd->Hdr.DdiCmd, pSubmitCommand->SubmissionFenceId, pContext, vboxVdmaGgDdiCmdDestroy, pFlipCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pFlipCmd->Hdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(&pFlipCmd->Flip, &pFlip->Flip, sizeof (pFlipCmd->Flip));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmSubmitCmd(pDevExt, &pFlipCmd->Hdr);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_FAULTED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pPrivateDataBase;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCFCmd = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)vboxVdmaGgCmdCreate(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync &pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_DMACMD,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync RT_OFFSETOF(VBOXVDMAPIPE_CMD_DMACMD_CLRFILL, ClrFill.Rects.aRects[pCF->ClrFill.Rects.cRects]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pFlip->Flip.Alloc.srcId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVdmaDdiCmdInit(&pCFCmd->Hdr.DdiCmd, pSubmitCommand->SubmissionFenceId, pContext, vboxVdmaGgDdiCmdDestroy, pCFCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCFCmd->Hdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(&pCFCmd->ClrFill, &pCF->ClrFill, RT_OFFSETOF(VBOXVDMA_CLRFILL, Rects.aRects[pCF->ClrFill.Rects.cRects]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_FAULTED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, 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);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: try flushing.. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // vboxVdmaCBufDrCreate zero initializes the pDr
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync //pDr->fFlags = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDr->cbBuf = pSubmitCommand->DmaBufferSubmissionEndOffset - pSubmitCommand->DmaBufferSubmissionStartOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDr->u32FenceId = pSubmitCommand->SubmissionFenceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDr->u64GuestContext = (uint64_t)pPrivateData->pContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // else // vboxVdmaCBufDrCreate zero initializes the pDr
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // pDr->u64GuestContext = NULL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDr->Location.phBuf = pSubmitCommand->DmaBufferPhysicalAddress.QuadPart + pSubmitCommand->DmaBufferSubmissionStartOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, context(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// AssertBreakpoint();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: fixme: implement */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic uint32_t vboxWddmSysMemElBuild(PVBOXVDMACMD_SYSMEMEL pEl, PMDL pMdl, uint32_t iPfn, uint32_t cPages, uint32_t cbBuffer, uint32_t *pcPagesRemaining)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bool bArrayMode = false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PFN_NUMBER next = MmGetMdlPfnArray(pMdl)[iPfn+cBufs];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* array mode */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic uint32_t vboxWddmBpbTransferVRamSysBuildEls(PVBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS pCmd, PMDL pMdl, uint32_t iPfn, uint32_t cPages, uint32_t cbBuffer, uint32_t *pcPagesRemaining)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cbBufferUsed = vboxWddmSysMemElBuild(&pCmd->FirstEl, pMdl, iPfn, cPages, cbBuffer, &cPages);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD_SYSMEMEL pEl = VBOXVDMACMD_SYSMEMEL_NEXT(pEl);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync cbBufferUsed = vboxWddmSysMemElBuild(pEl, pMdl, iPfn + cInitPages - cPages, cPages, cbBuffer - cbBufferUsed, &cPages);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiBuildPagingBuffer
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiBuildPagingBuffer should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if ((!pBuildPagingBuffer->Transfer.Source.SegmentId) != (!pBuildPagingBuffer->Transfer.Destination.SegmentId))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD pCmd = (PVBOXVDMACMD)pBuildPagingBuffer->pDmaBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCmd->enmType = VBOXVDMACMD_TYPE_DMA_BPB_TRANSFER_VRAMSYS;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS pBody = VBOXVDMACMD_BODY(pCmd, VBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cPages = (pBuildPagingBuffer->Transfer.TransferSize + 0xfff) >> 12;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t iFirstPage = pBuildPagingBuffer->Transfer.MdlOffset + pBuildPagingBuffer->MultipassOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint64_t off = pBuildPagingBuffer->Transfer.Source.SegmentAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync off += pBuildPagingBuffer->Transfer.TransferOffset + (pBuildPagingBuffer->MultipassOffset << 12);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBody->fFlags = 0;//VBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS_SYS2VRAM
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint64_t off = pBuildPagingBuffer->Transfer.Destination.SegmentAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync off += pBuildPagingBuffer->Transfer.TransferOffset + (pBuildPagingBuffer->MultipassOffset << 12);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pMdl = pBuildPagingBuffer->Transfer.Destination.pMdl;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBody->fFlags = VBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS_SYS2VRAM;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t sbBufferUsed = vboxWddmBpbTransferVRamSysBuildEls(pBody, pMdl, iFirstPage, cPages, pBuildPagingBuffer->DmaSize, &cPagesRemaining);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->Transfer.hAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && !pAlloc->fRcFlags.Overlay /* overlay surfaces actually contain a valid data */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE /* shadow primary - also */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER /* hgsmi buffer - also */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we do now care about the others for now */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbCmd = VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_BPB_TRANSFER);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, cbCmd);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync SIZE_T cbTransferSize = pBuildPagingBuffer->Transfer.TransferSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // 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;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint64_t off = pBuildPagingBuffer->Transfer.Source.SegmentAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync off += pBuildPagingBuffer->Transfer.TransferOffset + cbTransfered;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBody->fFlags |= VBOXVDMACMD_DMA_BPB_TRANSFER_F_SRC_VRAMOFFSET;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT index = pBuildPagingBuffer->Transfer.MdlOffset + (UINT)(cbTransfered>>12);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBody->Src.phBuf = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Source.pMdl)[index] << 12;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PFN_NUMBER num = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Source.pMdl)[index];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 1; i < ((cbTransferSize - cbTransfered + 0xfff) >> 12); ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PFN_NUMBER cur = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Source.pMdl)[index+i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pBuildPagingBuffer->Transfer.Destination.SegmentId)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint64_t off = pBuildPagingBuffer->Transfer.Destination.SegmentAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync off += pBuildPagingBuffer->Transfer.TransferOffset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBody->fFlags |= VBOXVDMACMD_DMA_BPB_TRANSFER_F_DST_VRAMOFFSET;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT index = pBuildPagingBuffer->Transfer.MdlOffset + (UINT)(cbTransfered>>12);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBody->Dst.phBuf = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Destination.pMdl)[index] << 12;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PFN_NUMBER num = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Destination.pMdl)[index];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 1; i < ((cbTransferSize - cbTransfered + 0xfff) >> 12); ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PFN_NUMBER cur = MmGetMdlPfnArray(pBuildPagingBuffer->Transfer.Destination.pMdl)[index+i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync cbCurTransfer = RT_MIN(cbTransferSize - cbTransfered, cSrcPages << 12);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync cbCurTransfer = RT_MIN(cbCurTransfer, cDstPages << 12);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = vboxVdmaCBufDrSubmitSynch(pDevExt, &pDevExt->u.primary.Vdma, pDr);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: try flushing.. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#endif /* #ifdef VBOX_WITH_VDMA */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pBuildPagingBuffer->pDmaBuffer = (uint8_t*)pBuildPagingBuffer->pDmaBuffer + VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_BPB_FILL);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// AssertBreakpoint();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("unsupported op (%d)", pBuildPagingBuffer->Operation));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: fixme: implement */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncBOOL vboxWddmPointerCopyColorData(CONST DXGKARG_SETPOINTERSHAPE* pSetPointerShape, PVIDEO_POINTER_ATTRIBUTES pPointerAttributes)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* truncate masks if we exceed supported size */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Width = min(srcMaskW, VBOXWDDM_C_POINTER_MAX_WIDTH);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Height = min(srcMaskH, VBOXWDDM_C_POINTER_MAX_HEIGHT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->WidthInBytes = pPointerAttributes->Width * 4;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* cnstruct and mask from alpha color channel */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* sanity check */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cbData = RT_ALIGN_T(dstBytesPerLine*pPointerAttributes->Height, 4, ULONG)+
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Height*pPointerAttributes->WidthInBytes;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cbPointerAttributes = RT_OFFSETOF(VIDEO_POINTER_ATTRIBUTES, Pixels[cbData]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(VBOXWDDM_POINTER_ATTRIBUTES_SIZE >= cbPointerAttributes);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (VBOXWDDM_POINTER_ATTRIBUTES_SIZE < cbPointerAttributes)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("VBOXWDDM_POINTER_ATTRIBUTES_SIZE(%d) < cbPointerAttributes(%d)", VBOXWDDM_POINTER_ATTRIBUTES_SIZE, cbPointerAttributes));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pDst, 0xFF, dstBytesPerLine*pPointerAttributes->Height);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (x=0, bit=7; x<pPointerAttributes->Width; ++x, --bit)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pSrc[y*pSetPointerShape->Pitch + x*4 + 3] > 0x7F)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* copy 32bpp to XOR DIB, it start in pPointerAttributes->Pixels should be 4bytes aligned */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDst = pPointerAttributes->Pixels + RT_ALIGN_T(dstBytesPerLine*pPointerAttributes->Height, 4, ULONG);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(pDst+y*dstBytesPerLine, pSrc+y*pSetPointerShape->Pitch, dstBytesPerLine);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncBOOL vboxWddmPointerCopyMonoData(CONST DXGKARG_SETPOINTERSHAPE* pSetPointerShape, PVIDEO_POINTER_ATTRIBUTES pPointerAttributes)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* truncate masks if we exceed supported size */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Width = min(srcMaskW, VBOXWDDM_C_POINTER_MAX_WIDTH);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Height = min(srcMaskH, VBOXWDDM_C_POINTER_MAX_HEIGHT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->WidthInBytes = pPointerAttributes->Width * 4;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* copy AND mask */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(pDst+y*dstBytesPerLine, pSrc+y*pSetPointerShape->Pitch, dstBytesPerLine);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* convert XOR mask to RGB0 DIB, it start in pPointerAttributes->Pixels should be 4bytes aligned */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSrc = (BYTE*)pSetPointerShape->pPixels + srcMaskH*pSetPointerShape->Pitch;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDst = pPointerAttributes->Pixels + RT_ALIGN_T(dstBytesPerLine*pPointerAttributes->Height, 4, ULONG);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (x=0, bit=7; x<pPointerAttributes->Width; ++x, --bit)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync *(ULONG*)&pDst[y*dstBytesPerLine+x*4] = (pSrc[y*pSetPointerShape->Pitch+x/8] & RT_BIT(bit)) ? 0x00FFFFFF : 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic BOOLEAN vboxVddmPointerShapeToAttributes(CONST DXGKARG_SETPOINTERSHAPE* pSetPointerShape, PVBOXWDDM_POINTER_INFO pPointerInfo)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVIDEO_POINTER_ATTRIBUTES pPointerAttributes = &pPointerInfo->Attributes.data;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* pPointerAttributes maintains the visibility state, clear all except visibility */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Enable &= VBOX_MOUSE_POINTER_VISIBLE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pSetPointerShape->Flags.Value == 1 || pSetPointerShape->Flags.Value == 2);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (vboxWddmPointerCopyColorData(pSetPointerShape, pPointerAttributes))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Flags = VIDEO_MODE_COLOR_POINTER;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Enable |= VBOX_MOUSE_POINTER_ALPHA;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (vboxWddmPointerCopyMonoData(pSetPointerShape, pPointerAttributes))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 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;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Enable |= (pSetPointerShape->XHot & 0xFF) << 16;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CONST DXGKARG_SETPOINTERPOSITION* pSetPointerPosition)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// 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;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bNotifyVisibility = (pGlobalPointerInfo->cVisible == 0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!(pPointerAttributes->Enable & VBOX_MOUSE_POINTER_VISIBLE))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Enable |= VBOX_MOUSE_POINTER_VISIBLE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!!(pPointerAttributes->Enable & VBOX_MOUSE_POINTER_VISIBLE))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pGlobalPointerInfo->cVisible < UINT32_MAX/2);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Enable &= ~VBOX_MOUSE_POINTER_VISIBLE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync bNotifyVisibility = (pGlobalPointerInfo->cVisible == 0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPointerAttributes->Column = pSetPointerPosition->X;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (bNotifyVisibility && VBoxQueryHostWantsAbsolute())
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 if (VBoxMPCmnUpdatePointerShape(VBoxCommonFromDeviceExt(pDevExt), &pPointerInfo->Attributes.data, VBOXWDDM_POINTER_ATTRIBUTES_SIZE))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, hAdapter(0x%x)", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: fixme: implement */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* the lpRgnData->Buffer comes to us as RECT
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * to avoid extra memcpy we cast it to PRTRECT assuming
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * they are identical */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(RTRECT, xLeft));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(RTRECT, yBottom));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(RTRECT, xRight));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(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 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE_UHGSMI_SUBMIT pSubmit = (PVBOXDISPIFESCAPE_UHGSMI_SUBMIT)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_UHGSMI_SUBMIT)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pEscape->PrivateDriverDataSize == RT_OFFSETOF(VBOXDISPIFESCAPE_UHGSMI_SUBMIT, aBuffers[pEscapeHdr->u32CmdSpecific]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pEscape->PrivateDriverDataSize == RT_OFFSETOF(VBOXDISPIFESCAPE_UHGSMI_SUBMIT, aBuffers[pEscapeHdr->u32CmdSpecific]))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVideoAMgrCtxAllocSubmit(pDevExt, &pContext->AllocContext, pEscapeHdr->u32CmdSpecific, pSubmit->aBuffers);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE_UHGSMI_ALLOCATE pAlocate = (PVBOXDISPIFESCAPE_UHGSMI_ALLOCATE)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pEscape->PrivateDriverDataSize == sizeof (VBOXDISPIFESCAPE_UHGSMI_ALLOCATE));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize == sizeof (VBOXDISPIFESCAPE_UHGSMI_ALLOCATE))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVideoAMgrCtxAllocCreate(&pContext->AllocContext, &pAlocate->Alloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE_UHGSMI_DEALLOCATE pDealocate = (PVBOXDISPIFESCAPE_UHGSMI_DEALLOCATE)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pEscape->PrivateDriverDataSize == sizeof (VBOXDISPIFESCAPE_UHGSMI_DEALLOCATE));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize == sizeof (VBOXDISPIFESCAPE_UHGSMI_DEALLOCATE))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVideoAMgrCtxAllocDestroy(&pContext->AllocContext, pDealocate->hAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD pRegions = (PVBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVideoCmEscape(&pContext->CmContext, pRegions, pEscape->PrivateDriverDataSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LPRGNDATA lpRgnData = VBOXDISPIFESCAPE_DATA(pEscapeHdr, RGNDATA);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cbData = VBOXDISPIFESCAPE_DATA_SIZE(pEscape->PrivateDriverDataSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cbRects = cbData - RT_OFFSETOF(RGNDATA, Buffer);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* the lpRgnData->Buffer comes to us as RECT
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * to avoid extra memcpy we cast it to PRTRECT assuming
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * they are identical
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * see AssertCompile's above */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOG(("IOCTL_VIDEO_VBOX_SETVISIBLEREGION cRects=%d", cRects));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Inform the host about the visible region
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync sizeof (VMMDevVideoSetVisibleRegion) + (cRects-1)*sizeof(RTRECT),
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("VBOXESC_SETVISIBLEREGION: incorrect buffer size (%d), reported count (%d)", cbRects, lpRgnData->rdh.nCount));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: implement */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXDISPIFESCAPE_SCREENLAYOUT pLo = (PVBOXDISPIFESCAPE_SCREENLAYOUT)pEscapeHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pLo->ScreenLayout.cScreens <= (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < pLo->ScreenLayout.cScreens; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXSCREENLAYOUT_ELEMENT pEl = &pLo->ScreenLayout.aScreens[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pEl->VidPnSourceId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pEl->VidPnSourceId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pEl->VidPnSourceId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS tmpStatus = vboxWddmGhDisplayUpdateScreenPos(pDevExt, pSource, &pEl->pos);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("VBOXESC_SCREENLAYOUT: incorrect buffer size (%d) < sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT) (%d)",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmSwapchainCtxEscape(pDevExt, pContext, (PVBOXDISPIFESCAPE_SWAPCHAININFO)pEscapeHdr, pEscape->PrivateDriverDataSize);
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';
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("unsupported escape code (0x%x)", pEscapeHdr->escapeCode));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("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 = DxgkDdiInterruptRoutine(pdc->pDevExt, pdc->MessageNumber);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pdc->uLastCompletedCmdFenceId = pdc->pDevExt->u.primary.Vdma.uLastCompletedPagingBufferCmdFenceId;
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. */
bbe8d54f2bca31d98ce10c89506ca5a53c9d41b7vboxsync PVBOXMP_DEVEXT pContext = (PVBOXMP_DEVEXT)hAdapter;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL;
bbe8d54f2bca31d98ce10c89506ca5a53c9d41b7vboxsync Status = pContext->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pIsSupportedVidPnArg->hDesiredVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface);
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync WARN(("DxgkCbQueryVidPnInterface failed Status()0x%x\n", Status));
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync vboxVidPnDumpVidPn("\n>>>>IS SUPPORTED VidPN : >>>>", pContext, pIsSupportedVidPnArg->hDesiredVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<");
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync Status = pVidPnInterface->pfnGetTopology(pIsSupportedVidPnArg->hDesiredVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync WARN(("pfnGetTopology failed Status()0x%x\n", Status));
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync Status = vboxVidPnCheckTopology(hVidPnTopology, pVidPnTopologyInterface, TRUE /* fBreakOnDisabled */, RT_ELEMENTS(aItems), aItems, &fDisabledFound);
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync WARN(("vboxVidPnCheckTopology failed Status()0x%x\n", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pIsSupportedVidPnArg->IsVidPnSupported = bSupported;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("The Given VidPn is %ssupported\n", pIsSupportedVidPnArg->IsVidPnSupported ? "" : "!!NOT!! "));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CONST DXGKARG_RECOMMENDFUNCTIONALVIDPN* CONST pRecommendFunctionalVidPnArg
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* The DxgkDdiRecommendFunctionalVidPn should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_RECOMMENDVIDPN pVidPnInfo = pRecommendFunctionalVidPnArg->PrivateDriverDataSize >= sizeof (VBOXWDDM_RECOMMENDVIDPN) ?
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync (PVBOXWDDM_RECOMMENDVIDPN)pRecommendFunctionalVidPnArg->pPrivateDriverData : NULL;
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmUpdateVideoModesInfo(pDevExt, NULL /*pVidPnInfo*/);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface);
dfec9ba035ff0c77d470041bc230a60542d39e27vboxsync for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: check that we actually need the current source->target */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VIDEO_MODE_INFORMATION *pModeInfo = &pInfo->aModes[pInfo->iPreferredMode];
dfec9ba035ff0c77d470041bc230a60542d39e27vboxsync Status = vboxVidPnCheckAddMonitorModes(pDevExt, i, D3DKMDT_MCO_DRIVER, &Resolution, 1);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("vboxVidPnCheckAddMonitorModes failed Status(0x%x)", Status));
dfec9ba035ff0c77d470041bc230a60542d39e27vboxsync for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
dfec9ba035ff0c77d470041bc230a60542d39e27vboxsync 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);
bbe8d54f2bca31d98ce10c89506ca5a53c9d41b7vboxsync 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);
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync WARN(("DxgkCbQueryVidPnInterface failed Status()0x%x\n", Status));
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync vboxVidPnDumpCofuncModalityArg(">>>>MODALITY Args: ", pEnumCofuncModalityArg, "\n");
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync vboxVidPnDumpVidPn(">>>>MODALITY VidPN (IN) : >>>>\n", pDevExt, pEnumCofuncModalityArg->hConstrainingVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n");
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync Status = pVidPnInterface->pfnGetTopology(pEnumCofuncModalityArg->hConstrainingVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync WARN(("pfnGetTopology failed Status()0x%x\n", Status));
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync Status = vboxVidPnCheckTopology(hVidPnTopology, pVidPnTopologyInterface, FALSE /* fBreakOnDisabled */, RT_ELEMENTS(aItems), aItems, NULL /* *pfDisabledFound */);
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync WARN(("vboxVidPnCheckTopology failed Status()0x%x\n", Status));
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync CbContext.pEnumCofuncModalityArg = pEnumCofuncModalityArg;
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync CbContext.pInfos = VBoxWddmGetAllVideoModesInfos(pDevExt);
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface,
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync WARN(("vboxVidPnEnumPaths failed Status()0x%x\n", Status));
5793d23a719d4902824a3649b6fef3822ddd5fc7vboxsync 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));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CONST DXGKARG_SETVIDPNSOURCEADDRESS* pSetVidPnSourceAddress
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* 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, &pSource->VScreenPos);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if ((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays > pSetVidPnSourceAddress->VidPnSourceId)
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(pDevExt, pSource, pAllocation, pSetVidPnSourceAddress->VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->offVram = (VBOXVIDEOOFFSET)pSetVidPnSourceAddress->PrimaryAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->SegmentId = pSetVidPnSourceAddress->PrimarySegment;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync || pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this is the case of full-screen d3d, ensure we notify host */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC &&
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* to ensure the resize request gets issued in case we exit a full-screen D3D mode */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* should not generally happen, but still inform host*/
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmGhDisplaySetInfo(pDevExt, pSource, pSetVidPnSourceAddress->VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("vboxWddmGhDisplaySetInfo failed, Status (0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("invalid VidPnSourceId (%d), should be smaller than (%d)", pSetVidPnSourceAddress->VidPnSourceId, VBoxCommonFromDeviceExt(pDevExt)->cDisplays));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync CONST DXGKARG_SETVIDPNSOURCEVISIBILITY* pSetVidPnSourceVisibility
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiSetVidPnSourceVisibility should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays > pSetVidPnSourceVisibility->VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pSetVidPnSourceVisibility->VidPnSourceId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId, &pSource->VScreenPos);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if ((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays > pSetVidPnSourceVisibility->VidPnSourceId)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAllocation = pSource->pPrimaryAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync || pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAllocation->bVisible != pSetVidPnSourceVisibility->Visible);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pAllocation->bVisible != pSetVidPnSourceVisibility->Visible)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->bVisible = pSetVidPnSourceVisibility->Visible;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (/* this is the case of full-screen d3d, ensure we notify host */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* to ensure the resize request gets issued in case we exit a full-screen D3D mode */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmGhDisplaySetInfo(pDevExt, pSource, pSetVidPnSourceVisibility->VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("vboxWddmGhDisplaySetInfo failed, Status (0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("invalid VidPnSourceId (%d), should be smaller than (%d)", pSetVidPnSourceVisibility->VidPnSourceId, VBoxCommonFromDeviceExt(pDevExt)->cDisplays));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pCommitVidPnArg->hFunctionalVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVidPnDumpVidPn("\n>>>>COMMIT VidPN: >>>>", pDevExt, pCommitVidPnArg->hFunctionalVidPn, pVidPnInterface, "<<<<<<<<<<<<<<<<<<<<\n");
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pCommitVidPnArg->AffectedVidPnSourceId != D3DDDI_ID_ALL)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCommitVidPnArg->hFunctionalVidPn, pVidPnInterface,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCommitVidPnArg->AffectedVidPnSourceId, (PVBOXWDDM_ALLOCATION)pCommitVidPnArg->hPrimaryAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("vboxVidPnCommitSourceModeForSrcId failed Status(0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* clear all current primaries */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[i], NULL, i);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = pVidPnInterface->pfnGetTopology(pCommitVidPnArg->hFunctionalVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("vboxVidPnCommitPathEnum failed Status(0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("vboxVidPnEnumPaths failed Status(0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("pfnGetTopology failed Status(0x%x)", Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->u.primary.hCommittedVidPn = pCommitVidPnArg->hFunctionalVidPn;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("DxgkCbQueryVidPnInterface failed Status(0x%x)", Status));
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 D3DKMDT_MONITOR_SOURCE_MODE * pNewMonitorSourceModeInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = pRecommendMonitorModesArg->pMonitorSourceModeSetInterface->pfnCreateNewModeInfo(
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRecommendMonitorModesArg->hMonitorSourceModeSet, &pNewMonitorSourceModeInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVidPnPopulateMonitorSourceModeInfoFromLegacy(pDevExt,
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 Assert((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays > pGetScanLine->VidPnTargetId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[pGetScanLine->VidPnTargetId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pTarget->HeightTotal > pTarget->HeightVisible);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pTarget->ScanLineState < pTarget->HeightTotal);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pTarget->ScanLineState >= pTarget->HeightTotal)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync BOOL bVBlank = (!curScanLine || curScanLine > pTarget->HeightVisible);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// AssertBreakpoint();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: STATUS_NOT_IMPLEMENTED ?? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)vboxWddmMemAllocZero(sizeof (VBOXWDDM_OVERLAY));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = vboxVhwaHlpOverlayCreate(pDevExt, pCreateOverlay->VidPnSourceId, &pCreateOverlay->OverlayInfo, pOverlay);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiDestroyDevice should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiOpenAllocation
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiOpenAllocation should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pOpenAllocation->PrivateDriverSize == sizeof (VBOXWDDM_RCINFO));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pOpenAllocation->PrivateDriverSize >= sizeof (VBOXWDDM_RCINFO))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRcInfo = (PVBOXWDDM_RCINFO)pOpenAllocation->pPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRcInfo->cAllocInfos == pOpenAllocation->NumAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < pOpenAllocation->NumAllocations; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_OPENALLOCATIONINFO* pInfo = &pOpenAllocation->pOpenAllocation[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_OPENALLOCATION pOa = (PVBOXWDDM_OPENALLOCATION)vboxWddmMemAllocZero(sizeof (VBOXWDDM_OPENALLOCATION));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAllocation = vboxWddmGetAllocationFromOpenData(pDevExt, pOa);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we have queried host for some surface info, like pitch & size,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * need to return it back to the UMD (User Mode Drive) */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* success, just continue */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we are here in case of error */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT j = 0; j < i; ++j)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_OPENALLOCATIONINFO* pInfo2Free = &pOpenAllocation->pOpenAllocation[j];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_OPENALLOCATION pOa2Free = (PVBOXWDDM_OPENALLOCATION)pInfo2Free->hDeviceSpecificAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiCloseAllocation should be made pageable. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < pCloseAllocation->NumAllocations; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmMemFree(pCloseAllocation->pOpenHandleList[i]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, hContext(0x%x)", hContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRender->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pRender->DmaBufferPrivateDataSize < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRender->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: can this actually happen? what status to return? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pRender->CommandLength < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRender->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: can this actually happen? what status to return? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pInputHdr = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)pRender->pCommand;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pRender->CommandLength != RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, aBufInfos[pInputHdr->u32CmdReserved]))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD pUmCmd = (PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD)pInputHdr;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD pChromiumCmd = (PVBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD)pRender->pDmaBufferPrivateData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync const uint32_t cbDma = RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD, aBufInfos[pInputHdr->u32CmdReserved]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pRender->PatchLocationListOutSize < pInputHdr->u32CmdReserved)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pChromiumCmd->Base.enmCmd = VBOXVDMACMD_TYPE_CHROMIUM_CMD;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pChromiumCmd->Base.u32CmdReserved = pInputHdr->u32CmdReserved;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRender->pDmaBufferPrivateData = (uint8_t*)pRender->pDmaBufferPrivateData + cbDma;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRender->pDmaBuffer = ((uint8_t*)pRender->pDmaBuffer) + cbDma;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DDDI_PATCHLOCATIONLIST* pPLL = pRender->pPatchLocationListOut;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pPLL, 0, sizeof (*pPLL) * pChromiumCmd->Base.u32CmdReserved);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRender->pPatchLocationListOut += pInputHdr->u32CmdReserved;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_UHGSMI_BUFFER_SUBMIT_INFO pSubmInfo = pChromiumCmd->aBufInfos;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO pSubmUmInfo = pUmCmd->aBufInfos;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_ALLOCATIONLIST *pAllocationList = pRender->pAllocationList;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < pChromiumCmd->Base.u32CmdReserved; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pAllocationList);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmPopulateDmaAllocInfoWithOffset(&pSubmInfo->Alloc, pAlloc, pAllocationList, pSubmUmInfo->offData);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSubmInfo->bDoNotSignalCompletion = pSubmUmInfo->fSubFlags.bDoNotSignalCompletion;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPLL->PatchOffset = RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD, aBufInfos[i].Alloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pPrivateData = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)pRender->pDmaBufferPrivateData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRender->pDmaBufferPrivateData = (uint8_t*)pRender->pDmaBufferPrivateData + sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRender->pDmaBuffer = ((uint8_t*)pRender->pDmaBuffer) + pRender->CommandLength;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRender->DmaSize >= pRender->CommandLength);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRender->PatchLocationListOutSize >= pRender->PatchLocationListInSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbPLL = pRender->PatchLocationListInSize * sizeof (pRender->pPatchLocationListOut[0]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(pRender->pPatchLocationListOut, pRender->pPatchLocationListIn, cbPLL);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRender->pPatchLocationListOut += pRender->PatchLocationListInSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, hContext(0x%x)", hContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#define VBOXVDMACMD_DMA_PRESENT_BLT_MINSIZE() (VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_PRESENT_BLT))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#define VBOXVDMACMD_DMA_PRESENT_BLT_SIZE(_c) (VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, aDstSubRects[_c]))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(VOID) vboxWddmRectlFromRect(const RECT *pRect, PVBOXVDMA_RECTL pRectl)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRectl->width = (uint16_t)(pRect->right - pRect->left);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRectl->height = (uint16_t)(pRect->bottom - pRect->top);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(VBOXVDMA_PIXEL_FORMAT) vboxWddmFromPixFormat(D3DDDIFORMAT format)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(VOID) vboxWddmSurfDescFromAllocation(PVBOXWDDM_ALLOCATION pAllocation, PVBOXVDMA_SURF_DESC pDesc)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDesc->format = vboxWddmFromPixFormat(pAllocation->SurfDesc.format);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(BOOLEAN) vboxWddmPixFormatConversionSupported(D3DDDIFORMAT From, D3DDDIFORMAT To)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(bool) vboxWddmCheckForVisiblePrimary(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync !!!primary could be of pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC!!!
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pAllocation->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DDDI_VIDEO_PRESENT_SOURCE_ID id = pAllocation->SurfDesc.VidPnSourceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (id >= (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return true;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiPresent
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("ENTER, hContext(0x%x)", hContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pPresent->DmaBufferPrivateDataSize < sizeof (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR (%d)", pPresent->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: can this actually happen? what status tu return? */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR pPrivateData = (PVBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR)pPresent->pDmaBufferPrivateData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cContexts3D = ASMAtomicReadU32(&pDevExt->cContexts3D);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->Flags.Value == 1); /* only Blt is set, we do not support anything else for now */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_ALLOCATIONLIST *pSrc = &pPresent->pAllocationList[DXGK_PRESENT_SOURCE_INDEX];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_ALLOCATIONLIST *pDst = &pPresent->pAllocationList[DXGK_PRESENT_DESTINATION_INDEX];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pSrcAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pSrc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pDstAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pDst);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert ((pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync || (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* issue VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE ONLY in case there are no 3D contexts currently
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * otherwise we would need info about all rects being updated on primary for visible rect reporting */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (vboxVhwaHlpOverlayListIsEmpty(pDevExt, pDstAlloc->SurfDesc.VidPnSourceId))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pPresent->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->SurfDesc.VidPnSourceId];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->SurfDesc.VidPnSourceId);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->SrcRect.left == pPresent->DstRect.left);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->SrcRect.right == pPresent->DstRect.right);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->SrcRect.top == pPresent->DstRect.top);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->SrcRect.bottom == pPresent->DstRect.bottom);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmRectUnited(&rect, &rect, &pPresent->pDstSubRects[i]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + sizeof (VBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + VBOXWDDM_DUMMY_DMABUFFER_SIZE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->DmaSize >= VBOXWDDM_DUMMY_DMABUFFER_SIZE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pPresent->pPatchLocationListOut, 0, 2*sizeof (D3DDDI_PATCHLOCATIONLIST));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_SOURCE_INDEX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_DESTINATION_INDEX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY pS2P = (PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY)pPrivateData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we do not know the shadow address yet, perform dummy DMA cycle */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmPopulateDmaAllocInfo(&pS2P->Shadow2Primary.ShadowAlloc, pSrcAlloc, pSrc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// vboxWddmPopulateDmaAllocInfo(&pPrivateData->DstAllocInfo, pDstAlloc, pDst);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pS2P->Shadow2Primary.VidPnSourceId = pDstAlloc->SurfDesc.VidPnSourceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we're here because this is NOT a shadow->primary update
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * or because there are d3d contexts and we need to report visible rects
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * or because we have overlays active and we need a special handling for primary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_BLT;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_BLT pBlt = (PVBOXWDDM_DMA_PRIVATEDATA_BLT)pPrivateData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmPopulateDmaAllocInfo(&pBlt->Blt.SrcAlloc, pSrcAlloc, pSrc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmPopulateDmaAllocInfo(&pBlt->Blt.DstAlloc, pDstAlloc, pDst);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBlt->Blt.DstRects.ContextRect = pPresent->DstRect;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbHead = RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_BLT, Blt.DstRects.UpdateRects.aRects[0]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->SubRectCnt > pPresent->MultipassOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbRects = (pPresent->SubRectCnt - pPresent->MultipassOffset) * sizeof (RECT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + cbHead + cbRects;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + VBOXWDDM_DUMMY_DMABUFFER_SIZE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->DmaSize >= VBOXWDDM_DUMMY_DMABUFFER_SIZE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(&pBlt->Blt.DstRects.UpdateRects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbRects);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBlt->Blt.DstRects.UpdateRects.cRects += cbRects/sizeof (RECT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbFitingRects = (cbCmd/sizeof (RECT)) * sizeof (RECT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(&pBlt->Blt.DstRects.UpdateRects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbFitingRects);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->MultipassOffset += cbFitingRects/sizeof (RECT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pBlt->Blt.DstRects.UpdateRects.cRects += cbFitingRects/sizeof (RECT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->SubRectCnt > pPresent->MultipassOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pPresent->pPatchLocationListOut, 0, 2*sizeof (D3DDDI_PATCHLOCATIONLIST));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_SOURCE_INDEX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_DESTINATION_INDEX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cmdSize = VBOXVDMACMD_DMA_PRESENT_BLT_SIZE(pPresent->SubRectCnt - pPresent->MultipassOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD pCmd = (PVBOXVDMACMD)pPresent->pDmaBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + cmdSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(cbCmd >= VBOXVDMACMD_DMA_PRESENT_BLT_MINSIZE());
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (cbCmd >= VBOXVDMACMD_DMA_PRESENT_BLT_MINSIZE())
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (vboxWddmPixFormatConversionSupported(pSrcAlloc->SurfDesc.format, pDstAlloc->SurfDesc.format))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pPresent->pPatchLocationListOut, 0, 2*sizeof (D3DDDI_PATCHLOCATIONLIST));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // pPresent->pPatchLocationListOut->PatchOffset = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // ++pPresent->pPatchLocationListOut;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->PatchOffset = VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, offSrc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_SOURCE_INDEX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->PatchOffset = VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, offDst);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_DESTINATION_INDEX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD_DMA_PRESENT_BLT pTransfer = VBOXVDMACMD_BODY(pCmd, VBOXVDMACMD_DMA_PRESENT_BLT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pTransfer->offSrc = (VBOXVIDEOOFFSET)pSrc->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pTransfer->offDst = (VBOXVIDEOOFFSET)pDst->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmSurfDescFromAllocation(pSrcAlloc, &pTransfer->srcDesc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmSurfDescFromAllocation(pDstAlloc, &pTransfer->dstDesc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmRectlFromRect(&pPresent->SrcRect, &pTransfer->srcRectl);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmRectlFromRect(&pPresent->DstRect, &pTransfer->dstRectl);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync cbCmd -= VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, aDstSubRects);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmRectlFromRect(&pPresent->pDstSubRects[i + pPresent->MultipassOffset], &pTransfer->aDstSubRects[i]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_BLT;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + sizeof(VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("unsupported format conversion from(%d) to (%d)",pSrcAlloc->SurfDesc.format, pDstAlloc->SurfDesc.format));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this should not happen actually */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while(0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this should not happen actually */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("failed to get Dst Allocation info for hDeviceSpecificAllocation(0x%x)",pDst->hDeviceSpecificAllocation));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this should not happen actually */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("failed to get Src Allocation info for hDeviceSpecificAllocation(0x%x)",pSrc->hDeviceSpecificAllocation));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cmdSize = VBOXVDMACMD_DMA_PRESENT_BLT_SIZE(pPresent->SubRectCnt - pPresent->MultipassOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD pCmd = (PVBOXVDMACMD)pPresent->pDmaBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + cmdSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(cbCmd >= VBOXVDMACMD_DMA_PRESENT_BLT_MINSIZE());
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (cbCmd >= VBOXVDMACMD_DMA_PRESENT_BLT_MINSIZE())
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_ALLOCATIONLIST *pSrc = &pPresent->pAllocationList[DXGK_PRESENT_SOURCE_INDEX];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_ALLOCATIONLIST *pDst = &pPresent->pAllocationList[DXGK_PRESENT_DESTINATION_INDEX];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pSrcAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pSrc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pDstAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pDst);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (vboxWddmPixFormatConversionSupported(pSrcAlloc->SurfDesc.format, pDstAlloc->SurfDesc.format))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pPresent->pPatchLocationListOut, 0, 2*sizeof (D3DDDI_PATCHLOCATIONLIST));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pPresent->pPatchLocationListOut->PatchOffset = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// ++pPresent->pPatchLocationListOut;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->PatchOffset = VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, offSrc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_SOURCE_INDEX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->PatchOffset = VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, offDst);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_DESTINATION_INDEX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXVDMACMD_DMA_PRESENT_BLT pTransfer = VBOXVDMACMD_BODY(pCmd, VBOXVDMACMD_DMA_PRESENT_BLT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pTransfer->offSrc = (VBOXVIDEOOFFSET)pSrc->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pTransfer->offDst = (VBOXVIDEOOFFSET)pDst->PhysicalAddress.QuadPart;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmSurfDescFromAllocation(pSrcAlloc, &pTransfer->srcDesc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmSurfDescFromAllocation(pDstAlloc, &pTransfer->dstDesc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmRectlFromRect(&pPresent->SrcRect, &pTransfer->srcRectl);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmRectlFromRect(&pPresent->DstRect, &pTransfer->dstRectl);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync cbCmd -= VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, aDstSubRects);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmRectlFromRect(&pPresent->pDstSubRects[i + pPresent->MultipassOffset], &pTransfer->aDstSubRects[i]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + sizeof(VBOXWDDM_DMA_PRIVATEDATA_HDR);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("unsupported format conversion from(%d) to (%d)",pSrcAlloc->SurfDesc.format, pDstAlloc->SurfDesc.format));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this should not happen actually */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("failed to get Dst Allocation info for hDeviceSpecificAllocation(0x%x)",pDst->hDeviceSpecificAllocation));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this should not happen actually */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("failed to get Src Allocation info for hDeviceSpecificAllocation(0x%x)",pSrc->hDeviceSpecificAllocation));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this should not happen actually */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->Flags.Value == 4); /* only Blt is set, we do not support anything else for now */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_ALLOCATIONLIST *pSrc = &pPresent->pAllocationList[DXGK_PRESENT_SOURCE_INDEX];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pSrcAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pSrc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_FLIP pFlip = (PVBOXWDDM_DMA_PRIVATEDATA_FLIP)pPrivateData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmPopulateDmaAllocInfo(&pFlip->Flip.Alloc, pSrcAlloc, pSrc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbCmd = sizeof (VBOXWDDM_DMA_PRIVATEDATA_FLIP);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + cbCmd;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + VBOXWDDM_DUMMY_DMABUFFER_SIZE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->DmaSize >= VBOXWDDM_DUMMY_DMABUFFER_SIZE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pPresent->pPatchLocationListOut, 0, sizeof (D3DDDI_PATCHLOCATIONLIST));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_SOURCE_INDEX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this should not happen actually */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("failed to get pSrc Allocation info for hDeviceSpecificAllocation(0x%x)",pSrc->hDeviceSpecificAllocation));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_2D);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->Flags.Value == 2); /* only ColorFill is set, we do not support anything else for now */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DXGK_ALLOCATIONLIST *pDst = &pPresent->pAllocationList[DXGK_PRESENT_DESTINATION_INDEX];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCATION pDstAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pDst);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pPrivateData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmPopulateDmaAllocInfo(&pCF->ClrFill.Alloc, pDstAlloc, pDst);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbHead = RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_CLRFILL, ClrFill.Rects.aRects[0]);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->SubRectCnt > pPresent->MultipassOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbRects = (pPresent->SubRectCnt - pPresent->MultipassOffset) * sizeof (RECT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + cbHead + cbRects;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + VBOXWDDM_DUMMY_DMABUFFER_SIZE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->DmaSize >= VBOXWDDM_DUMMY_DMABUFFER_SIZE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(&pCF->ClrFill.Rects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbRects);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCF->ClrFill.Rects.cRects += cbRects/sizeof (RECT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT cbFitingRects = (cbCmd/sizeof (RECT)) * sizeof (RECT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(&pCF->ClrFill.Rects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbFitingRects);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->MultipassOffset += cbFitingRects/sizeof (RECT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCF->ClrFill.Rects.cRects += cbFitingRects/sizeof (RECT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pPresent->SubRectCnt > pPresent->MultipassOffset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pPresent->pPatchLocationListOut, 0, sizeof (D3DDDI_PATCHLOCATIONLIST));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_DESTINATION_INDEX;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this should not happen actually */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("failed to get pDst Allocation info for hDeviceSpecificAllocation(0x%x)",pDst->hDeviceSpecificAllocation));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("cmd NOT IMPLEMENTED!! Flags(0x%x)", pPresent->Flags.Value));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// LOGF(("LEAVE, hContext(0x%x), Status(0x%x)", hContext, Status));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = vboxVhwaHlpOverlayUpdate(pOverlay, &pUpdateOverlay->OverlayInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVhwaHlpOverlayDstRectGet(pOverlay->pDevExt, pOverlay, &DstRect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVdmaHlpUpdatePrimary(pOverlay->pDevExt, pOverlay->VidPnSourceId, &DstRect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = vboxVhwaHlpOverlayFlip(pOverlay, pFlipOverlay);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DxgkDdiCreateContext
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* DxgkDdiCreateContext should be made pageable */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)vboxWddmMemAllocZero(sizeof (VBOXWDDM_CONTEXT));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pContext->EngineAffinity = pCreateContext->EngineAffinity;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pContext->NodeOrdinal = pCreateContext->NodeOrdinal;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pCreateContext->Flags.SystemContext || pCreateContext->PrivateDriverDataSize == 0)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pCreateContext->PrivateDriverDataSize == 0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pCreateContext->Flags.Value <= 2); /* 2 is a GDI context in Win7 */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevExt->aSources[i].offVram = VBOXVIDEOOFFSET_VOID;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS tmpStatus= vboxWddmDisplaySettingsQueryPos(pDevExt, i, &pDevExt->aSources[i].VScreenPos);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pCreateContext->PrivateDriverDataSize == sizeof (VBOXWDDM_CREATECONTEXT_INFO));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pCreateContext->PrivateDriverDataSize == sizeof (VBOXWDDM_CREATECONTEXT_INFO))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CREATECONTEXT_INFO pInfo = (PVBOXWDDM_CREATECONTEXT_INFO)pCreateContext->pPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVideoAMgrCtxCreate(&pDevExt->AllocMgr, &pContext->AllocContext);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxWddmHTableCreate(&pContext->Swapchains, 4);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pContext->enmType = VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVideoCmCtxAdd(&pDevice->pAdapter->CmMgr, &pContext->CmContext, (HANDLE)pInfo->hUmEvent, pInfo->u64UmInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // ExAcquireFastMutex(&pDevExt->ContextMutex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // ExReleaseFastMutex(&pDevExt->ContextMutex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVideoAMgrCtxCreate(&pDevExt->AllocMgr, &pContext->AllocContext);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* do not break to go to the _2D branch and do the rest stuff */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateContext->ContextInfo.DmaBufferSize = VBOXWDDM_C_DMA_BUFFER_SIZE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateContext->ContextInfo.DmaBufferSegmentSet = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateContext->ContextInfo.DmaBufferPrivateDataSize = VBOXWDDM_C_DMA_PRIVATEDATA_SIZE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateContext->ContextInfo.AllocationListSize = VBOXWDDM_C_ALLOC_LIST_SIZE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateContext->ContextInfo.PatchLocationListSize = VBOXWDDM_C_PATH_LOCATION_LIST_SIZE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync //#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync //# error port to Win7 DDI
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // //pCreateContext->ContextInfo.DmaBufferAllocationGroup = ???;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync //#endif // DXGKDDI_INTERFACE_VERSION
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXMP_DEVEXT pDevExt = pContext->pDevice->pAdapter;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// ExAcquireFastMutex(&pDevExt->ContextMutex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// RemoveEntryList(&pContext->ListEntry);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cContexts = ASMAtomicDecU32(&pDevExt->cContexts3D);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// ExReleaseFastMutex(&pDevExt->ContextMutex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync NTSTATUS Status = vboxVideoAMgrCtxDestroy(&pContext->AllocContext);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Status = vboxVideoCmCtxRemove(&pContext->pDevice->pAdapter->CmMgr, &pContext->CmContext);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("ENTER, MiniportDeviceContext(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGF(("LEAVE, MiniportDeviceContext(0x%x)", MiniportDeviceContext));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /*CONST*/ DXGKARG_SETDISPLAYPRIVATEDRIVERFORMAT* pSetDisplayPrivateDriverFormat
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncNTSTATUS APIENTRY CALLBACK DxgkDdiRestartFromTimeout(IN_CONST_HANDLE hAdapter)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int irc = RTR0Init(0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (RT_FAILURE(irc))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync LOGREL(("VBoxMP::failed to init IPRT (rc=%#x)", irc));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return ERROR_INVALID_FUNCTION;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DRIVER_INITIALIZATION_DATA DriverInitializationData = {'\0'};
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // Fill in the DriverInitializationData structure and call DxgkInitialize()
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.Version = DXGKDDI_INTERFACE_VERSION;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiAddDevice = DxgkDdiAddDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiStartDevice = DxgkDdiStartDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiStopDevice = DxgkDdiStopDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiRemoveDevice = DxgkDdiRemoveDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiDispatchIoRequest = DxgkDdiDispatchIoRequest;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiInterruptRoutine = DxgkDdiInterruptRoutine;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiDpcRoutine = DxgkDdiDpcRoutine;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiQueryChildRelations = DxgkDdiQueryChildRelations;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiQueryChildStatus = DxgkDdiQueryChildStatus;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiQueryDeviceDescriptor = DxgkDdiQueryDeviceDescriptor;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiSetPowerState = DxgkDdiSetPowerState;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiNotifyAcpiEvent = DxgkDdiNotifyAcpiEvent;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiResetDevice = DxgkDdiResetDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiUnload = DxgkDdiUnload;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiQueryInterface = DxgkDdiQueryInterface;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiControlEtwLogging = DxgkDdiControlEtwLogging;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiQueryAdapterInfo = DxgkDdiQueryAdapterInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiCreateDevice = DxgkDdiCreateDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiCreateAllocation = DxgkDdiCreateAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiDestroyAllocation = DxgkDdiDestroyAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiDescribeAllocation = DxgkDdiDescribeAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiGetStandardAllocationDriverData = DxgkDdiGetStandardAllocationDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiAcquireSwizzlingRange = DxgkDdiAcquireSwizzlingRange;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiReleaseSwizzlingRange = DxgkDdiReleaseSwizzlingRange;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiPatch = DxgkDdiPatch;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiSubmitCommand = DxgkDdiSubmitCommand;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiPreemptCommand = DxgkDdiPreemptCommand;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiBuildPagingBuffer = DxgkDdiBuildPagingBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiSetPalette = DxgkDdiSetPalette;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiSetPointerPosition = DxgkDdiSetPointerPosition;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiSetPointerShape = DxgkDdiSetPointerShape;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiResetFromTimeout = DxgkDdiResetFromTimeout;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiRestartFromTimeout = DxgkDdiRestartFromTimeout;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiEscape = DxgkDdiEscape;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiCollectDbgInfo = DxgkDdiCollectDbgInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiQueryCurrentFence = DxgkDdiQueryCurrentFence;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiIsSupportedVidPn = DxgkDdiIsSupportedVidPn;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiRecommendFunctionalVidPn = DxgkDdiRecommendFunctionalVidPn;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiEnumVidPnCofuncModality = DxgkDdiEnumVidPnCofuncModality;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiSetVidPnSourceAddress = DxgkDdiSetVidPnSourceAddress;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiSetVidPnSourceVisibility = DxgkDdiSetVidPnSourceVisibility;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiCommitVidPn = DxgkDdiCommitVidPn;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiUpdateActiveVidPnPresentPath = DxgkDdiUpdateActiveVidPnPresentPath;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiRecommendMonitorModes = DxgkDdiRecommendMonitorModes;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiRecommendVidPnTopology = DxgkDdiRecommendVidPnTopology;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiGetScanLine = DxgkDdiGetScanLine;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiStopCapture = DxgkDdiStopCapture;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiControlInterrupt = DxgkDdiControlInterrupt;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiCreateOverlay = DxgkDdiCreateOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiDestroyDevice = DxgkDdiDestroyDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiOpenAllocation = DxgkDdiOpenAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiCloseAllocation = DxgkDdiCloseAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiRender = DxgkDdiRender;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiPresent = DxgkDdiPresent;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiUpdateOverlay = DxgkDdiUpdateOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiFlipOverlay = DxgkDdiFlipOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiDestroyOverlay = DxgkDdiDestroyOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiCreateContext = DxgkDdiCreateContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiDestroyContext = DxgkDdiDestroyContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiLinkDevice = NULL; //DxgkDdiLinkDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DriverInitializationData.DxgkDdiSetDisplayPrivateDriverFormat = DxgkDdiSetDisplayPrivateDriverFormat;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync//#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync//# error port to Win7 DDI
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// DriverInitializationData.DxgkDdiRenderKm = DxgkDdiRenderKm;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// DriverInitializationData.DxgkDdiRestartFromTimeout = DxgkDdiRestartFromTimeout;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// DriverInitializationData.DxgkDdiSetVidPnSourceVisibility = DxgkDdiSetVidPnSourceVisibility;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// DriverInitializationData.DxgkDdiUpdateActiveVidPnPresentPath = DxgkDdiUpdateActiveVidPnPresentPath;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// DriverInitializationData.DxgkDdiQueryVidPnHWCapability = DxgkDdiQueryVidPnHWCapability;