VirtualBox

Changeset 94631 in vbox for trunk/src/VBox/Additions/WINNT


Ignore:
Timestamp:
Apr 19, 2022 1:23:11 PM (3 years ago)
Author:
vboxsync
Message:

WDDM: support for command buffers. bugref:9845

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium/Svga.cpp

    r94622 r94631  
    303303    const uint32_t cbSubmit =   sizeof(uint32_t)
    304304                              + sizeof(SVGAScreenObject);
    305     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     305    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    306306    if (pvCmd)
    307307    {
    … …  
    309309                            xOrigin, yOrigin, u32Width, u32Height,
    310310                            /* fPrimary = */ false, u32Offset, fBlank);
    311         SvgaFifoCommit(pSvga, cbSubmit);
     311        SvgaCommit(pSvga, cbSubmit);
    312312    }
    313313    else
    … …  
    326326    const uint32_t cbSubmit =   sizeof(uint32_t)
    327327                              + sizeof(SVGAFifoCmdDestroyScreen);
    328     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     328    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    329329    if (pvCmd)
    330330    {
    331331        SvgaCmdDestroyScreen(pvCmd, u32ScreenId);
    332         SvgaFifoCommit(pSvga, cbSubmit);
     332        SvgaCommit(pSvga, cbSubmit);
    333333    }
    334334    else
    … …  
    423423    uint32_t cbSubmit =   sizeof(SVGA3dCmdHeader)
    424424                        + sizeof(SVGA3dCmdDefineContext);
    425     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     425    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    426426    if (pvCmd)
    427427    {
    428428        Svga3dCmdDefineContext(pvCmd, u32Cid);
    429         SvgaFifoCommit(pSvga, cbSubmit);
     429        SvgaCommit(pSvga, cbSubmit);
    430430    }
    431431    else
    … …  
    447447    const uint32_t cbSubmit =   sizeof(SVGA3dCmdHeader)
    448448                              + sizeof(SVGA3dCmdDestroyContext);
    449     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     449    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    450450    if (pvCmd)
    451451    {
    452452        Svga3dCmdDestroyContext(pvCmd, u32Cid);
    453         SvgaFifoCommit(pSvga, cbSubmit);
     453        SvgaCommit(pSvga, cbSubmit);
    454454    }
    455455    else
    … …  
    468468    const uint32_t cbSubmit =  sizeof(uint32_t)
    469469                             + sizeof(SVGAFifoCmdFence);
    470     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     470    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    471471    if (pvCmd)
    472472    {
    473473        SvgaCmdFence(pvCmd, u32Fence);
    474474
    475         SvgaFifoCommit(pSvga, cbSubmit);
     475        SvgaCommit(pSvga, cbSubmit);
     476        SvgaFlush(pSvga);
    476477    }
    477478    else
    … …  
    496497                              + cSizes * sizeof(SVGA3dSize);
    497498
    498     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     499    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    499500    if (pvCmd)
    500501    {
    501502        Svga3dCmdDefineSurface(pvCmd, u32Sid, pCreateParms, paSizes, cSizes);
    502         SvgaFifoCommit(pSvga, cbSubmit);
     503        SvgaCommit(pSvga, cbSubmit);
    503504    }
    504505    else
    … …  
    517518    const uint32_t cbSubmit =   sizeof(SVGA3dCmdHeader)
    518519                              + sizeof(SVGA3dCmdDestroySurface);
    519     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     520    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    520521    if (pvCmd)
    521522    {
    522523        Svga3dCmdDestroySurface(pvCmd, u32Sid);
    523         SvgaFifoCommit(pSvga, cbSubmit);
     524        SvgaCommit(pSvga, cbSubmit);
    524525    }
    525526    else
    … …  
    981982    SvgaGenPresent(0, 0, 0, NULL, 0, &cbSubmit);
    982983
    983     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     984    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    984985    if (pvCmd)
    985986    {
    986987        SvgaGenPresent(u32Sid, u32Width, u32Height, pvCmd, cbSubmit, NULL);
    987         SvgaFifoCommit(pSvga, cbSubmit);
     988        SvgaCommit(pSvga, cbSubmit);
     989        SvgaFlush(pSvga);
    988990    }
    989991    else
    … …  
    10411043    SvgaGenPresentVRAM(pSvga, 0, 0, 0, 0, NULL, 0, &cbSubmit);
    10421044
    1043     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     1045    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    10441046    if (pvCmd)
    10451047    {
    10461048        Status = SvgaGenPresentVRAM(pSvga, u32Sid, u32Width, u32Height, u32VRAMOffset, pvCmd, cbSubmit, NULL);
    10471049        Assert(Status == STATUS_SUCCESS);
    1048         SvgaFifoCommit(pSvga, cbSubmit);
     1050        SvgaCommit(pSvga, cbSubmit);
     1051        SvgaFlush(pSvga);
    10491052    }
    10501053    else
    … …  
    11191122}
    11201123
    1121 void *SvgaReserve(PVBOXWDDM_EXT_VMSVGA pSvga, uint32_t cbReserve, uint32_t idDXContext)
    1122 {
    1123     if (pSvga->pCBState)
    1124         return SvgaCmdBufReserve(pSvga, cbReserve, idDXContext);
    1125     return SvgaFifoReserve(pSvga, cbReserve);
    1126 }
    1127 
    1128 void SvgaCommit(PVBOXWDDM_EXT_VMSVGA pSvga, uint32_t cbActual)
    1129 {
    1130     if (pSvga->pCBState)
    1131     {
    1132         SvgaCmdBufCommit(pSvga, cbActual);
    1133         return;
    1134     }
    1135     SvgaFifoCommit(pSvga, cbActual);
    1136 }
    1137 
    1138 void SvgaFlush(PVBOXWDDM_EXT_VMSVGA pSvga)
    1139 {
    1140     if (pSvga->pCBState)
    1141         SvgaCmdBufFlush(pSvga);
    1142 }
    1143 
    11441124NTSTATUS SvgaBlitGMRFBToScreen(PVBOXWDDM_EXT_VMSVGA pSvga,
    11451125                               uint32_t idDstScreen,
    … …  
    11551135                             NULL, 0, &cbSubmit);
    11561136
    1157     pvCmd = SvgaReserve(pSvga, cbSubmit, SVGA3D_INVALID_ID);
     1137    pvCmd = SvgaReserve(pSvga, cbSubmit);
    11581138    if (pvCmd)
    11591139    {
    … …  
    12691249                       + sizeof(SVGAFifoCmdUpdate);
    12701250
    1271     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     1251    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    12721252    if (pvCmd)
    12731253    {
    12741254        /** @todo Multi-monitor. */
    12751255        SvgaCmdUpdate(pvCmd, u32X, u32Y, u32Width, u32Height);
    1276         SvgaFifoCommit(pSvga, cbSubmit);
     1256        SvgaCommit(pSvga, cbSubmit);
     1257        SvgaFlush(pSvga);
    12771258    }
    12781259    else
    … …  
    13311312                        NULL, 0, &cbSubmit);
    13321313
    1333     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     1314    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    13341315    if (pvCmd)
    13351316    {
    … …  
    13401321                                     pvCmd, cbSubmit, NULL);
    13411322        Assert(Status == STATUS_SUCCESS);
    1342         SvgaFifoCommit(pSvga, cbSubmit);
     1323        SvgaCommit(pSvga, cbSubmit);
    13431324    }
    13441325    else
    … …  
    13921373                             NULL, 0, &cbSubmit);
    13931374
    1394     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     1375    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    13951376    if (pvCmd)
    13961377    {
    … …  
    14001381                                          pvCmd, cbSubmit, NULL);
    14011382        Assert(Status == STATUS_SUCCESS);
    1402         SvgaFifoCommit(pSvga, cbSubmit);
     1383        SvgaCommit(pSvga, cbSubmit);
    14031384    }
    14041385    else
    … …  
    14601441                       NULL, 0, &cbSubmit);
    14611442
    1462     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     1443    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    14631444    if (pvCmd)
    14641445    {
    … …  
    14661447                                    pvCmd, cbSubmit, NULL);
    14671448        Assert(Status == STATUS_SUCCESS);
    1468         SvgaFifoCommit(pSvga, cbSubmit);
     1449        SvgaCommit(pSvga, cbSubmit);
    14691450    }
    14701451    else
    … …  
    15651546                     NULL, 0, &cbSubmit);
    15661547
    1567     void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     1548    void *pvCmd = SvgaReserve(pSvga, cbSubmit);
    15681549    if (pvCmd)
    15691550    {
    … …  
    15711552                                  pvCmd, cbSubmit, NULL);
    15721553        AssertStmt(Status == STATUS_SUCCESS, cbSubmit = 0);
    1573         SvgaFifoCommit(pSvga, cbSubmit);
     1554        SvgaCommit(pSvga, cbSubmit);
    15741555    }
    15751556    else

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium/Svga.h

    r94622 r94631  
    6565typedef struct VMSVGACBPAGE
    6666{
    67     RTR0MEMOBJ           hMemObj;
     67    RTR0MEMOBJ           hMemObjPages;
     68    RTR0MEMOBJ           hMemObjMapping;
    6869    RTR0PTR              pvR0;
    6970    RTHCPHYS             PhysAddr;
    … …  
    7576typedef enum VMSVGACBTYPE
    7677{
    77     VMSVGACB_INVALID  = 0,
    78     VMSVGACB_CONTEXT_DEVICE = 1,
    79     VMSVGACB_MINIPORT = 2,
    80     VMSVGACB_UMD = 3
     78    VMSVGACB_INVALID = 0,
     79    VMSVGACB_CONTEXT_DEVICE = 1,                   /* SVGA_CB_CONTEXT_DEVICE commands. */
     80    VMSVGACB_MINIPORT = 2,                         /* Commands generated by the miniport. */
     81    VMSVGACB_UMD = 3                               /* WDDM DMA buffer. */
    8182} VMSVGACBTYPE;
    8283
    … …  
    100101        PHYSICAL_ADDRESS DmaBufferPhysicalAddress; /* VMSVGACB_UMD */
    101102    } commands;
     103#ifdef DEBUG
     104    bool fSubmitted : 1;
     105#endif
    102106} VMSVGACB, *PVMSVGACB;
    103107
    … …  
    130134    VMSVGACBHEADERPOOL   HeaderPool;               /* Array of buffer headers. */
    131135    PVMSVGACB            pCBCurrent;               /* Current buffer for miniport commands. */
    132     FAST_MUTEX           CBCurrentMutex;           /* Access pCBCurrent.  KGUARDED_MUTEX? */
     136    FAST_MUTEX           CBCurrentMutex;           /* Access pCBCurrent. */
    133137    KSPIN_LOCK           SpinLock;                 /* Lock for aCBContexts. */
    134138} VMSVGACBSTATE, *PVMSVGACBSTATE;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium/SvgaFifo.cpp

    r94622 r94631  
    8989void *SvgaFifoReserve(PVBOXWDDM_EXT_VMSVGA pSvga, uint32_t cbReserve)
    9090{
     91    Assert(!pSvga->pCBState);
    9192    Assert((cbReserve & 0x3) == 0);
    9293
    … …  
    289290static NTSTATUS svgaCBFreePage(PVMSVGACBPAGE pPage)
    290291{
    291     if (pPage->hMemObj != NIL_RTR0MEMOBJ)
    292     {
    293         int rc = RTR0MemObjFree(pPage->hMemObj, /* fFreeMappings */ true);
    294         AssertReturn(RT_SUCCESS(rc), STATUS_INVALID_PARAMETER);
     292    if (pPage->hMemObjMapping != NIL_RTR0MEMOBJ)
     293    {
     294        int rc = RTR0MemObjFree(pPage->hMemObjMapping, /* fFreeMappings */ true);
     295        Assert(RT_SUCCESS(rc)); RT_NOREF(rc);
     296    }
     297
     298    if (pPage->hMemObjPages != NIL_RTR0MEMOBJ)
     299    {
     300        int rc = RTR0MemObjFree(pPage->hMemObjPages, /* fFreeMappings */ true);
     301        Assert(RT_SUCCESS(rc)); RT_NOREF(rc);
    295302    }
    296303    RT_ZERO(*pPage);
    … …  
    299306
    300307
    301 static NTSTATUS svgaCBAllocPage(PVMSVGACBPAGE pPage)
    302 {
    303     int rc = RTR0MemObjAllocPageTag(&pPage->hMemObj, PAGE_SIZE,
    304                                     /* fExecutable */ false, "WDDMGA");
     308static NTSTATUS svgaCBAllocPage(PVMSVGACBPAGE pPage, uint32_t cb)
     309{
     310    int rc = RTR0MemObjAllocPhysTag(&pPage->hMemObjPages, cb, NIL_RTHCPHYS, "VMSVGACB");
    305311    AssertReturn(RT_SUCCESS(rc), STATUS_INSUFFICIENT_RESOURCES);
    306312
    307     pPage->pvR0     = RTR0MemObjAddress(pPage->hMemObj);
    308     pPage->PhysAddr = RTR0MemObjGetPagePhysAddr(pPage->hMemObj, /* iPage */ 0);
     313    rc = RTR0MemObjMapKernelTag(&pPage->hMemObjMapping, pPage->hMemObjPages, (void *)-1,
     314                                PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE, "VMSVGACB");
     315    AssertReturnStmt(RT_SUCCESS(rc), svgaCBFreePage(pPage), STATUS_INSUFFICIENT_RESOURCES);
     316
     317    pPage->pvR0     = RTR0MemObjAddress(pPage->hMemObjMapping);
     318    pPage->PhysAddr = RTR0MemObjGetPagePhysAddr(pPage->hMemObjPages, /* iPage */ 0);
    309319    return STATUS_SUCCESS;
    310320}
    … …  
    326336    for (unsigned i = 0; i < RT_ELEMENTS(pHeaderPool->aHeaderPoolPages); ++i)
    327337    {
    328         Status = svgaCBAllocPage(&pHeaderPool->aHeaderPoolPages[i]);
     338        Status = svgaCBAllocPage(&pHeaderPool->aHeaderPoolPages[i], PAGE_SIZE);
    329339        AssertBreak(NT_SUCCESS(Status));
    330340    }
    … …  
    372382
    373383    PVMSVGACBPAGE pPage = &pHeaderPool->aHeaderPoolPages[idxPage];
    374     Assert(pPage->hMemObj != NIL_RTR0MEMOBJ);
     384    Assert(pPage->hMemObjMapping != NIL_RTR0MEMOBJ);
    375385
    376386    uint32_t const offPage = (id - idxPage * VMSVGA_CB_HEADER_POOL_HANDLES_PER_PAGE) * sizeof(SVGACBHeader);
    … …  
    384394static NTSTATUS svgaCBFree(PVMSVGACBSTATE pCBState, PVMSVGACB pCB)
    385395{
     396    GALOG(("CB: %p\n", pCB));
    386397    if (pCB->enmType != VMSVGACB_UMD)
    387398        svgaCBFreePage(&pCB->commands.page);
    … …  
    398409 * @param enmType     Kind of the buffer.
    399410 * @param idDXContext DX context of the commands in the buffer.
     411 * @param cbRequired  How many bytes are required for MINIPORT or CONTEXT_DEVICE buffers.
    400412 * @param ppCB        Where to store the allocated buffer pointer.
    401413 */
    402 static NTSTATUS svgaCBAlloc(PVMSVGACBSTATE pCBState, VMSVGACBTYPE enmType, uint32_t idDXContext, PVMSVGACB *ppCB)
     414static NTSTATUS svgaCBAlloc(PVMSVGACBSTATE pCBState, VMSVGACBTYPE enmType, uint32_t idDXContext, uint32_t cbRequired, PVMSVGACB *ppCB)
    403415{
    404416    RT_NOREF(pCBState);
    … …  
    406418    PVMSVGACB pCB = (PVMSVGACB)GaMemAllocZero(sizeof(VMSVGACB));
    407419    AssertReturn(pCB, STATUS_INSUFFICIENT_RESOURCES);
     420    GALOG(("CB: %p\n", pCB));
    408421
    409422    NTSTATUS Status;
    … …  
    417430    if (enmType != VMSVGACB_UMD)
    418431    {
    419         pCB->cbBuffer = PAGE_SIZE;
     432        pCB->cbBuffer = RT_ALIGN_32(cbRequired, PAGE_SIZE);
    420433        pCB->cbCommand = 0;
    421         Status = svgaCBAllocPage(&pCB->commands.page);
     434        Status = svgaCBAllocPage(&pCB->commands.page, pCB->cbBuffer);
    422435        AssertReturnStmt(NT_SUCCESS(Status),
    423436                         GaMemFree(pCB),
    … …  
    456469
    457470    PVMSVGACBSTATE pCBState = pSvga->pCBState;
     471    GALOG(("CB: %p\n", pCB));
    458472
    459473    /* Allocate a header for the buffer. */
    … …  
    465479    pCBHeader->status      = SVGA_CB_STATUS_NONE;
    466480    pCBHeader->errorOffset = 0;
    467     pCBHeader->id          = 0;
     481    if (pCB->enmType != VMSVGACB_UMD)
     482        pCBHeader->id      = 0;
     483    else
     484        pCBHeader->id      = 1; /* An arbitrary not zero value. SVGA_DC_CMD_PREEMPT will preempt such buffers. */
    468485    if (pCB->idDXContext != SVGA3D_INVALID_ID)
    469486        pCBHeader->flags   = SVGA_CB_FLAG_DX_CONTEXT;
    … …  
    478495    pCBHeader->dxContext   = pCB->idDXContext;
    479496    RT_ZERO(pCBHeader->mustBeZero);
     497    Assert(pCBHeader->ptr.pa != 0);
    480498
    481499    /* Select appropriate comamnd buffer context. */
    … …  
    500518        RTListAppend(&pCBCtx->QueueSubmitted, &pCB->nodeQueue);
    501519        ++pCBCtx->cSubmitted;
     520#ifdef DEBUG
     521        Assert(!pCB->fSubmitted);
     522        if (pCB->fSubmitted)
     523            GALOG(("CB: %p already submitted\n", pCB));
     524        pCB->fSubmitted = true;
     525#endif
    502526
    503527        KeReleaseSpinLock(&pCBState->SpinLock, OldIrql);
    … …  
    515539
    516540    PVMSVGACB pCB;
    517     NTSTATUS Status = svgaCBAlloc(pCBState, VMSVGACB_CONTEXT_DEVICE, SVGA3D_INVALID_ID, &pCB);
     541    NTSTATUS Status = svgaCBAlloc(pCBState, VMSVGACB_CONTEXT_DEVICE, SVGA3D_INVALID_ID, cbCmd, &pCB);
    518542    AssertReturn(NT_SUCCESS(Status), Status);
    519543
    … …  
    529553    svgaCBFree(pCBState, pCB);
    530554    return Status;
     555}
     556
     557
     558NTSTATUS SvgaCmdBufSubmitMiniportCommand(PVBOXWDDM_EXT_VMSVGA pSvga, void const *pvCmd, uint32_t cbCmd)
     559{
     560    PVMSVGACBSTATE pCBState = pSvga->pCBState;
     561
     562    PVMSVGACB pCB;
     563    NTSTATUS Status = svgaCBAlloc(pCBState, VMSVGACB_MINIPORT, SVGA3D_INVALID_ID, cbCmd, &pCB);
     564    AssertReturn(NT_SUCCESS(Status), Status);
     565
     566    memcpy(pCB->commands.page.pvR0, pvCmd, cbCmd);
     567    pCB->cbCommand = cbCmd;
     568
     569    return svgaCBSubmit(pSvga, pCB);
    531570}
    532571
    … …  
    570609    {
    571610        /* Allocate a new command buffer. */
    572         Status = svgaCBAlloc(pCBState, VMSVGACB_MINIPORT, idDXContext, &pCBState->pCBCurrent);
     611        Status = svgaCBAlloc(pCBState, VMSVGACB_MINIPORT, idDXContext, cbRequired, &pCBState->pCBCurrent);
    573612        AssertReturnStmt(NT_SUCCESS(Status), ExReleaseFastMutex(&pCBState->CBCurrentMutex), NULL);
    574613        pCB = pCBState->pCBCurrent;
     614        AssertReturnStmt(pCB->cbBuffer - pCB->cbCommand >= cbRequired, ExReleaseFastMutex(&pCBState->CBCurrentMutex), NULL);
    575615    }
    576616
    … …  
    619659 * @param pSvga            The device instance.
    620660 * @param cbReserve        Expected size of the command data.
     661 * @param idDXContext      DX context of the command.
    621662 * @return Pointer to the command data.
    622663 */
    … …  
    678719
    679720    PVMSVGACB pCB = pCBState->pCBCurrent;
     721    GALOG(("CB: %p\n", pCB));
    680722    if (pCB && pCB->cbCommand)
    681723    {
    … …  
    687729
    688730    ExReleaseFastMutex(&pCBState->CBCurrentMutex);
     731}
     732
     733
     734NTSTATUS SvgaCmdBufSubmitUMD(PVBOXWDDM_EXT_VMSVGA pSvga, PVMSVGACB pCB)
     735{
     736    AssertReturn(pCB && pCB->enmType == VMSVGACB_UMD, STATUS_INVALID_PARAMETER);
     737    return svgaCBSubmit(pSvga, pCB);
     738}
     739
     740
     741NTSTATUS SvgaCmdBufAllocUMD(PVBOXWDDM_EXT_VMSVGA pSvga, PHYSICAL_ADDRESS DmaBufferPhysicalAddress,
     742                            uint32_t cbBuffer, uint32_t cbCommands, uint32_t idDXContext, PVMSVGACB *ppCB)
     743{
     744    PVMSVGACBSTATE pCBState = pSvga->pCBState;
     745    NTSTATUS Status = svgaCBAlloc(pCBState, VMSVGACB_UMD, idDXContext, cbBuffer, ppCB);
     746    AssertReturn(NT_SUCCESS(Status), Status);
     747    GALOG(("CB: %p, cbBuffer %d\n", *ppCB, cbBuffer));
     748
     749    (*ppCB)->cbBuffer = cbBuffer;
     750    (*ppCB)->cbCommand = cbCommands;
     751    (*ppCB)->commands.DmaBufferPhysicalAddress = DmaBufferPhysicalAddress;
     752    return STATUS_SUCCESS;
    689753}
    690754
    … …  
    736800                break;
    737801
     802            case SVGA_CB_STATUS_PREEMPTED:
     803                /* Delete the buffer. */
     804                GALOG(("SVGA_CB_STATUS_PREEMPTED %p\n", pIter));
     805                RTListNodeRemove(&pIter->nodeQueue);
     806                svgaCBFree(pCBState, pIter);
     807                break;
     808
    738809            case SVGA_CB_STATUS_NONE:
    739810            case SVGA_CB_STATUS_QUEUE_FULL:
    740811            case SVGA_CB_STATUS_COMMAND_ERROR:
    741812            case SVGA_CB_STATUS_CB_HEADER_ERROR:
    742             case SVGA_CB_STATUS_PREEMPTED:
    743813            case SVGA_CB_STATUS_SUBMISSION_ERROR:
    744814            case SVGA_CB_STATUS_PARTIAL_COMPLETE:

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium/SvgaFifo.h

    r94622 r94631  
    3333
    3434NTSTATUS SvgaCmdBufDeviceCommand(PVBOXWDDM_EXT_VMSVGA pSvga, void const *pvCmd, uint32_t cbCmd);
     35NTSTATUS SvgaCmdBufSubmitMiniportCommand(PVBOXWDDM_EXT_VMSVGA pSvga, void const *pvCmd, uint32_t cbCmd);
    3536
    3637void *SvgaCmdBuf3dCmdReserve(PVBOXWDDM_EXT_VMSVGA pSvga, SVGAFifo3dCmdId enmCmd, uint32_t cbReserve, uint32_t idDXContext);
    … …  
    4142void  SvgaCmdBufProcess(PVBOXWDDM_EXT_VMSVGA pSvga);
    4243
     44NTSTATUS SvgaCmdBufAllocUMD(PVBOXWDDM_EXT_VMSVGA pSvga, PHYSICAL_ADDRESS DmaBufferPhysicalAddress,
     45                            uint32_t cbBuffer, uint32_t cbCommands, uint32_t idDXContext, PVMSVGACB *ppCB);
     46NTSTATUS SvgaCmdBufSubmitUMD(PVBOXWDDM_EXT_VMSVGA pSvga, PVMSVGACB pCB);
     47
     48DECLINLINE(void *) SvgaReserve(PVBOXWDDM_EXT_VMSVGA pSvga, uint32_t cbReserve, uint32_t idDXContext = SVGA3D_INVALID_ID)
     49{
     50    if (pSvga->pCBState)
     51        return SvgaCmdBufReserve(pSvga, cbReserve, idDXContext);
     52    return SvgaFifoReserve(pSvga, cbReserve);
     53}
     54
     55DECLINLINE(void) SvgaCommit(PVBOXWDDM_EXT_VMSVGA pSvga, uint32_t cbActual)
     56{
     57    if (pSvga->pCBState)
     58    {
     59        SvgaCmdBufCommit(pSvga, cbActual);
     60        return;
     61    }
     62    SvgaFifoCommit(pSvga, cbActual);
     63}
     64
     65DECLINLINE(void) SvgaFlush(PVBOXWDDM_EXT_VMSVGA pSvga)
     66{
     67    if (pSvga->pCBState)
     68        SvgaCmdBufFlush(pSvga);
     69}
     70
     71
    4372#endif /* !GA_INCLUDED_SRC_WINNT_Graphics_Video_mp_wddm_gallium_SvgaFifo_h */

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium/VBoxMPGaWddm.cpp

    r94622 r94631  
    327327    memset(&notify, 0, sizeof(notify));
    328328
    329     GALOG(("%d fence %d\n", enmType, uFenceId));
    330329    switch (enmType)
    331330    {
    332331        case DXGK_INTERRUPT_DMA_COMPLETED:
     332            GALOG(("COMPLETED fence %d\n", uFenceId));
    333333            notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
    334334            notify.DmaCompleted.SubmissionFenceId = uFenceId;
    … …  
    337337
    338338        case DXGK_INTERRUPT_DMA_PREEMPTED:
     339            GALOG(("PREEMPTED fence %d, %d\n", uFenceId, uLastCompletedFenceId));
    339340            notify.InterruptType = DXGK_INTERRUPT_DMA_PREEMPTED;
    340341            notify.DmaPreempted.PreemptionFenceId = uFenceId;
    … …  
    344345
    345346        case DXGK_INTERRUPT_DMA_FAULTED:
     347            GALOG(("COMPLETED fence %d\n", uFenceId));
    346348            notify.InterruptType = DXGK_INTERRUPT_DMA_FAULTED;
    347349            notify.DmaFaulted.FaultedFenceId = uFenceId;
    … …  
    676678    PVBOXWDDM_DEVICE pDevice = pContext->pDevice;
    677679    PVBOXMP_DEVEXT pDevExt = pDevice->pAdapter;
     680
     681    SvgaFlush(pDevExt->pGa->hw.pSvga);
    678682
    679683    DXGK_ALLOCATIONLIST *pSrc =  &pPresent->pAllocationList[DXGK_PRESENT_SOURCE_INDEX];
    … …  
    913917    VBOXWDDM_EXT_GA *pGaDevExt = pDevExt->pGa;
    914918
     919    SvgaFlush(pDevExt->pGa->hw.pSvga);
     920
    915921    AssertReturn(pContext && pContext->enmType == VBOXWDDM_CONTEXT_TYPE_GA_3D, STATUS_INVALID_PARAMETER);
    916922    AssertReturn(pRender->CommandLength > pRender->MultipassOffset, STATUS_INVALID_PARAMETER);
    … …  
    10601066    NTSTATUS Status = STATUS_SUCCESS;
    10611067    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter;
     1068
     1069    SvgaFlush(pDevExt->pGa->hw.pSvga);
    10621070
    10631071    GALOG(("DmaBufferPrivateData %p/%d, DmaBuffer %p/%d\n",
    … …  
    12351243NTSTATUS APIENTRY GaDxgkDdiPatch(const HANDLE hAdapter, const DXGKARG_PATCH *pPatch)
    12361244{
    1237     RT_NOREF2(hAdapter, pPatch);
    1238     /* Nothing to do. */
     1245    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter;
     1246
     1247    SvgaFlush(pDevExt->pGa->hw.pSvga);
     1248
     1249    GALOG(("\n"));
    12391250
    12401251    uint8_t *pu8DMABuffer = (uint8_t *)pPatch->pDmaBuffer + pPatch->DmaBufferSubmissionStartOffset;
    … …  
    13131324    while (cDataBlocks--)
    13141325    {
     1326        GALOG(("pRenderData %p: u32DataType %u, pvDmaBuffer %p, cbData %u\n",
     1327                pRenderData, pRenderData->u32DataType, pRenderData->pvDmaBuffer, pRenderData->cbData));
    13151328        AssertReturn(cbDmaBufferSubmission >= pRenderData->cbData, STATUS_INVALID_PARAMETER);
    13161329        cbDmaBufferSubmission -= pRenderData->cbData;
    … …  
    13571370        }
    13581371
    1359         if (pvDmaBuffer)
     1372        if (pGaDevExt->hw.pSvga->pCBState)
     1373        {
     1374            if (pRenderData->cbData && pvDmaBuffer)
     1375            {
     1376                PVMSVGACB pCB;
     1377                NTSTATUS Status = SvgaCmdBufAllocUMD(pGaDevExt->hw.pSvga, pSubmitCommand->DmaBufferPhysicalAddress,
     1378                                                     pSubmitCommand->DmaBufferSize, pRenderData->cbData,
     1379                                                     SVGA3D_INVALID_ID, &pCB);
     1380                GALOG(("Allocated UMD buffer %p\n", pCB));
     1381                if (NT_SUCCESS(Status))
     1382                {
     1383                    Status = SvgaCmdBufSubmitUMD(pGaDevExt->hw.pSvga, pCB);
     1384                    Assert(NT_SUCCESS(Status)); RT_NOREF(Status);
     1385                }
     1386            }
     1387        }
     1388        else if (pvDmaBuffer)
    13601389        {
    13611390            Assert(pSubmitCommand->DmaBufferSegmentId == 0);
    … …  
    14031432
    14041433    /* Submit the fence. */
    1405     SvgaFence(pGaDevExt->hw.pSvga, pSubmitCommand->SubmissionFenceId);
     1434    if (pGaDevExt->hw.pSvga->pCBState)
     1435    {
     1436        struct
     1437        {
     1438            uint32_t id;
     1439            uint32_t fence;
     1440        } fence;
     1441        fence.id = SVGA_CMD_FENCE;
     1442        fence.fence = pSubmitCommand->SubmissionFenceId;
     1443        SvgaCmdBufSubmitMiniportCommand(pGaDevExt->hw.pSvga, &fence, sizeof(fence));
     1444    }
     1445    else
     1446        SvgaFence(pGaDevExt->hw.pSvga, pSubmitCommand->SubmissionFenceId);
    14061447
    14071448    GALOG(("done %d\n", pSubmitCommand->SubmissionFenceId));
    … …  
    15721613    }
    15731614
    1574     /* We can not safely remove submitted data from FIFO, so just let the host process all submitted commands.
    1575      */
    15761615    const uint32_t u32LastCompletedFenceId = ASMAtomicReadU32(&pGaDevExt->u32LastCompletedFenceId);
    15771616    const uint32_t u32LastSubmittedFenceId = ASMAtomicReadU32(&pGaDevExt->u32LastSubmittedFenceId);
    15781617    if (u32LastCompletedFenceId == u32LastSubmittedFenceId)
    15791618    {
     1619        /* "the hardware is already finished processing all of the submitted DMA buffers" */
    15801620        GAPREEMPTCOMMANDCBCTX Ctx;
    15811621        Ctx.pDevExt = pDevExt;
    … …  
    15911631    else
    15921632    {
    1593         /* Submit the fence. */
    1594         Assert(pGaDevExt->u32PreemptionFenceId == 0);
    1595         ASMAtomicWriteU32(&pGaDevExt->u32PreemptionFenceId, pPreemptCommand->PreemptionFenceId);
    1596         Status = SvgaFence(pGaDevExt->hw.pSvga, pPreemptCommand->PreemptionFenceId);
     1633        if (pGaDevExt->hw.pSvga->pCBState)
     1634        {
     1635#if 0 /** @todo later */
     1636            struct
     1637            {
     1638                uint32_t id;
     1639                SVGADCCmdPreempt cmd;
     1640            } cmd;
     1641            cmd.id = SVGA_DC_CMD_PREEMPT;
     1642            cmd.cmd.context = SVGA_CB_CONTEXT_0;
     1643            cmd.cmd.ignoreIDZero = 1; /* Preempt only the UMD buffers. */
     1644            Status = SvgaCmdBufDeviceCommand(pGaDevExt->hw.pSvga, &cmd, sizeof(cmd));
     1645            AssertReturn(NT_SUCCESS(Status), Status);
     1646#endif
     1647
     1648            Assert(pGaDevExt->u32PreemptionFenceId == 0);
     1649            ASMAtomicWriteU32(&pGaDevExt->u32PreemptionFenceId, pPreemptCommand->PreemptionFenceId);
     1650
     1651            struct
     1652            {
     1653                uint32_t id;
     1654                uint32_t fence;
     1655            } fence;
     1656            fence.id = SVGA_CMD_FENCE;
     1657            fence.fence = pPreemptCommand->PreemptionFenceId;
     1658            Status = SvgaCmdBufSubmitMiniportCommand(pGaDevExt->hw.pSvga, &fence, sizeof(fence));
     1659        }
     1660        else
     1661        {
     1662            /* We can not safely remove submitted data from FIFO, so just let the host process all submitted commands.
     1663             */
     1664            /* Submit the fence. */
     1665            Assert(pGaDevExt->u32PreemptionFenceId == 0);
     1666            ASMAtomicWriteU32(&pGaDevExt->u32PreemptionFenceId, pPreemptCommand->PreemptionFenceId);
     1667            Status = SvgaFence(pGaDevExt->hw.pSvga, pPreemptCommand->PreemptionFenceId);
     1668        }
    15971669    }
    15981670
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette