Index: /trunk/include/VBox/VBoxVideo.h
===================================================================
--- /trunk/include/VBox/VBoxVideo.h	(revision 32876)
+++ /trunk/include/VBox/VBoxVideo.h	(revision 32877)
@@ -836,5 +836,5 @@
 # define VBVA_VHWA_CMD    9
 #endif /* # ifdef VBOX_WITH_VIDEOHWACCEL */
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
 # define VBVA_VDMA_CTL   10 /* setup G<->H DMA channel info */
 # define VBVA_VDMA_CMD    11 /* G->H DMA command             */
@@ -845,5 +845,5 @@
 # define VBVAHG_EVENT              1
 # define VBVAHG_DISPLAY_CUSTOM     2
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
 # define VBVAHG_SHGSMI_COMPLETION  3
 #endif
@@ -1125,5 +1125,6 @@
     VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL,
     VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP,
-    VBOXVDMACMD_TYPE_DMA_NOP
+    VBOXVDMACMD_TYPE_DMA_NOP,
+    VBOXVDMACMD_TYPE_CHROMIUM_CMD
 } VBOXVDMACMD_TYPE;
 
@@ -1131,5 +1132,5 @@
 #endif
 
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
 # pragma pack(1)
 
@@ -1232,12 +1233,10 @@
 typedef struct VBOXVDMACBUF_DR
 {
-    uint32_t fFlags;
-    uint32_t cbBuf;
-    uint32_t u32FenceId;
+    uint32_t fFlags : 16;
+    uint32_t cbBuf  : 16;
     /* RT_SUCCESS()     - on success
      * VERR_INTERRUPTED - on preemption
      * VERR_xxx         - on error */
     int32_t  rc;
-    uint64_t u64GuestContext;
     union
     {
@@ -1245,4 +1244,5 @@
         VBOXVIDEOOFFSET offVramBuf;
     } Location;
+    uint64_t aGuestData[6];
 } VBOXVDMACBUF_DR, *PVBOXVDMACBUF_DR;
 
@@ -1304,6 +1304,20 @@
 } VBOXVDMACMD_DMA_BPB_FILL, *PVBOXVDMACMD_DMA_BPB_FILL;
 
+typedef struct VBOXVDMACMD_CHROMIUM_BUFFER
+{
+    VBOXVIDEOOFFSET offBuffer;
+    uint32_t cbBuffer;
+    uint32_t u32GuesData;
+    uint64_t u64GuesData;
+} VBOXVDMACMD_CHROMIUM_BUFFER, *PVBOXVDMACMD_CHROMIUM_BUFFER;
+
+typedef struct VBOXVDMACMD_CHROMIUM_CMD
+{
+    /* the number of buffers is specified in the VBOXVDMACMD::u32CmdSpecific*/
+    VBOXVDMACMD_CHROMIUM_BUFFER aBuffers[1];
+} VBOXVDMACMD_CHROMIUM_CMD, *PVBOXVDMACMD_CHROMIUM_CMD;
+
 # pragma pack()
-#endif /* #ifdef VBOXVDMA */
+#endif /* #ifdef VBOX_WITH_VDMA */
 
 #ifdef VBOXVDMA_WITH_VBVA
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Display/Makefile.kmk
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Display/Makefile.kmk	(revision 32876)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Display/Makefile.kmk	(revision 32877)
@@ -76,5 +76,5 @@
  endif
 VBoxDispD3D_TEMPLATE = VBOXGUESTR3DLL
-VBoxDispD3D_DEFS     = UNICODE _UNICODE VBOX_WITH_WDDM VBOXVDMA VBOXWDDMDISP
+VBoxDispD3D_DEFS     = UNICODE _UNICODE VBOX_WITH_WDDM VBOXWDDMDISP
 # VBoxDispD3D_DEFS    += VBOXDISPMP_TEST
 ifdef VBOXWDDM_WITH_VBVA
@@ -94,4 +94,5 @@
     wddm/VBoxDispMp.cpp \
     wddm/VBoxScreen.cpp \
+    wddm/VBoxUhgsmiDisp.cpp \
     wddm/VBoxDispMpTst.cpp \
 	wddm/VBoxDispD3D.def \
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp	(revision 32876)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp	(revision 32877)
@@ -5511,11 +5511,12 @@
         --pData->cPatchLocationList;
         ++pData->cAllocations;
+
+        ++pData->pAllocationList;
+        ++pData->pPatchLocationList;
+        pData->pvCommandBuffer = (VOID*)(((uint8_t*)pData->pvCommandBuffer) + 4);
+
     }
     else
         hr = S_FALSE;
-
-    ++pData->pAllocationList;
-    ++pData->pPatchLocationList;
-    pData->pvCommandBuffer = (VOID*)(((uint8_t*)pData->pvCommandBuffer) + 4);
 
     return hr;
@@ -5538,4 +5539,12 @@
             NscAdd.cPatchLocationList = pDevice->DefaultContext.ContextInfo.PatchLocationListSize;
             NscAdd.cAllocations = 0;
+            Assert(NscAdd.cbCommandBuffer >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR));
+            if (NscAdd.cbCommandBuffer < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
+                return E_FAIL;
+
+            PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pHdr = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)NscAdd.pvCommandBuffer;
+            pHdr->enmCmd = VBOXVDMACMD_TYPE_DMA_NOP;
+            NscAdd.pvCommandBuffer = (VOID*)(((uint8_t*)NscAdd.pvCommandBuffer) + sizeof (*pHdr));
+            NscAdd.cbCommandBuffer -= sizeof (*pHdr);
             bReinitRenderData = FALSE;
         }
@@ -5574,7 +5583,7 @@
         RenderData.NumPatchLocations = pDevice->DefaultContext.ContextInfo.PatchLocationListSize - NscAdd.cPatchLocationList;
         Assert(RenderData.NumPatchLocations == NscAdd.cAllocations);
-        RenderData.NewCommandBufferSize = sizeof (VBOXVDMACMD) + 4 * (100);
-        RenderData.NewAllocationListSize = 100;
-        RenderData.NewPatchLocationListSize = 100;
+//        RenderData.NewCommandBufferSize = sizeof (VBOXVDMACMD) + 4 * (100);
+//        RenderData.NewAllocationListSize = 100;
+//        RenderData.NewPatchLocationListSize = 100;
         RenderData.hContext = pDevice->DefaultContext.ContextInfo.hContext;
 
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiDisp.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiDisp.cpp	(revision 32877)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiDisp.cpp	(revision 32877)
@@ -0,0 +1,309 @@
+/** @file
+ *
+ * VBoxVideo Display D3D User mode dll
+ *
+ * Copyright (C) 2010 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+#include "VBoxUhgsmiDisp.h"
+
+#include <iprt/mem.h>
+#include <iprt/err.h>
+
+typedef struct VBOXUHGSMI_BUFFER_PRIVATE_D3D
+{
+    VBOXUHGSMI_BUFFER Base;
+    PVBOXWDDMDISP_DEVICE pDevice;
+    D3DKMT_HANDLE hAllocation;
+    UINT aLockPageIndices[1];
+} VBOXUHGSMI_BUFFER_PRIVATE_D3D, *PVBOXUHGSMI_BUFFER_PRIVATE_D3D;
+
+#define VBOXUHGSMID3D_GET_PRIVATE(_p, _t) ((_t*)(((uint8_t*)_p) - RT_OFFSETOF(_t, Base)))
+#define VBOXUHGSMID3D_GET(_p) VBOXUHGSMID3D_GET_PRIVATE(_p, VBOXUHGSMI_PRIVATE_D3D)
+#define VBOXUHGSMID3D_GET_BUFFER(_p) VBOXUHGSMID3D_GET_PRIVATE(_p, VBOXUHGSMI_BUFFER_PRIVATE_D3D)
+
+DECLCALLBACK(int) vboxUhgsmiD3DBufferDestroy(PVBOXUHGSMI_BUFFER pBuf)
+{
+    PVBOXUHGSMI_BUFFER_PRIVATE_D3D pBuffer = VBOXUHGSMID3D_GET_BUFFER(pBuf);
+    D3DDDICB_DEALLOCATE DdiDealloc;
+    DdiDealloc.hResource = 0;
+    DdiDealloc.NumAllocations = 1;
+    DdiDealloc.HandleList = &pBuffer->hAllocation;
+    HRESULT hr = pBuffer->pDevice->RtCallbacks.pfnDeallocateCb(pBuffer->pDevice->hDevice, &DdiDealloc);
+    Assert(hr == S_OK);
+    if (hr == S_OK)
+    {
+        if (pBuffer->Base.bSynchCreated)
+        {
+            CloseHandle(pBuffer->Base.hSynch);
+        }
+        RTMemFree(pBuffer);
+        return VINF_SUCCESS;
+    }
+    return VERR_GENERAL_FAILURE;
+}
+
+DECLCALLBACK(int) vboxUhgsmiD3DBufferLock(PVBOXUHGSMI_BUFFER pBuf, uint32_t offLock, uint32_t cbLock, VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags, void**pvLock)
+{
+    PVBOXUHGSMI_BUFFER_PRIVATE_D3D pBuffer = VBOXUHGSMID3D_GET_BUFFER(pBuf);
+    if (!cbLock)
+    {
+        Assert(0);
+        return VERR_INVALID_PARAMETER;
+    }
+    if (offLock + cbLock > pBuf->cbBuffer)
+    {
+        Assert(0);
+        return VERR_INVALID_PARAMETER;
+    }
+    uint32_t iFirstPage = offLock >> 0x1000;
+    uint32_t iAfterLastPage = (cbLock + 0xfff) >> 0x1000;
+    uint32_t cPages = iAfterLastPage - iFirstPage;
+    uint32_t cBufPages = pBuf->cbBuffer >> 0x1000;
+    Assert(cPages <= (cBufPages));
+    D3DDDICB_LOCK DdiLock;
+    DdiLock.hAllocation = pBuffer->hAllocation;
+    DdiLock.PrivateDriverData = 0;
+    if (cPages == cBufPages)
+    {
+        DdiLock.NumPages = 0;
+        DdiLock.pPages = NULL;
+        DdiLock.Flags.Value = 0;
+        DdiLock.Flags.LockEntire = 1;
+    }
+    else
+    {
+        DdiLock.NumPages = cPages;
+        DdiLock.pPages = pBuffer->aLockPageIndices;
+        DdiLock.Flags.Value = 0;
+        for (UINT i = 0, j = iFirstPage; i < cPages; ++i, ++j)
+        {
+            pBuffer->aLockPageIndices[i] = j;
+        }
+    }
+    DdiLock.pData = NULL;
+    DdiLock.Flags.ReadOnly = fFlags.bReadOnly;
+    DdiLock.Flags.WriteOnly = fFlags.bWriteOnly;
+    DdiLock.Flags.DonotWait = fFlags.bDonotWait;
+    DdiLock.Flags.Discard = fFlags.bDiscard;
+
+    HRESULT hr = pBuffer->pDevice->RtCallbacks.pfnLockCb(pBuffer->pDevice->hDevice, &DdiLock);
+    Assert(hr == S_OK);
+    if (hr == S_OK)
+    {
+        *pvLock = (void*)(((uint8_t*)DdiLock.pPages) + (offLock & 0xfff));
+        return VINF_SUCCESS;
+    }
+    return VERR_GENERAL_FAILURE;
+}
+
+DECLCALLBACK(int) vboxUhgsmiD3DBufferUnlock(PVBOXUHGSMI_BUFFER pBuf)
+{
+    PVBOXUHGSMI_BUFFER_PRIVATE_D3D pBuffer = VBOXUHGSMID3D_GET_BUFFER(pBuf);
+    D3DDDICB_UNLOCK DdiUnlock;
+    DdiUnlock.NumAllocations = 1;
+    DdiUnlock.phAllocations = &pBuffer->hAllocation;
+    HRESULT hr = pBuffer->pDevice->RtCallbacks.pfnUnlockCb(pBuffer->pDevice->hDevice, &DdiUnlock);
+    Assert(hr == S_OK);
+    if (hr == S_OK)
+        return VINF_SUCCESS;
+    return VERR_GENERAL_FAILURE;
+}
+
+DECLCALLBACK(int) vboxUhgsmiD3DBufferCreate(PVBOXUHGSMI pHgsmi, uint32_t cbBuf,
+        VBOXUHGSMI_SYNCHOBJECT_TYPE enmSynchType, HVBOXUHGSMI_SYNCHOBJECT hSynch,
+        PVBOXUHGSMI_BUFFER* ppBuf)
+{
+    bool bSynchCreated = false;
+    if (!cbBuf)
+        return VERR_INVALID_PARAMETER;
+
+    switch (enmSynchType)
+    {
+        case VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT:
+            if (!hSynch)
+            {
+                hSynch = CreateEvent(
+                  NULL, /* LPSECURITY_ATTRIBUTES lpEventAttributes */
+                  FALSE, /* BOOL bManualReset */
+                  FALSE, /* BOOL bInitialState */
+                  NULL /* LPCTSTR lpName */
+                );
+                Assert(hSynch);
+                if (!hSynch)
+                {
+                    DWORD winEr = GetLastError();
+                    /* todo: translate winer */
+                    return VERR_GENERAL_FAILURE;
+                }
+                bSynchCreated = true;
+            }
+            break;
+        case VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE:
+            if (!hSynch)
+            {
+                hSynch = CreateSemaphore(
+                  NULL, /* LPSECURITY_ATTRIBUTES lpSemaphoreAttributes */
+                  0, /* LONG lInitialCount */
+                  ~0L, /* LONG lMaximumCount */
+                  NULL /* LPCTSTR lpName */
+                );
+                Assert(hSynch);
+                if (!hSynch)
+                {
+                    DWORD winEr = GetLastError();
+                    /* todo: translate winer */
+                    return VERR_GENERAL_FAILURE;
+                }
+                bSynchCreated = true;
+            }
+            break;
+        default:
+            Assert(0);
+            return VERR_INVALID_PARAMETER;
+    }
+
+    cbBuf = VBOXWDDM_ROUNDBOUND(cbBuf, 0x1000);
+    Assert(cbBuf);
+    uint32_t cPages = cbBuf >> 0x1000;
+    Assert(cPages);
+
+    int rc;
+    PVBOXUHGSMI_PRIVATE_D3D pPrivate = VBOXUHGSMID3D_GET(pHgsmi);
+    PVBOXUHGSMI_BUFFER_PRIVATE_D3D pBuf = (PVBOXUHGSMI_BUFFER_PRIVATE_D3D)RTMemAllocZ(RT_OFFSETOF(VBOXUHGSMI_BUFFER_PRIVATE_D3D, aLockPageIndices));
+    Assert(pBuf);
+    if (pBuf)
+    {
+        struct
+        {
+            D3DDDICB_ALLOCATE DdiAlloc;
+            D3DDDI_ALLOCATIONINFO DdiAllocInfo;
+            VBOXWDDM_ALLOCINFO AllocInfo;
+        } Buf;
+        memset(&Buf, 0, sizeof (Buf));
+        Buf.DdiAlloc.hResource = NULL;
+        Buf.DdiAlloc.hKMResource = NULL;
+        Buf.DdiAlloc.NumAllocations = 1;
+        Buf.DdiAlloc.pAllocationInfo = &Buf.DdiAllocInfo;
+        Buf.DdiAllocInfo.pPrivateDriverData = &Buf.AllocInfo;
+        Buf.DdiAllocInfo.PrivateDriverDataSize = sizeof (Buf.AllocInfo);
+        Buf.AllocInfo.enmType = VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER;
+        Buf.AllocInfo.cbBuffer = cbBuf;
+        Buf.AllocInfo.hSynch = hSynch;
+        Buf.AllocInfo.enmSynchType = enmSynchType;
+
+        HRESULT hr = pPrivate->pDevice->RtCallbacks.pfnAllocateCb(pPrivate->pDevice->hDevice, &Buf.DdiAlloc);
+        Assert(hr == S_OK);
+        if (hr == S_OK)
+        {
+            Assert(Buf.DdiAllocInfo.hAllocation);
+            pBuf->Base.pfnLock = vboxUhgsmiD3DBufferLock;
+            pBuf->Base.pfnUnlock = vboxUhgsmiD3DBufferUnlock;
+//            pBuf->Base.pfnAdjustValidDataRange = vboxUhgsmiD3DBufferAdjustValidDataRange;
+            pBuf->Base.pfnDestroy = vboxUhgsmiD3DBufferDestroy;
+
+            pBuf->Base.hSynch = hSynch;
+            pBuf->Base.enmSynchType =enmSynchType;
+            pBuf->Base.cbBuffer = cbBuf;
+            pBuf->Base.bSynchCreated = bSynchCreated;
+
+            pBuf->pDevice = pPrivate->pDevice;
+            pBuf->hAllocation = Buf.DdiAllocInfo.hAllocation;
+            return VINF_SUCCESS;
+        }
+
+        RTMemFree(pBuf);
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    if (bSynchCreated)
+        CloseHandle(hSynch);
+
+    return rc;
+}
+
+DECLCALLBACK(int) vboxUhgsmiD3DBufferSubmitAsynch(PVBOXUHGSMI pHgsmi, PVBOXUHGSMI_BUFFER_SUBMIT aBuffers, uint32_t cBuffers)
+{
+    PVBOXUHGSMI_PRIVATE_D3D pHg = VBOXUHGSMID3D_GET(pHgsmi);
+    PVBOXWDDMDISP_DEVICE pDevice = pHg->pDevice;
+    const uint32_t cbDmaCmd = RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, aBufInfos[cBuffers]);
+    if (pDevice->DefaultContext.ContextInfo.CommandBufferSize < cbDmaCmd)
+    {
+        Assert(0);
+        return VERR_GENERAL_FAILURE;
+    }
+    if (pDevice->DefaultContext.ContextInfo.AllocationListSize < cBuffers)
+    {
+        Assert(0);
+        return VERR_GENERAL_FAILURE;
+    }
+
+    PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD pHdr = (PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD)pDevice->DefaultContext.ContextInfo.pCommandBuffer;
+    pHdr->Base.enmCmd = VBOXVDMACMD_TYPE_CHROMIUM_CMD;
+    pHdr->Base.u32CmdReserved = cBuffers;
+
+    D3DDDI_ALLOCATIONLIST* pAllocationList = pDevice->DefaultContext.ContextInfo.pAllocationList;
+    PVBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO pBufSubmInfo = pHdr->aBufInfos;
+
+    for (uint32_t i = 0; i < cBuffers; ++i)
+    {
+        PVBOXUHGSMI_BUFFER_SUBMIT pBufInfo = &aBuffers[i];
+        PVBOXUHGSMI_BUFFER_PRIVATE_D3D pBuffer = VBOXUHGSMID3D_GET_BUFFER(pBufInfo->pBuf);
+
+        memset(pAllocationList, 0, sizeof (D3DDDI_ALLOCATIONLIST));
+        pAllocationList->hAllocation = pBuffer->hAllocation;
+        pAllocationList->WriteOperation = !pBufInfo->fFlags.bHostReadOnly;
+        pAllocationList->DoNotRetireInstance = pBufInfo->fFlags.bDoNotRetire;
+        pBufSubmInfo->fSubFlags = pBufInfo->fFlags;
+        pBufSubmInfo->offData = pBufInfo->offData;
+        pBufSubmInfo->cbData = pBufInfo->cbData;
+
+        ++pAllocationList;
+        ++pBufSubmInfo;
+    }
+
+
+    D3DDDICB_RENDER DdiRender = {0};
+    DdiRender.CommandLength = cbDmaCmd;
+    Assert(DdiRender.CommandLength);
+    Assert(DdiRender.CommandLength < UINT32_MAX/2);
+    DdiRender.CommandOffset = 0;
+    DdiRender.NumAllocations = cBuffers;
+    DdiRender.NumPatchLocations = 0;
+//    DdiRender.NewCommandBufferSize = sizeof (VBOXVDMACMD) + 4 * (100);
+//    DdiRender.NewAllocationListSize = 100;
+//    DdiRender.NewPatchLocationListSize = 100;
+    DdiRender.hContext = pDevice->DefaultContext.ContextInfo.hContext;
+
+    HRESULT hr = pDevice->RtCallbacks.pfnRenderCb(pDevice->hDevice, &DdiRender);
+    Assert(hr == S_OK);
+    if (hr == S_OK)
+    {
+        pDevice->DefaultContext.ContextInfo.CommandBufferSize = DdiRender.NewCommandBufferSize;
+        pDevice->DefaultContext.ContextInfo.pCommandBuffer = DdiRender.pNewCommandBuffer;
+        pDevice->DefaultContext.ContextInfo.AllocationListSize = DdiRender.NewAllocationListSize;
+        pDevice->DefaultContext.ContextInfo.pAllocationList = DdiRender.pNewAllocationList;
+        pDevice->DefaultContext.ContextInfo.PatchLocationListSize = DdiRender.NewPatchLocationListSize;
+        pDevice->DefaultContext.ContextInfo.pPatchLocationList = DdiRender.pNewPatchLocationList;
+
+        return VINF_SUCCESS;
+    }
+
+    return VERR_GENERAL_FAILURE;
+}
+
+HRESULT vboxUhgsmiD3DInit(PVBOXUHGSMI_PRIVATE_D3D pHgsmi, PVBOXWDDMDISP_DEVICE pDevice)
+{
+    pHgsmi->Base.pfnBufferCreate = vboxUhgsmiD3DBufferCreate;
+    pHgsmi->Base.pfnBufferSubmitAsynch = vboxUhgsmiD3DBufferSubmitAsynch;
+    pHgsmi->pDevice = pDevice;
+    return S_OK;
+}
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiDisp.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiDisp.h	(revision 32877)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiDisp.h	(revision 32877)
@@ -0,0 +1,28 @@
+/** @file
+ *
+ * VBoxVideo Display D3D User mode dll
+ *
+ * Copyright (C) 2010 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+#ifndef ___VBoxUhgsmiDisp_h__
+#define ___VBoxUhgsmiDisp_h__
+
+#include "../../Miniport/wddm/VBoxUhgsmi.h"
+#include "VBoxDispD3DCmn.h"
+
+typedef struct VBOXUHGSMI_PRIVATE_D3D
+{
+    VBOXUHGSMI Base;
+    PVBOXWDDMDISP_DEVICE pDevice;
+} VBOXUHGSMI_PRIVATE_D3D, *PVBOXUHGSMI_PRIVATE_D3D;
+
+HRESULT vboxUhgsmiD3DInit(PVBOXUHGSMI_PRIVATE_D3D pHgsmi, PVBOXWDDMDISP_DEVICE pDevice);
+#endif /* #ifndef ___VBoxUhgsmiDisp_h__ */
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/Makefile.kmk
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/Makefile.kmk	(revision 32876)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/Makefile.kmk	(revision 32877)
@@ -90,4 +90,7 @@
   endif
  endif
+ ifdef VBOXVDMA_WITH_VDMA
+  VBoxVideoWddm_DEFS     += VBOXVDMA_WITH_VDMA 
+ endif
  ifdef DEBUG_misha
   VBoxVideoWddm_DEFS       += LOG_ENABLED
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp	(revision 32876)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp	(revision 32877)
@@ -959,5 +959,5 @@
         ULONG ulSize;
         ULONG offset;
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
         ulSize = ulAvailable / 2;
         if (ulSize > VBOXWDDM_C_VDMA_BUFFER_SIZE)
@@ -973,5 +973,5 @@
 #endif
         rc = vboxVdmaCreate (PrimaryExtension, &PrimaryExtension->u.primary.Vdma
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
                 , offset, ulSize
 #endif
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxUhgsmi.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxUhgsmi.h	(revision 32877)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxUhgsmi.h	(revision 32877)
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2010 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+#ifndef ___VBoxUhgsmi_h__
+#define ___VBoxUhgsmi_h__
+
+#include <iprt/cdefs.h>
+#include <iprt/types.h>
+
+typedef struct VBOXUHGSMI *PVBOXUHGSMI;
+
+typedef struct VBOXUHGSMI_BUFFER *PVBOXUHGSMI_BUFFER;
+typedef void* HVBOXUHGSMI_SYNCHOBJECT;
+
+typedef enum
+{
+    VBOXUHGSMI_SYNCHOBJECT_TYPE_UNKNOWN = 0,
+    VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT,
+    VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE
+} VBOXUHGSMI_SYNCHOBJECT_TYPE;
+
+typedef struct VBOXUHGSMI_BUFFER_LOCK_FLAGS
+{
+    union
+    {
+        struct
+        {
+            uint32_t bReadOnly  : 1;
+            uint32_t bWriteOnly : 1;
+            uint32_t bDonotWait : 1;
+            uint32_t bDiscard   : 1;
+            uint32_t Reserved   : 28;
+        };
+        uint32_t Value;
+    };
+} VBOXUHGSMI_BUFFER_LOCK_FLAGS;
+
+typedef struct VBOXUHGSMI_BUFFER_SUBMIT_FLAGS
+{
+    union
+    {
+        struct
+        {
+            uint32_t bHostReadOnly          : 1;
+            uint32_t bHostWriteOnly         : 1;
+            uint32_t bDoNotRetire           : 1; /* <- the buffer will be used in a subsequent command */
+            uint32_t bDoNotSignalCompletion : 1; /* <- do not signal notification object on completion for this alloc */
+            uint32_t Reserved               : 28;
+        };
+        uint32_t Value;
+    };
+} VBOXUHGSMI_BUFFER_SUBMIT_FLAGS, *PVBOXUHGSMI_BUFFER_SUBMIT_FLAGS;
+
+/* the caller can specify NULL as a hSynch and specify a valid enmSynchType to make UHGSMI create a proper object itself,
+ *  */
+typedef DECLCALLBACK(int) FNVBOXUHGSMI_BUFFER_CREATE(PVBOXUHGSMI pHgsmi, uint32_t cbBuf,
+        VBOXUHGSMI_SYNCHOBJECT_TYPE enmSynchType, HVBOXUHGSMI_SYNCHOBJECT hSynch,
+        PVBOXUHGSMI_BUFFER* ppBuf);
+typedef FNVBOXUHGSMI_BUFFER_CREATE *PFNVBOXUHGSMI_BUFFER_CREATE;
+
+typedef struct VBOXUHGSMI_BUFFER_SUBMIT
+{
+    PVBOXUHGSMI_BUFFER pBuf;
+    uint32_t offData;
+    uint32_t cbData;
+    VBOXUHGSMI_BUFFER_SUBMIT_FLAGS fFlags;
+} VBOXUHGSMI_BUFFER_SUBMIT, *PVBOXUHGSMI_BUFFER_SUBMIT;
+
+typedef DECLCALLBACK(int) FNVBOXUHGSMI_BUFFER_SUBMIT_ASYNCH(PVBOXUHGSMI pHgsmi, PVBOXUHGSMI_BUFFER_SUBMIT aBuffers, uint32_t cBuffers);
+typedef FNVBOXUHGSMI_BUFFER_SUBMIT_ASYNCH *PFNVBOXUHGSMI_BUFFER_SUBMIT_ASYNCH;
+
+typedef DECLCALLBACK(int) FNVBOXUHGSMI_BUFFER_DESTROY(PVBOXUHGSMI_BUFFER pBuf);
+typedef FNVBOXUHGSMI_BUFFER_DESTROY *PFNVBOXUHGSMI_BUFFER_DESTROY;
+
+typedef DECLCALLBACK(int) FNVBOXUHGSMI_BUFFER_LOCK(PVBOXUHGSMI_BUFFER pBuf, uint32_t offLock, uint32_t cbLock, VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags, void**pvLock);
+typedef FNVBOXUHGSMI_BUFFER_LOCK *PFNVBOXUHGSMI_BUFFER_LOCK;
+
+typedef DECLCALLBACK(int) FNVBOXUHGSMI_BUFFER_UNLOCK(PVBOXUHGSMI_BUFFER pBuf);
+typedef FNVBOXUHGSMI_BUFFER_UNLOCK *PFNVBOXUHGSMI_BUFFER_UNLOCK;
+
+typedef struct VBOXUHGSMI
+{
+    PFNVBOXUHGSMI_BUFFER_CREATE pfnBufferCreate;
+    PFNVBOXUHGSMI_BUFFER_SUBMIT_ASYNCH pfnBufferSubmitAsynch;
+} VBOXUHGSMI, *PVBOXUHGSMI;
+
+typedef struct VBOXUHGSMI_BUFFER
+{
+    PFNVBOXUHGSMI_BUFFER_LOCK pfnLock;
+    PFNVBOXUHGSMI_BUFFER_UNLOCK pfnUnlock;
+    PFNVBOXUHGSMI_BUFFER_DESTROY pfnDestroy;
+
+    /* r/o data added for ease of access and simplicity
+     * modifying it leads to unpredictable behavior */
+    HVBOXUHGSMI_SYNCHOBJECT hSynch;
+    VBOXUHGSMI_SYNCHOBJECT_TYPE enmSynchType;
+    uint32_t cbBuffer;
+    bool bSynchCreated;
+} VBOXUHGSMI_BUFFER, *PVBOXUHGSMI_BUFFER;
+
+#endif /* #ifndef ___VBoxUhgsmi_h__ */
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoIf.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoIf.h	(revision 32876)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoIf.h	(revision 32877)
@@ -24,4 +24,5 @@
 #include <VBox/VBoxVideo.h>
 #include "../../../include/VBoxDisplay.h"
+#include "VBoxUhgsmi.h"
 
 #include <iprt/assert.h>
@@ -29,5 +30,5 @@
 
 /* One would increase this whenever definitions in this file are changed */
-#define VBOXVIDEOIF_VERSION 5
+#define VBOXVIDEOIF_VERSION 6
 
 /* create allocation func */
@@ -42,4 +43,5 @@
     /* custom allocation types requested from user-mode d3d module will go here */
     , VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC
+    , VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER
 } VBOXWDDM_ALLOC_TYPE;
 
@@ -69,7 +71,20 @@
 {
     VBOXWDDM_ALLOC_TYPE enmType;
-    D3DDDI_RESOURCEFLAGS fFlags;
-    HANDLE hSharedHandle;
-    VBOXWDDM_SURFACE_DESC SurfDesc;
+    union
+    {
+        struct
+        {
+            D3DDDI_RESOURCEFLAGS fFlags;
+            HANDLE hSharedHandle;
+            VBOXWDDM_SURFACE_DESC SurfDesc;
+        };
+
+        struct
+        {
+            uint32_t cbBuffer;
+            HANDLE hSynch;
+            VBOXUHGSMI_SYNCHOBJECT_TYPE enmSynchType;
+        };
+    };
 } VBOXWDDM_ALLOCINFO, *PVBOXWDDM_ALLOCINFO;
 
@@ -100,4 +115,40 @@
 //    VBOXWDDM_ALLOCINFO aAllocInfos[1];
 } VBOXWDDM_RCINFO, *PVBOXWDDM_RCINFO;
+
+typedef struct VBOXWDDM_DMA_PRIVATEDATA_FLAFS
+{
+    union
+    {
+        struct
+        {
+            UINT bCmdInDmaBuffer : 1;
+            UINT bReserved : 31;
+        };
+        uint32_t Value;
+    };
+} VBOXWDDM_DMA_PRIVATEDATA_FLAFS, *PVBOXWDDM_DMA_PRIVATEDATA_FLAFS;
+
+typedef struct VBOXWDDM_DMA_PRIVATEDATA_BASEHDR
+{
+    VBOXVDMACMD_TYPE enmCmd;
+    union
+    {
+        VBOXWDDM_DMA_PRIVATEDATA_FLAFS fFlags;
+        uint32_t u32CmdReserved;
+    };
+} VBOXWDDM_DMA_PRIVATEDATA_BASEHDR, *PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR;
+
+typedef struct VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO
+{
+    VBOXUHGSMI_BUFFER_SUBMIT_FLAGS fSubFlags;
+    uint32_t offData;
+    uint32_t cbData;
+} VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO, *PVBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO;
+
+typedef struct VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD
+{
+    VBOXWDDM_DMA_PRIVATEDATA_BASEHDR Base;
+    VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO aBufInfos[1];
+} VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, *PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD;
 
 #define VBOXVHWA_F_ENABLED  0x00000001
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.cpp	(revision 32876)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.cpp	(revision 32877)
@@ -717,4 +717,5 @@
     PVBOXWDDM_CONTEXT pContext = pDmaCmd->DdiCmd.pContext;
     NTSTATUS Status = STATUS_SUCCESS;
+    DXGK_INTERRUPT_TYPE enmComplType = DXGK_INTERRUPT_DMA_COMPLETED;
     switch (pDmaCmd->enmCmd)
     {
@@ -869,5 +870,5 @@
     }
 
-    Status = vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, &pDmaCmd->DdiCmd);
+    Status = vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, &pDmaCmd->DdiCmd, enmComplType);
     Assert(Status == STATUS_SUCCESS);
 
@@ -974,5 +975,5 @@
 /* end */
 
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
 /*
  * This is currently used by VDMA. It is invisible for Vdma API clients since
@@ -1063,5 +1064,5 @@
 /* create a DMACommand buffer */
 int vboxVdmaCreate(PDEVICE_EXTENSION pDevExt, VBOXVDMAINFO *pInfo
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
         , ULONG offBuffer, ULONG cbBuffer
 #endif
@@ -1071,5 +1072,5 @@
     pInfo->fEnabled           = FALSE;
 
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     Assert((offBuffer & 0xfff) == 0);
     Assert((cbBuffer & 0xfff) == 0);
@@ -1110,5 +1111,5 @@
             rc = VERR_GENERAL_FAILURE;
         }
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
         else
             drprintf((__FUNCTION__": HGSMIHeapSetup failed rc = 0x%x\n", rc));
@@ -1132,5 +1133,5 @@
     /* ensure nothing else is submitted */
     pInfo->fEnabled        = FALSE;
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     int rc = vboxVdmaInformHost (pDevExt, pInfo, VBOXVDMA_CTL_TYPE_DISABLE);
     AssertRC(rc);
@@ -1148,5 +1149,5 @@
     if (pInfo->fEnabled)
         return VINF_ALREADY_INITIALIZED;
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     int rc = vboxVdmaInformHost (pDevExt, pInfo, VBOXVDMA_CTL_TYPE_ENABLE);
     Assert(RT_SUCCESS(rc));
@@ -1160,5 +1161,5 @@
 }
 
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
 int vboxVdmaFlush (PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo)
 {
@@ -1186,5 +1187,5 @@
         if (pInfo->fEnabled)
             rc = vboxVdmaDisable (pDevExt, pInfo);
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
         VBoxUnmapAdapterMemory (pDevExt, (void**)&pInfo->CmdHeap.area.pu8Base, pInfo->CmdHeap.area.cbArea);
 #endif
@@ -1195,5 +1196,5 @@
 }
 
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
 void vboxVdmaCBufDrFree (PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr)
 {
@@ -1227,59 +1228,28 @@
     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pvContext;
     PVBOXVDMAINFO pVdma = &pDevExt->u.primary.Vdma;
-    DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
     PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)pvCmd;
 
-    memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
-
-    PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pDr->u64GuestContext;
+    DXGK_INTERRUPT_TYPE enmComplType;
 
     if (RT_SUCCESS(pDr->rc))
     {
-        notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
-        notify.DmaCompleted.SubmissionFenceId = pDr->u32FenceId;
-        if (pContext)
-        {
-            notify.DmaCompleted.NodeOrdinal = pContext->NodeOrdinal;
-            notify.DmaCompleted.EngineOrdinal = 0;
-            pContext->uLastCompletedCmdFenceId = pDr->u32FenceId;
-        }
-        else
-            pVdma->uLastCompletedPagingBufferCmdFenceId = pDr->u32FenceId;
-        pDevExt->bSetNotifyDxDpc = TRUE;
+        enmComplType = DXGK_INTERRUPT_DMA_COMPLETED;
     }
     else if (pDr->rc == VERR_INTERRUPTED)
     {
-        notify.InterruptType = DXGK_INTERRUPT_DMA_PREEMPTED;
-        notify.DmaPreempted.PreemptionFenceId = pDr->u32FenceId;
-        if (pContext)
-        {
-            notify.DmaPreempted.LastCompletedFenceId = pContext->uLastCompletedCmdFenceId;
-            notify.DmaPreempted.NodeOrdinal = pContext->NodeOrdinal;
-            notify.DmaPreempted.EngineOrdinal = 0;
-        }
-        else
-            notify.DmaPreempted.LastCompletedFenceId = pVdma->uLastCompletedPagingBufferCmdFenceId;
-
-        pDevExt->bSetNotifyDxDpc = TRUE;
+        Assert(0);
+        enmComplType = DXGK_INTERRUPT_DMA_PREEMPTED;
     }
     else
     {
-        AssertBreakpoint();
-        notify.InterruptType = DXGK_INTERRUPT_DMA_FAULTED;
-        notify.DmaFaulted.FaultedFenceId = pDr->u32FenceId;
-        notify.DmaFaulted.Status = STATUS_UNSUCCESSFUL; /* @todo: better status ? */
-        if (pContext)
-        {
-            notify.DmaFaulted.NodeOrdinal = pContext->NodeOrdinal;
-            notify.DmaFaulted.EngineOrdinal = 0;
-        }
-        pDevExt->bSetNotifyDxDpc = TRUE;
-    }
-
-    pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
-
-    /* inform SHGSMI we want to be called at DPC later */
-    *ppfnCompletion = vboxVdmaCBufDrCompletion;
-    *ppvCompletion = pvContext;
+        Assert(0);
+        enmComplType = DXGK_INTERRUPT_DMA_FAULTED;
+    }
+
+    vboxVdmaDdiCmdCompletedIrq(pDevExt, &pDevExt->DdiCmdQueue, VBOXVDMADDI_CMD_FROM_BUF_DR(pDr), enmComplType);
+
+    /* inform SHGSMI we DO NOT want to be called at DPC later */
+    *ppfnCompletion = NULL;
+//    *ppvCompletion = pvContext;
 }
 
@@ -1330,17 +1300,57 @@
 }
 
-static VOID vboxVdmaDdiCmdNotifyCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
+static VOID vboxVdmaDdiCmdNotifyCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd, DXGK_INTERRUPT_TYPE enmComplType)
 {
     DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
     memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
-    notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
-    notify.DmaCompleted.SubmissionFenceId = pCmd->u32FenceId;
-    notify.DmaCompleted.NodeOrdinal = pCmd->pContext->NodeOrdinal;
-    notify.DmaCompleted.EngineOrdinal = 0;
-    pCmd->pContext->uLastCompletedCmdFenceId = pCmd->u32FenceId;
+    switch (enmComplType)
+    {
+        case DXGK_INTERRUPT_DMA_COMPLETED:
+            notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
+            notify.DmaCompleted.SubmissionFenceId = pCmd->u32FenceId;
+            if (pCmd->pContext)
+            {
+                notify.DmaCompleted.NodeOrdinal = pCmd->pContext->NodeOrdinal;
+                pCmd->pContext->uLastCompletedCmdFenceId = pCmd->u32FenceId;
+            }
+            else
+            {
+                pDevExt->u.primary.Vdma.uLastCompletedPagingBufferCmdFenceId = pCmd->u32FenceId;
+            }
+
+            InsertTailList(&pQueue->DpcCmdQueue, &pCmd->QueueEntry);
+
+            break;
+        case DXGK_INTERRUPT_DMA_PREEMPTED:
+            Assert(0);
+            notify.InterruptType = DXGK_INTERRUPT_DMA_PREEMPTED;
+            notify.DmaPreempted.PreemptionFenceId = pCmd->u32FenceId;
+            if (pCmd->pContext)
+            {
+                notify.DmaPreempted.LastCompletedFenceId = pCmd->pContext->uLastCompletedCmdFenceId;
+                notify.DmaPreempted.NodeOrdinal = pCmd->pContext->NodeOrdinal;
+            }
+            else
+            {
+                notify.DmaPreempted.LastCompletedFenceId = pDevExt->u.primary.Vdma.uLastCompletedPagingBufferCmdFenceId;
+            }
+            break;
+
+        case DXGK_INTERRUPT_DMA_FAULTED:
+            Assert(0);
+            notify.InterruptType = DXGK_INTERRUPT_DMA_FAULTED;
+            notify.DmaFaulted.FaultedFenceId = pCmd->u32FenceId;
+            notify.DmaFaulted.Status = STATUS_UNSUCCESSFUL; /* @todo: better status ? */
+            if (pCmd->pContext)
+            {
+                notify.DmaFaulted.NodeOrdinal = pCmd->pContext->NodeOrdinal;
+            }
+            break;
+        default:
+            Assert(0);
+            break;
+    }
 
     pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
-
-    InsertTailList(&pQueue->DpcCmdQueue, &pCmd->QueueEntry);
 }
 
@@ -1364,5 +1374,5 @@
 }
 
-BOOLEAN vboxVdmaDdiCmdCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
+BOOLEAN vboxVdmaDdiCmdCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd, DXGK_INTERRUPT_TYPE enmComplType)
 {
     BOOLEAN bQueued = pCmd->enmState > VBOXVDMADDI_STATE_NOT_QUEUED;
@@ -1390,5 +1400,5 @@
     if (bComplete)
     {
-        vboxVdmaDdiCmdNotifyCompletedIrq(pDevExt, pQueue, pCmd);
+        vboxVdmaDdiCmdNotifyCompletedIrq(pDevExt, pQueue, pCmd, enmComplType);
 
         while (!IsListEmpty(&pQueue->CmdQueue))
@@ -1398,5 +1408,5 @@
             {
                 vboxVdmaDdiCmdDequeueIrq(pQueue, pCmd);
-                vboxVdmaDdiCmdNotifyCompletedIrq(pDevExt, pQueue, pCmd);
+                vboxVdmaDdiCmdNotifyCompletedIrq(pDevExt, pQueue, pCmd, pCmd->enmComplType);
             }
             else
@@ -1407,4 +1417,5 @@
     {
         pCmd->enmState = VBOXVDMADDI_STATE_COMPLETED;
+        pCmd->enmComplType = enmComplType;
     }
 
@@ -1426,4 +1437,5 @@
     PVBOXVDMADDI_CMD_QUEUE pQueue;
     PVBOXVDMADDI_CMD pCmd;
+    DXGK_INTERRUPT_TYPE enmComplType;
 } VBOXVDMADDI_CMD_COMPLETED_CB, *PVBOXVDMADDI_CMD_COMPLETED_CB;
 
@@ -1431,5 +1443,5 @@
 {
     PVBOXVDMADDI_CMD_COMPLETED_CB pdc = (PVBOXVDMADDI_CMD_COMPLETED_CB)Context;
-    BOOLEAN bNeedDps = vboxVdmaDdiCmdCompletedIrq(pdc->pDevExt, pdc->pQueue, pdc->pCmd);
+    BOOLEAN bNeedDps = vboxVdmaDdiCmdCompletedIrq(pdc->pDevExt, pdc->pQueue, pdc->pCmd, pdc->enmComplType);
     pdc->pDevExt->bNotifyDxDpc |= bNeedDps;
 
@@ -1437,5 +1449,5 @@
 }
 
-NTSTATUS vboxVdmaDdiCmdCompleted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
+NTSTATUS vboxVdmaDdiCmdCompleted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd, DXGK_INTERRUPT_TYPE enmComplType)
 {
     VBOXVDMADDI_CMD_COMPLETED_CB context;
@@ -1443,4 +1455,5 @@
     context.pQueue = pQueue;
     context.pCmd = pCmd;
+    context.enmComplType = enmComplType;
     BOOLEAN bNeedDps;
     NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
@@ -1535,5 +1548,5 @@
 }
 
-NTSTATUS vboxVdmaDdiCmdFenceComplete(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, uint32_t u32FenceId)
+NTSTATUS vboxVdmaDdiCmdFenceComplete(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, uint32_t u32FenceId, DXGK_INTERRUPT_TYPE enmComplType)
 {
     if (vboxVdmaDdiCmdCanComplete(&pDevExt->DdiCmdQueue))
@@ -1545,5 +1558,5 @@
     {
         vboxVdmaDdiCmdInit(pCmd, u32FenceId, pContext, vboxVdmaDdiCmdCompletionCbFree, NULL);
-        NTSTATUS Status = vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, pCmd);
+        NTSTATUS Status = vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, pCmd, enmComplType);
         Assert(Status == STATUS_SUCCESS);
         if (Status == STATUS_SUCCESS)
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.h	(revision 32876)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.h	(revision 32877)
@@ -37,4 +37,5 @@
     VBOXVDMADDI_STATE enmState;
     uint32_t u32FenceId;
+    DXGK_INTERRUPT_TYPE enmComplType;
     PVBOXWDDM_CONTEXT pContext;
     PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete;
@@ -50,8 +51,8 @@
 
 VOID vboxVdmaDdiQueueInit(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue);
-BOOLEAN vboxVdmaDdiCmdCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd);
+BOOLEAN vboxVdmaDdiCmdCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd, DXGK_INTERRUPT_TYPE enmComplType);
 VOID vboxVdmaDdiCmdSubmittedIrq(PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd);
 
-NTSTATUS vboxVdmaDdiCmdCompleted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd);
+NTSTATUS vboxVdmaDdiCmdCompleted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd, DXGK_INTERRUPT_TYPE enmComplType);
 NTSTATUS vboxVdmaDdiCmdSubmitted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd);
 
@@ -69,5 +70,5 @@
 }
 
-NTSTATUS vboxVdmaDdiCmdFenceComplete(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, uint32_t u32FenceId);
+NTSTATUS vboxVdmaDdiCmdFenceComplete(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, uint32_t u32FenceId, DXGK_INTERRUPT_TYPE enmComplType);
 
 DECLCALLBACK(VOID) vboxVdmaDdiCmdCompletionCbFree(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext);
@@ -247,5 +248,5 @@
 typedef struct VBOXVDMAINFO
 {
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     HGSMIHEAP CmdHeap;
 #endif
@@ -260,5 +261,5 @@
 
 int vboxVdmaCreate (struct _DEVICE_EXTENSION* pDevExt, VBOXVDMAINFO *pInfo
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
         , ULONG offBuffer, ULONG cbBuffer
 #endif
@@ -271,5 +272,5 @@
 int vboxVdmaDestroy (struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo);
 
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
 int vboxVdmaFlush (struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo);
 int vboxVdmaCBufDrSubmit (struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr);
@@ -280,4 +281,9 @@
 #define VBOXVDMACBUF_DR_SIZE(_cbData) (VBOXVDMACBUF_DR_DATA_OFFSET() + (_cbData))
 #define VBOXVDMACBUF_DR_DATA(_pDr) ( ((uint8_t*)(_pDr)) + VBOXVDMACBUF_DR_DATA_OFFSET() )
+
+AssertCompile(sizeof (VBOXVDMADDI_CMD) <= RT_SIZEOFMEMB(VBOXVDMACBUF_DR, aGuestData));
+#define VBOXVDMADDI_CMD_FROM_BUF_DR(_pDr) ((PVBOXVDMADDI_CMD)(_pDr)->aGuestData)
+#define VBOXVDMACBUF_DR_FROM_DDI_CMD(_pCmd) ((PVBOXVDMACBUF_DR)(((uint_8*)(_pCmd)) - RT_OFFSETOF(VBOXVDMACBUF_DR, aGuestData)))
+
 #endif
 NTSTATUS vboxVdmaGgCmdSubmit(PVBOXVDMAGG pVdma, PVBOXVDMAPIPE_CMD_DR pCmd);
@@ -287,4 +293,3 @@
 #define VBOXVDMAPIPE_CMD_DR_FROM_DDI_CMD(_pCmd) ((PVBOXVDMAPIPE_CMD_DR)(((uint8_t*)(_pCmd)) - RT_OFFSETOF(VBOXVDMAPIPE_CMD_DR, DdiCmd)))
 DECLCALLBACK(VOID) vboxVdmaGgDdiCmdDestroy(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext);
-
 #endif /* #ifndef ___VBoxVideoVdma_h___ */
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp	(revision 32876)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp	(revision 32877)
@@ -47,4 +47,22 @@
     GhData.Flags.Value = 0;
     return (PVBOXWDDM_ALLOCATION)pDevExt->u.primary.DxgkInterface.DxgkCbGetHandleData(&GhData);
+}
+
+DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromAllocList(PDEVICE_EXTENSION pDevExt, DXGK_ALLOCATIONLIST *pAllocList)
+{
+    return vboxWddmGetAllocationFromOpenData(pDevExt, (PVBOXWDDM_OPENALLOCATION)pAllocList->hDeviceSpecificAllocation);
+}
+
+static void vboxWddmPopulateDmaAllocInfo(PVBOXWDDM_DMA_ALLOCINFO pInfo, PVBOXWDDM_ALLOCATION pAlloc, DXGK_ALLOCATIONLIST *pDmaAlloc)
+{
+    pInfo->pAlloc = pAlloc;
+    if (pDmaAlloc->SegmentId)
+    {
+        pInfo->offAlloc = (VBOXVIDEOOFFSET)pDmaAlloc->PhysicalAddress.QuadPart;
+        pInfo->segmentIdAlloc = pDmaAlloc->SegmentId;
+    }
+    else
+        pInfo->segmentIdAlloc = 0;
+    pInfo->srcId = pAlloc->SurfDesc.VidPnSourceId;
 }
 
@@ -246,5 +264,5 @@
 HGSMIHEAP* vboxWddmHgsmiGetHeapFromCmdOffset(PDEVICE_EXTENSION pDevExt, HGSMIOFFSET offCmd)
 {
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     if(HGSMIAreaContainsOffset(&pDevExt->u.primary.Vdma.CmdHeap.area, offCmd))
         return &pDevExt->u.primary.Vdma.CmdHeap;
@@ -259,5 +277,5 @@
     VBOXWDDM_HGSMICMD_TYPE_UNDEFINED = 0,
     VBOXWDDM_HGSMICMD_TYPE_CTL       = 1,
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     VBOXWDDM_HGSMICMD_TYPE_DMACMD    = 2
 #endif
@@ -266,5 +284,5 @@
 VBOXWDDM_HGSMICMD_TYPE vboxWddmHgsmiGetCmdTypeFromOffset(PDEVICE_EXTENSION pDevExt, HGSMIOFFSET offCmd)
 {
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     if(HGSMIAreaContainsOffset(&pDevExt->u.primary.Vdma.CmdHeap.area, offCmd))
         return VBOXWDDM_HGSMICMD_TYPE_DMACMD;
@@ -764,9 +782,9 @@
     {
         VBOXSHGSMILIST CtlList;
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
         VBOXSHGSMILIST DmaCmdList;
 #endif
         vboxSHGSMIListInit(&CtlList);
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
         vboxSHGSMIListInit(&DmaCmdList);
 #endif
@@ -793,5 +811,5 @@
                     switch (enmType)
                     {
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
                         case VBOXWDDM_HGSMICMD_TYPE_DMACMD:
                             pList = &DmaCmdList;
@@ -816,5 +834,5 @@
                             switch (chInfo)
                             {
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
                                 case VBVA_VDMA_CMD:
                                 case VBVA_VDMA_CTL:
@@ -855,5 +873,5 @@
             bNeedDpc = TRUE;
         }
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
         if (!vboxSHGSMIListIsEmpty(&DmaCmdList))
         {
@@ -904,5 +922,5 @@
 {
     VBOXSHGSMILIST CtlList;
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     VBOXSHGSMILIST DmaCmdList;
 #endif
@@ -925,5 +943,5 @@
 
     vboxSHGSMIListDetach2List(&pdc->pDevExt->CtlList, &pdc->data.CtlList);
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     vboxSHGSMIListDetach2List(&pdc->pDevExt->DmaCmdList, &pdc->data.DmaCmdList);
 #endif
@@ -967,5 +985,5 @@
         AssertRC(rc);
     }
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     if (!vboxSHGSMIListIsEmpty(&context.data.DmaCmdList))
     {
@@ -1964,4 +1982,22 @@
             case VBOXVDMACMD_TYPE_DMA_NOP:
                 break;
+            case VBOXVDMACMD_TYPE_CHROMIUM_CMD:
+            {
+                uint8_t * pPrivateBuf = (uint8_t*)pPrivateDataBase;
+                for (UINT i = pPatch->PatchLocationListSubmissionStart; i < pPatch->PatchLocationListSubmissionLength; ++i)
+                {
+                    const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[i];
+                    Assert(pPatchList->AllocationIndex < pPatch->AllocationListSize);
+                    const DXGK_ALLOCATIONLIST *pAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
+                    Assert(pAllocationList->SegmentId);
+                    if (pAllocationList->SegmentId)
+                    {
+                        DXGK_ALLOCATIONLIST *pAllocation2Patch = (DXGK_ALLOCATIONLIST*)pPrivateBuf + pPatchList->PatchOffset;
+                        pAllocation2Patch->SegmentId = pAllocationList->SegmentId;
+                        pAllocation2Patch->PhysicalAddress = pAllocationList->PhysicalAddress;
+                    }
+                }
+                break;
+            }
             default:
             {
@@ -2051,5 +2087,5 @@
                 Assert(cNew < UINT32_MAX/2);
             }
-            vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, &pCmd->DdiCmd);
+            vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, &pCmd->DdiCmd, DXGK_INTERRUPT_DMA_FAULTED);
         }
     }
@@ -2079,5 +2115,5 @@
     else
     {
-        Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, u32FenceId);
+        Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, u32FenceId, DXGK_INTERRUPT_DMA_FAULTED);
     }
 
@@ -2085,4 +2121,39 @@
 }
 
+#ifdef VBOX_WITH_VDMA
+DECLCALLBACK(VOID) vboxWddmDmaCompleteChromiumCmd(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
+{
+    PVBOXVDMACBUF_DR pDr = (pDr)pvContext;
+    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
+    UINT cBufs = pHdr->u32CmdSpecific;
+    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHROMIUM_CMD);
+    for (UINT i = 0; i < cBufs; ++i)
+    {
+        VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[i];
+        if (!pBufCmd->u32GuesData)
+        {
+            /* signal completion */
+            PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBufCmd->u64GuesData;
+            switch (pAlloc->enmSynchType)
+            {
+                case VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT:
+                    KeSetEvent(pAlloc->pSynchEvent, 3, FALSE);
+                    break;
+                case VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE:
+                    KeReleaseSemaphore(pAlloc->pSynchSemaphore,
+                        3,
+                        1,
+                        FALSE);
+                    break;
+                default:
+                    Assert(0);
+            }
+        }
+    }
+
+    vboxVdmaCBufDrFree(&pDevExt->u.primary.Vdma, pDr);
+}
+
+#endif
 NTSTATUS
 APIENTRY
@@ -2140,5 +2211,5 @@
             /* get DPC data at IRQL */
 
-            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
+            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
             break;
         }
@@ -2251,7 +2322,60 @@
             if (bComplete)
             {
-                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
+                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
             }
             break;
+        }
+        case VBOXVDMACMD_TYPE_CHROMIUM_CMD:
+        {
+#ifdef VBOX_WITH_VDMA
+            VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD *pChromiumCmd = (VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD*)pPrivateDataBase;
+            UINT cbCmd = VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[pChromiumCmd->Base.u32CmdReserved]));
+
+            PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, cbCmd);
+            if (!pDr)
+            {
+                /* @todo: try flushing.. */
+                drprintf((__FUNCTION__": vboxVdmaCBufDrCreate returned NULL\n"));
+                return STATUS_INSUFFICIENT_RESOURCES;
+            }
+            // vboxVdmaCBufDrCreate zero initializes the pDr
+            pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR;
+            pDr->cbBuf = cbCmd;
+            pDr->u32FenceId = pSubmitCommand->SubmissionFenceId;
+            pDr->rc = VERR_NOT_IMPLEMENTED;
+            pDr->u64GuestContext = (uint64_t)pContext;
+
+            PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
+            pHdr->enmType = VBOXVDMACMD_TYPE_CHROMIUM_CMD;
+            pHdr->u32CmdSpecific = pChromiumCmd->Base.u32CmdReserved;
+            VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHROMIUM_CMD);
+            for (UINT i = 0; i < pChromiumCmd->Base.u32CmdReserved; ++i)
+            {
+                VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[i];
+                VBOXWDDM_UHGSMI_BUFFER_SUBMIT_INFO *pBufInfo = &pChromiumCmd->aBufInfos[i];
+
+                pBufCmd->offBuffer = pBufInfo->Alloc.offAlloc;
+                pBufCmd->cbBuffer = pBufInfo->cbData;
+                pBufCmd->u32GuesData = pBufInfo->bDoNotSignalCompletion;
+                pBufCmd->u64GuesData = (uint64_t)pBufInfo->Alloc.pAlloc;
+            }
+
+            PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);
+            vboxVdmaDdiCmdInit(pDdiCmd, pSubmitCommand->SubmissionFenceId, pContext, vboxWddmDmaCompleteChromiumCmd, pDr);
+            NTSTATUS Status = vboxVdmaDdiCmdSubmitted(pDevExt, &pDevExt->DdiCmdQueue, &pCmd->DdiCmd);
+            Assert(Status == STATUS_SUCCESS);
+            if (Status == STATUS_SUCCESS)
+            {
+                int rc = vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);
+                Assert(rc == VINF_SUCCESS);
+            }
+            else
+            {
+                vboxVdmaCBufDrFree(&pDevExt->u.primary.Vdma, pDr);
+            }
+#else
+            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
+            Assert(Status == STATUS_SUCCESS);
+#endif
         }
         case VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP:
@@ -2275,5 +2399,5 @@
             else
             {
-                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
+                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_FAULTED);
                 Assert(Status == STATUS_SUCCESS);
             }
@@ -2303,5 +2427,5 @@
             else
             {
-                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
+                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_FAULTED);
                 Assert(Status == STATUS_SUCCESS);
             }
@@ -2311,5 +2435,5 @@
         case VBOXVDMACMD_TYPE_DMA_NOP:
         {
-            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
+            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
             Assert(Status == STATUS_SUCCESS);
             break;
@@ -2318,5 +2442,5 @@
         {
             AssertBreakpoint();
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
             VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
             PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, 0);
@@ -3384,5 +3508,5 @@
                     }
                 }
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
                 else
                 {
@@ -3835,16 +3959,95 @@
         return STATUS_INVALID_PARAMETER;
     }
-
+    if (pRender->CommandLength < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
+    {
+        Assert(0);
+        drprintf((__FUNCTION__": Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)\n",
+                pRender->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
+        /* @todo: can this actually happen? what status to return? */
+        return STATUS_INVALID_PARAMETER;
+    }
+
+    PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pInputHdr = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)pRender->pCommand;
     NTSTATUS Status = STATUS_SUCCESS;
-    PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pPrivateData = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)pRender->pDmaBufferPrivateData;
-    pPrivateData->enmCmd = VBOXVDMACMD_TYPE_DMA_NOP;
-
-    pRender->pDmaBufferPrivateData = (uint8_t*)pRender->pDmaBufferPrivateData + sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR);
-    pRender->pDmaBuffer = ((uint8_t*)pRender->pDmaBuffer) + pRender->CommandLength;
-    Assert(pRender->DmaSize >= pRender->CommandLength);
-    Assert(pRender->PatchLocationListOutSize >= pRender->PatchLocationListInSize);
-    UINT cbPLL = pRender->PatchLocationListInSize * sizeof (pRender->pPatchLocationListOut[0]);
-    memcpy(pRender->pPatchLocationListOut, pRender->pPatchLocationListIn, cbPLL);
-    pRender->pPatchLocationListOut += pRender->PatchLocationListInSize;
+    switch (pInputHdr->enmCmd)
+    {
+        case VBOXVDMACMD_TYPE_CHROMIUM_CMD:
+        {
+            if (pRender->CommandLength != RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, aBufInfos[pInputHdr->u32CmdReserved]))
+            {
+                Assert(0);
+                return STATUS_INVALID_PARAMETER;
+            }
+            PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD pUmCmd = (PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD)pInputHdr;
+            PVBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD pChromiumCmd = (PVBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD)pRender->pDmaBufferPrivateData;
+            const uint32_t cbDma = RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD, aBufInfos[pInputHdr->u32CmdReserved]);
+            if (pRender->DmaBufferPrivateDataSize < cbDma)
+            {
+                Assert(0);
+                return STATUS_INVALID_PARAMETER;
+            }
+            if (pRender->DmaSize < cbDma)
+            {
+                Assert(0);
+                return STATUS_INVALID_PARAMETER;
+            }
+
+            if (pRender->PatchLocationListOutSize < pInputHdr->u32CmdReserved)
+            {
+                Assert(0);
+                return STATUS_INVALID_PARAMETER;
+            }
+
+            PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)hContext;
+            PVBOXWDDM_DEVICE pDevice = pContext->pDevice;
+            PDEVICE_EXTENSION pDevExt = pDevice->pAdapter;
+
+            pChromiumCmd->Base.enmCmd = VBOXVDMACMD_TYPE_CHROMIUM_CMD;
+            pChromiumCmd->Base.u32CmdReserved = pInputHdr->u32CmdReserved;
+            pRender->pDmaBufferPrivateData = (uint8_t*)pRender->pDmaBufferPrivateData + cbDma;
+            pRender->pDmaBuffer = ((uint8_t*)pRender->pDmaBuffer) + cbDma;
+            D3DDDI_PATCHLOCATIONLIST* pPLL = pRender->pPatchLocationListOut;
+            memset(pPLL, 0, sizeof (*pPLL) * pChromiumCmd->Base.u32CmdReserved);
+            pRender->pPatchLocationListOut += pInputHdr->u32CmdReserved;
+            PVBOXWDDM_UHGSMI_BUFFER_SUBMIT_INFO pSubmInfo = pChromiumCmd->aBufInfos;
+            PVBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO pSubmUmInfo = pUmCmd->aBufInfos;
+            DXGK_ALLOCATIONLIST *pAllocationList = pRender->pAllocationList;
+            for (UINT i = 0; i < pChromiumCmd->Base.u32CmdReserved; ++i)
+            {
+                PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pAllocationList);
+                vboxWddmPopulateDmaAllocInfo(&pSubmInfo->Alloc, pAlloc, pAllocationList);
+
+                pSubmInfo->cbData = pSubmUmInfo->cbData;
+                pSubmInfo->bDoNotSignalCompletion = pSubmUmInfo->fSubFlags.bDoNotSignalCompletion;
+
+                pPLL->AllocationIndex = i;
+                pPLL->PatchOffset = RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD, aBufInfos[i].Alloc);
+                pPLL->AllocationOffset = pSubmUmInfo->offData;
+
+                ++pPLL;
+                ++pSubmInfo;
+                ++pSubmUmInfo;
+                ++pAllocationList;
+            }
+
+            break;
+        }
+        case VBOXVDMACMD_TYPE_DMA_NOP:
+        {
+            PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pPrivateData = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)pRender->pDmaBufferPrivateData;
+            pPrivateData->enmCmd = VBOXVDMACMD_TYPE_DMA_NOP;
+
+            pRender->pDmaBufferPrivateData = (uint8_t*)pRender->pDmaBufferPrivateData + sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR);
+            pRender->pDmaBuffer = ((uint8_t*)pRender->pDmaBuffer) + pRender->CommandLength;
+            Assert(pRender->DmaSize >= pRender->CommandLength);
+            Assert(pRender->PatchLocationListOutSize >= pRender->PatchLocationListInSize);
+            UINT cbPLL = pRender->PatchLocationListInSize * sizeof (pRender->pPatchLocationListOut[0]);
+            memcpy(pRender->pPatchLocationListOut, pRender->pPatchLocationListIn, cbPLL);
+            pRender->pPatchLocationListOut += pRender->PatchLocationListInSize;
+            break;
+        }
+        default:
+            return STATUS_INVALID_PARAMETER;
+    }
 
     drprintf(("<== "__FUNCTION__ ", hContext(0x%x)\n", hContext));
@@ -3856,10 +4059,5 @@
 #define VBOXVDMACMD_DMA_PRESENT_BLT_SIZE(_c) (VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, aDstSubRects[_c]))
 
-DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromAllocList(PDEVICE_EXTENSION pDevExt, DXGK_ALLOCATIONLIST *pAllocList)
-{
-    return vboxWddmGetAllocationFromOpenData(pDevExt, (PVBOXWDDM_OPENALLOCATION)pAllocList->hDeviceSpecificAllocation);
-}
-
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
 DECLINLINE(VOID) vboxWddmRectlFromRect(const RECT *pRect, PVBOXVDMA_RECTL pRectl)
 {
@@ -3916,16 +4114,4 @@
 #endif
 
-static void vboxWddmPopulateDmaAllocInfo(PVBOXWDDM_DMA_ALLOCINFO pInfo, PVBOXWDDM_ALLOCATION pAlloc, DXGK_ALLOCATIONLIST *pDmaAlloc)
-{
-    pInfo->pAlloc = pAlloc;
-    if (pDmaAlloc->SegmentId)
-    {
-        pInfo->offAlloc = (VBOXVIDEOOFFSET)pDmaAlloc->PhysicalAddress.QuadPart;
-        pInfo->segmentIdAlloc = pDmaAlloc->SegmentId;
-    }
-    else
-        pInfo->segmentIdAlloc = 0;
-    pInfo->srcId = pAlloc->SurfDesc.VidPnSourceId;
-}
 /**
  * DxgkDdiPresent
@@ -4109,5 +4295,5 @@
 
                     break;
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
                     cbCmd = pPresent->DmaSize;
 
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h	(revision 32876)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h	(revision 32877)
@@ -24,11 +24,11 @@
 #define VBOXWDDM_C_POINTER_MAX_HEIGHT 64
 
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
 #define VBOXWDDM_C_VDMA_BUFFER_SIZE   (64*_1K)
 #endif
 
 #ifndef VBOXWDDM_RENDER_FROM_SHADOW
-# ifndef VBOXVDMA
-#  error "VBOXVDMA must be defined!!!"
+# ifndef VBOX_WITH_VDMA
+#  error "VBOX_WITH_VDMA must be defined!!!"
 # endif
 #endif
@@ -76,4 +76,10 @@
     DXGK_ALLOCATIONUSAGEHINT UsageHint;
     uint32_t iIndex;
+    VBOXUHGSMI_SYNCHOBJECT_TYPE enmSynchType;
+    union
+    {
+        PKEVENT pSynchEvent;
+        PRKSEMAPHORE pSynchSemaphore;
+    };
 } VBOXWDDM_ALLOCATION, *PVBOXWDDM_ALLOCATION;
 
@@ -164,27 +170,4 @@
 #define VBOXWDDMENTRY_2_SWAPCHAIN(_pE) ((PVBOXWDDM_SWAPCHAIN)((uint8_t*)(_pE) - RT_OFFSETOF(VBOXWDDM_SWAPCHAIN, DevExtListEntry)))
 
-typedef struct VBOXWDDM_DMA_PRIVATEDATA_FLAFS
-{
-    union
-    {
-        struct
-        {
-            UINT bCmdInDmaBuffer : 1;
-            UINT bReserved : 31;
-        };
-        uint32_t Value;
-    };
-} VBOXWDDM_DMA_PRIVATEDATA_FLAFS, *PVBOXWDDM_DMA_PRIVATEDATA_FLAFS;
-
-typedef struct VBOXWDDM_DMA_PRIVATEDATA_BASEHDR
-{
-    VBOXVDMACMD_TYPE enmCmd;
-    union
-    {
-        VBOXWDDM_DMA_PRIVATEDATA_FLAFS fFlags;
-        uint32_t u32CmdReserved;
-    };
-}VBOXWDDM_DMA_PRIVATEDATA_BASEHDR, *PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR;
-
 typedef struct VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR
 {
@@ -219,4 +202,17 @@
     VBOXVDMA_CLRFILL ClrFill;
 } VBOXWDDM_DMA_PRIVATEDATA_CLRFILL, *PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL;
+
+typedef struct VBOXWDDM_UHGSMI_BUFFER_SUBMIT_INFO
+{
+    VBOXWDDM_DMA_ALLOCINFO Alloc;
+    uint32_t cbData;
+    uint32_t bDoNotSignalCompletion;
+} VBOXWDDM_UHGSMI_BUFFER_SUBMIT_INFO, *PVBOXWDDM_UHGSMI_BUFFER_SUBMIT_INFO;
+
+typedef struct VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD
+{
+    VBOXWDDM_DMA_PRIVATEDATA_BASEHDR Base;
+    VBOXWDDM_UHGSMI_BUFFER_SUBMIT_INFO aBufInfos[1];
+} VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD, *PVBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD;
 
 typedef struct VBOXWDDM_OPENALLOCATION
Index: /trunk/src/VBox/Devices/Graphics/DevVGA.cpp
===================================================================
--- /trunk/src/VBox/Devices/Graphics/DevVGA.cpp	(revision 32876)
+++ /trunk/src/VBox/Devices/Graphics/DevVGA.cpp	(revision 32877)
@@ -2136,6 +2136,7 @@
 
     int rc;
-#ifdef VBOXVDMA
-    /* do not do pfnResize in case VBVA is on since all mode changes are poerofmed over VBVA
+#if 0 //def VBOX_WITH_VDMA
+    /* @todo: we get a second resize here when VBVA is on, while we actually should not */
+    /* do not do pfnResize in case VBVA is on since all mode changes are performed over VBVA
      * we are checking for VDMA state here to ensure this code works only for WDDM driver,
      * although we should avoid calling pfnResize for XPDM as well, since pfnResize is actually an extra resize
@@ -6851,5 +6852,5 @@
 #endif /* VBOX_WITH_HGSMI */
 
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     if(rc == VINF_SUCCESS)
     {
Index: /trunk/src/VBox/Devices/Graphics/DevVGA.h
===================================================================
--- /trunk/src/VBox/Devices/Graphics/DevVGA.h	(revision 32876)
+++ /trunk/src/VBox/Devices/Graphics/DevVGA.h	(revision 32877)
@@ -256,5 +256,5 @@
 #endif /* VBOX */
 
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
 typedef struct VBOXVDMAHOST *PVBOXVDMAHOST;
 #endif
@@ -290,5 +290,5 @@
     R3PTRTYPE(PHGSMIINSTANCE)   pHGSMI;
 #endif /* VBOX_WITH_HGSMI */
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
     R3PTRTYPE(PVBOXVDMAHOST)    pVdma;
 #endif
@@ -495,5 +495,5 @@
 int vboxVBVALoadStateDone (PPDMDEVINS pDevIns, PSSMHANDLE pSSM);
 
-# ifdef VBOXVDMA
+# ifdef VBOX_WITH_VDMA
 typedef struct VBOXVDMAHOST *PVBOXVDMAHOST;
 int vboxVDMAConstruct(PVGASTATE pVGAState, struct VBOXVDMAHOST **ppVdma, uint32_t cPipeElements);
@@ -502,5 +502,5 @@
 void vboxVDMACommand(PVBOXVDMAHOST pVdma, PVBOXVDMACBUF_DR pCmd);
 bool vboxVDMAIsEnabled(PVBOXVDMAHOST pVdma);
-# endif /* VBOXVDMA */
+# endif /* VBOX_WITH_VDMA */
 
 #endif /* VBOX_WITH_HGSMI */
Index: /trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp
===================================================================
--- /trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp	(revision 32876)
+++ /trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp	(revision 32877)
@@ -1343,5 +1343,5 @@
 static DECLCALLBACK(void) vbvaNotifyGuest (void *pvCallback)
 {
-#if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOXVDMA) || defined(VBOX_WITH_WDDM))
+#if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM))
     PVGASTATE pVGAState = (PVGASTATE)pvCallback;
     PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
@@ -1370,5 +1370,5 @@
     switch (u16ChannelInfo)
     {
-#ifdef VBOXVDMA
+#ifdef VBOX_WITH_VDMA
         case VBVA_VDMA_CMD:
         {
Index: /trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp
===================================================================
--- /trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp	(revision 32876)
+++ /trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp	(revision 32877)
@@ -290,4 +290,9 @@
         switch (pCmd->enmType)
         {
+            case VBOXVDMACMD_TYPE_CHROMIUM_CMD:
+            {
+                /* todo: post the buffer to chromium */
+                return VINF_SUCCESS;
+            }
             case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT:
             {
Index: /trunk/src/VBox/Devices/Makefile.kmk
===================================================================
--- /trunk/src/VBox/Devices/Makefile.kmk	(revision 32876)
+++ /trunk/src/VBox/Devices/Makefile.kmk	(revision 32877)
@@ -348,4 +348,9 @@
 	Graphics/HGSMI/SHGSMIHost.cpp
 endif
+ifdef VBOX_WITH_VDMA
+ DevicesR3_DEFS        += VBOX_WITH_VDMA
+ DevicesR3_SOURCES      += \
+	Graphics/DevVGA_VDMA.cpp
+endif
 ifdef VBOXWDDM_WITH_VBVA
  DevicesR3_DEFS        += VBOXWDDM_WITH_VBVA
@@ -577,4 +582,8 @@
   VBoxDDGC_DEFS        += VBOX_WITH_WDDM
  endif
+ ifdef VBOX_WITH_VDMA
+  VBoxDDGC_DEFS        += VBOX_WITH_VDMA
+ endif
+ 
  ifdef VBOXWDDM_WITH_VBVA
   VBoxDDGC_DEFS         += VBOXWDDM_WITH_VBVA
@@ -601,4 +610,7 @@
  ifdef VBOX_WITH_WDDM
   VBoxDDGC_DEFS        += VBOX_WITH_WDDM
+ endif
+ ifdef VBOX_WITH_VDMA
+  VBoxDDGC_DEFS        += VBOX_WITH_VDMA
  endif
  ifdef VBOXWDDM_WITH_VBVA
@@ -689,4 +701,7 @@
  VBoxDDR0_DEFS         += VBOX_WITH_WDDM
 endif
+ifdef VBOX_WITH_VDMA
+ VBoxDDR0_DEFS        += VBOX_WITH_VDMA
+endif
 ifdef VBOXWDDM_WITH_VBVA
  VBoxDDR0_DEFS         += VBOXWDDM_WITH_VBVA
@@ -734,4 +749,7 @@
 ifdef VBOX_WITH_WDDM
  VBoxDDR0_DEFS         += VBOX_WITH_WDDM
+endif
+ifdef VBOX_WITH_VDMA
+ VBoxDDR0_DEFS         += VBOX_WITH_VDMA
 endif
 ifdef VBOXWDDM_WITH_VBVA