Changeset 41638 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm

Timestamp:

Jun 9, 2012 4:58:09 PM (12 years ago)

Author:

vboxsync

Message:

wddm: vsync support fixes + missing commit

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm

Files:

• VBoxMPMisc.cpp (modified) (2 diffs)
• VBoxMPTypes.h (modified) (1 diff)
• VBoxMPVdma.cpp (modified) (1 diff)
• VBoxMPWddm.cpp (modified) (15 diffs)
• VBoxMPWddm.h (modified) (1 diff)

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp

@@ -2535 +2535 @@
         LARGE_INTEGER DueTime;
         DueTime.QuadPart = -166666LL; /* 60 Hz */
-        KeSetTimerEx(&pDevExt->VSyncTimer, DueTime, 17, &pDevExt->VSyncDpc);
+        KeSetTimerEx(&pDevExt->VSyncTimer, DueTime, 16, &pDevExt->VSyncDpc);
     }
     return STATUS_SUCCESS;
@@ -2581 +2581 @@
     {
         PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
-        PVBOXWDDM_ALLOCATION pPrimary = pSource->pPrimaryAllocation;
-        if (pPrimary && pPrimary->offVram != VBOXVIDEOOFFSET_VOID)
-        {
-            memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
-            notify.InterruptType = DXGK_INTERRUPT_CRTC_VSYNC;
-            /* @todo: !!!this is not correct in case we want source[i]->target[i!=j] mapping */
-            notify.CrtcVsync.VidPnTargetId = i;
-            notify.CrtcVsync.PhysicalAddress.QuadPart = pPrimary->offVram;
-            /* yes, we can report VSync at dispatch */
-            pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
-            bNeedDpc = TRUE;
-        }
+        PVBOXWDDM_ALLOCATION pPrimary = vboxWddmAquirePrimary(pDevExt, pSource, i);
+        if (pPrimary)
+        {
+            VBOXVIDEOOFFSET offVram = pPrimary->offVram;
+            if (offVram != VBOXVIDEOOFFSET_VOID)
+            {
+                memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
+                notify.InterruptType = DXGK_INTERRUPT_CRTC_VSYNC;
+                /* @todo: !!!this is not correct in case we want source[i]->target[i!=j] mapping */
+                notify.CrtcVsync.VidPnTargetId = i;
+                notify.CrtcVsync.PhysicalAddress.QuadPart = pPrimary->offVram;
+                /* yes, we can report VSync at dispatch */
+                pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
+                bNeedDpc = TRUE;
+            }
+#ifdef DEBUG_misha
+            else
+                Assert(0);
+#endif
+            vboxWddmAllocationRelease(pPrimary);
+        }
+#ifdef DEBUG_misha
+        else
+            Assert(0);
+#endif
     }
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h

@@ -104 +104 @@
     KSPIN_LOCK OverlayListLock;
 #endif
+    KSPIN_LOCK AllocationLock;
     POINT VScreenPos;
     VBOXWDDM_POINTER_INFO PointerInfo;

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp

@@ -809 +809 @@
             Assert(pFlip->Hdr.fFlags.fVisibleRegions);
             Assert(!pFlip->Hdr.fFlags.fRealOp);
+            PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
+            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->SurfDesc.VidPnSourceId];
+            vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->SurfDesc.VidPnSourceId);
             if (pFlip->Hdr.fFlags.fVisibleRegions)
             {

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

@@ -879 +879 @@
         if (RT_SUCCESS(rc))
         {
+#ifdef VBOX_VDMA_WITH_WATCHDOG
+            vboxWddmWdInit(pDevExt);
+#endif
             /* can enable it right away since the host does not need any screen/FB info
              * for basic DMA functionality */
@@ -982 +985 @@
     if (RT_SUCCESS(rc))
     {
+#ifdef VBOX_VDMA_WITH_WATCHDOG
+        vboxWddmWdTerm(pDevExt);
+#endif
         rc = vboxVdmaDestroy(pDevExt, &pDevExt->u.primary.Vdma);
         AssertRC(rc);
@@ -1115 +1121 @@
                     vboxVhwaInit(pDevExt);
 #endif
+                    VBoxWddmSlInit(pDevExt);
+
+                    for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
+                    {
+                        PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
+                        KeInitializeSpinLock(&pSource->AllocationLock);
+                    }
                 }
                 else
@@ -1159 +1172 @@
     PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
     NTSTATUS Status = STATUS_SUCCESS;
+
+    VBoxWddmSlTerm(pDevExt);
 
     vboxVideoCmTerm(&pDevExt->CmMgr);
@@ -1402 +1417 @@
         if (pDevExt->bNotifyDxDpc)
         {
-//            Assert(bNeedDpc == TRUE);
-//            pDevExt->bNotifyDxDpc = TRUE;
-//            pDevExt->bSetNotifyDxDpc = FALSE;
             bNeedDpc = TRUE;
         }
@@ -1410 +1422 @@
         if (bOur)
         {
+#ifdef VBOX_VDMA_WITH_WATCHDOG
+            if (flags & HGSMIHOSTFLAGS_WATCHDOG)
+            {
+                Assert(0);
+            }
+#endif
+            if (flags & HGSMIHOSTFLAGS_VSYNC)
+            {
+                Assert(0);
+                DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
+                for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
+                {
+                    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
+                    PVBOXWDDM_ALLOCATION pPrimary = pSource->pPrimaryAllocation;
+                    if (pPrimary && pPrimary->offVram != VBOXVIDEOOFFSET_VOID)
+                    {
+                        memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
+                        notify.InterruptType = DXGK_INTERRUPT_CRTC_VSYNC;
+                        /* @todo: !!!this is not correct in case we want source[i]->target[i!=j] mapping */
+                        notify.CrtcVsync.VidPnTargetId = i;
+                        notify.CrtcVsync.PhysicalAddress.QuadPart = pPrimary->offVram;
+                        pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
+
+                        pDevExt->bNotifyDxDpc = TRUE;
+                    }
+                }
+            }
+
+            if (pDevExt->bNotifyDxDpc)
+            {
+                bNeedDpc = TRUE;
+            }
+
             VBoxHGSMIClearIrq(&VBoxCommonFromDeviceExt(pDevExt)->hostCtx);
 #if 0 //def DEBUG_misha
@@ -1493 +1538 @@
     Assert(Status == STATUS_SUCCESS);
 
-    if (context.data.bNotifyDpc)
-        pDevExt->u.primary.DxgkInterface.DxgkCbNotifyDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
+//    if (context.data.bNotifyDpc)
+    pDevExt->u.primary.DxgkInterface.DxgkCbNotifyDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
 
     if (!vboxVtListIsEmpty(&context.data.CtlList))
@@ -1937 +1982 @@
 }
 
-VOID vboxWddmAllocationCleanup(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
+VOID vboxWddmAllocationCleanupAssignment(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
 {
     switch (pAllocation->enmType)
@@ -1949 +1994 @@
                 vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[pAllocation->SurfDesc.VidPnSourceId], NULL, pAllocation->SurfDesc.VidPnSourceId);
             }
-
+            break;
+        }
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+        case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
+        {
+            if (pAllocation->bAssigned)
+            {
+                Assert(pAllocation->SurfDesc.VidPnSourceId != D3DDDI_ID_UNINITIALIZED);
+                /* @todo: do we need to notify host? */
+                vboxWddmAssignShadow(pDevExt, &pDevExt->aSources[pAllocation->SurfDesc.VidPnSourceId], NULL, pAllocation->SurfDesc.VidPnSourceId);
+            }
+            break;
+        }
+#endif
+        default:
+            break;
+    }
+}
+
+VOID vboxWddmAllocationCleanup(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
+{
+    switch (pAllocation->enmType)
+    {
+        case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
+        case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
+        {
 #if 0
             if (pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC)
@@ -1961 +2031 @@
             break;
         }
-#ifdef VBOXWDDM_RENDER_FROM_SHADOW
-        case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
-        {
-            if (pAllocation->bAssigned)
-            {
-                Assert(pAllocation->SurfDesc.VidPnSourceId != D3DDDI_ID_UNINITIALIZED);
-                /* @todo: do we need to notify host? */
-                vboxWddmAssignShadow(pDevExt, &pDevExt->aSources[pAllocation->SurfDesc.VidPnSourceId], NULL, pAllocation->SurfDesc.VidPnSourceId);
-            }
-            break;
-        }
-#endif
         case VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER:
         {
@@ -2310 +2368 @@
         PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pDestroyAllocation->pAllocationList[i];
         Assert(pAlloc->pResource == pRc);
+        vboxWddmAllocationCleanupAssignment(pDevExt, pAlloc);
         /* wait for all current allocation-related ops are completed */
         vboxWddmAllocationWaitDereference(pAlloc);
@@ -3042 +3101 @@
         {
             VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip = (VBOXWDDM_DMA_PRIVATEDATA_FLIP*)pPrivateDataBase;
+            vboxWddmAllocUpdateAddress(pFlip->Flip.Alloc.pAlloc, pFlip->Flip.Alloc.segmentIdAlloc, pFlip->Flip.Alloc.offAlloc);
             PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlipCmd = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)vboxVdmaGgCmdCreate(pDevExt,
                     VBOXVDMAPIPE_CMD_TYPE_DMACMD, sizeof (VBOXVDMAPIPE_CMD_DMACMD_FLIP));
@@ -3069 +3129 @@
         {
             PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pPrivateDataBase;
+            vboxWddmAllocUpdateAddress(pCF->ClrFill.Alloc.pAlloc, pCF->ClrFill.Alloc.segmentIdAlloc, pCF->ClrFill.Alloc.offAlloc);
             PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCFCmd = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)vboxVdmaGgCmdCreate(pDevExt,
                     VBOXVDMAPIPE_CMD_TYPE_DMACMD, RT_OFFSETOF(VBOXVDMAPIPE_CMD_DMACMD_CLRFILL, ClrFill.Rects.aRects[pCF->ClrFill.Rects.cRects]));
@@ -4853 +4914 @@
     PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter;
 
-    Assert((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays > pGetScanLine->VidPnTargetId);
-    VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[pGetScanLine->VidPnTargetId];
-    Assert(pTarget->HeightTotal);
-    Assert(pTarget->HeightVisible);
-    Assert(pTarget->HeightTotal > pTarget->HeightVisible);
-    Assert(pTarget->ScanLineState < pTarget->HeightTotal);
-    if (pTarget->HeightTotal)
-    {
-        uint32_t curScanLine = pTarget->ScanLineState;
-        ++pTarget->ScanLineState;
-        if (pTarget->ScanLineState >= pTarget->HeightTotal)
-            pTarget->ScanLineState = 0;
-
-
-        BOOL bVBlank = (!curScanLine || curScanLine > pTarget->HeightVisible);
-        pGetScanLine->ScanLine = curScanLine;
-        pGetScanLine->InVerticalBlank = bVBlank;
-    }
-    else
-    {
-        pGetScanLine->InVerticalBlank = TRUE;
-        pGetScanLine->ScanLine = 0;
-    }
+#ifdef DEBUG_misha
+    RT_BREAKPOINT();
+#endif
+
+    NTSTATUS Status = VBoxWddmSlGetScanLine(pDevExt, pGetScanLine);
 
     LOGF(("LEAVE, hAdapter(0x%x)", hAdapter));
 
-    return STATUS_SUCCESS;
+    return Status;
 }
 
@@ -4907 +4950 @@
     LOGF(("ENTER, hAdapter(0x%x)", hAdapter));
 
-//    AssertBreakpoint();
+    NTSTATUS Status = STATUS_SUCCESS;
+    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter;
+
+    switch (InterruptType)
+    {
+        case DXGK_INTERRUPT_CRTC_VSYNC:
+        {
+            Status = VBoxWddmSlEnableVSyncNotification(pDevExt, Enable);
+            if (!NT_SUCCESS(Status))
+                WARN(("VSYNC Interrupt control failed Enable(%d), Status(0x%x)", Enable, Status));
+            break;
+        }
+        case DXGK_INTERRUPT_DMA_COMPLETED:
+        case DXGK_INTERRUPT_DMA_PREEMPTED:
+        case DXGK_INTERRUPT_DMA_FAULTED:
+            WARN(("Unexpected interrupt type! %d", InterruptType));
+            break;
+        default:
+            WARN(("UNSUPPORTED interrupt type! %d", InterruptType));
+            break;
+    }
 
     LOGF(("LEAVE, hAdapter(0x%x)", hAdapter));
 
-    /* @todo: STATUS_NOT_IMPLEMENTED ?? */
-    return STATUS_SUCCESS;
+    return Status;
 }
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.h

@@ -75 +75 @@
 }
 
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+DECLINLINE(void) vboxWddmAssignShadow(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
+{
+    if (pSource->pShadowAllocation == pAllocation)
+    {
+        Assert(pAllocation->bAssigned);
+        return;
+    }
+
+    if (pSource->pShadowAllocation)
+    {
+        PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pShadowAllocation;
+        /* clear the visibility info fo the current primary */
+        pOldAlloc->bVisible = FALSE;
+        pOldAlloc->bAssigned = FALSE;
+        Assert(pOldAlloc->SurfDesc.VidPnSourceId == srcId);
+        /* release the shadow surface */
+        pOldAlloc->SurfDesc.VidPnSourceId = D3DDDI_ID_UNINITIALIZED;
+    }
+
+    if (pAllocation)
+    {
+        Assert(!pAllocation->bAssigned);
+        Assert(!pAllocation->bVisible);
+        pAllocation->bVisible = FALSE;
+        /* this check ensures the shadow is not used for other source simultaneously */
+        Assert(pAllocation->SurfDesc.VidPnSourceId == D3DDDI_ID_UNINITIALIZED);
+        pAllocation->SurfDesc.VidPnSourceId = srcId;
+        pAllocation->bAssigned = TRUE;
+        if (!vboxWddmCmpSurfDescsBase(&pSource->SurfDesc, &pAllocation->SurfDesc))
+            pSource->offVram = VBOXVIDEOOFFSET_VOID; /* force guest->host notification */
+        pSource->SurfDesc = pAllocation->SurfDesc;
+    }
+
+    pSource->pShadowAllocation = pAllocation;
+}
+#endif
+
+DECLINLINE(VOID) vboxWddmAssignPrimary(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
+{
+    /* vboxWddmAssignPrimary can not be run in reentrant order, so safely do a direct unlocked check here */
+    if (pSource->pPrimaryAllocation == pAllocation)
+        return;
+
+    if (pSource->pPrimaryAllocation)
+    {
+        PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pPrimaryAllocation;
+        /* clear the visibility info fo the current primary */
+        pOldAlloc->bVisible = FALSE;
+        pOldAlloc->bAssigned = FALSE;
+        Assert(pOldAlloc->SurfDesc.VidPnSourceId == srcId);
+
+        vboxWddmAllocationRelease(pOldAlloc);
+    }
+
+    if (pAllocation)
+    {
+        pAllocation->bVisible = FALSE;
+        Assert(pAllocation->SurfDesc.VidPnSourceId == srcId);
+        pAllocation->bAssigned = TRUE;
+
+        vboxWddmAllocationRetain(pAllocation);
+    }
+
+    KIRQL OldIrql;
+    KeAcquireSpinLock(&pSource->AllocationLock, &OldIrql);
+    pSource->pPrimaryAllocation = pAllocation;
+    KeReleaseSpinLock(&pSource->AllocationLock, OldIrql);
+}
+
+DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmAquirePrimary(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
+{
+    PVBOXWDDM_ALLOCATION pPrimary;
+    KIRQL OldIrql;
+    KeAcquireSpinLock(&pSource->AllocationLock, &OldIrql);
+    pPrimary = pSource->pPrimaryAllocation;
+    if (pPrimary)
+        vboxWddmAllocationRetain(pPrimary);
+    KeReleaseSpinLock(&pSource->AllocationLock, OldIrql);
+    return pPrimary;
+}
+
 
 #define VBOXWDDMENTRY_2_SWAPCHAIN(_pE) ((PVBOXWDDM_SWAPCHAIN)((uint8_t*)(_pE) - RT_OFFSETOF(VBOXWDDM_SWAPCHAIN, DevExtListEntry)))