VirtualBox

Changeset 50859 in vbox


Ignore:
Timestamp:
Mar 25, 2014 10:46:17 AM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
92950
Message:

wddm: remaining bits for new command submission

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/VBoxVideo.h

    r50831 r50859  
    17811781} VBOXCMDVBVA_3DCTL_CMD;
    17821782
     1783typedef struct VBOXCMDVBVA_CTL_3DCTL_CMD
     1784{
     1785    VBOXCMDVBVA_CTL Hdr;
     1786    VBOXCMDVBVA_3DCTL_CMD Cmd;
     1787} VBOXCMDVBVA_CTL_3DCTL_CMD;
     1788
     1789typedef struct VBOXCMDVBVA_CTL_3DCTL_CONNECT
     1790{
     1791    VBOXCMDVBVA_CTL Hdr;
     1792    VBOXCMDVBVA_3DCTL_CONNECT Connect;
     1793} VBOXCMDVBVA_CTL_3DCTL_CONNECT;
     1794
     1795typedef struct VBOXCMDVBVA_CTL_3DCTL
     1796{
     1797    VBOXCMDVBVA_CTL Hdr;
     1798    VBOXCMDVBVA_3DCTL Ctl;
     1799} VBOXCMDVBVA_CTL_3DCTL;
     1800
    17831801#pragma pack()
    17841802

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

    r50095 r50859  
    222222    CRVBOXHGSMIWRITE Cmd;
    223223} VBOXMP_CRHGSMICMD_WRITE, *PVBOXMP_CRHGSMICMD_WRITE;
     224
     225
     226#define VBOXMP_CRSHGSMICON_CMD_CMDBUF_OFFSET(_cBuffers) VBOXWDDM_ROUNDBOUND(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[_cBuffers]), 8)
     227#define VBOXMP_CRSHGSMICON_CMD_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf) ( VBOXMP_CRSHGSMICON_CMD_CMDBUF_OFFSET(_cBuffers) + VBOXWDDM_ROUNDBOUND(_cbCmdBuf, 8))
     228#define VBOXMP_CRSHGSMICON_CMD_GET_CMDBUF(_pCmd, _cBuffers, _type) ((_type*)(((uint8_t*)(_pCmd)) + VBOXMP_CRSHGSMICON_CMD_CMDBUF_OFFSET(_cBuffers)))
     229#define VBOXMP_CRSHGSMICON_CMD_GET_CMDCTX(_pCmd, _cBuffers, _cbCmdBuf, _type) ((_type*)(((uint8_t*)(_pCmd)) +  VBOXMP_CRSHGSMICON_CMD_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)))
     230#define VBOXMP_CRSHGSMICON_CMD_GET_FROM_CMDCTX(_pCtx, _cBuffers, _cbCmdBuf, _type) ((_type*)(((uint8_t*)(_pCtx)) -  VBOXMP_CRSHGSMICON_CMD_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)))
     231#define VBOXMP_CRSHGSMICON_CMD_SIZE(_cBuffers, _cbCmdBuf, _cbCtx) (VBOXMP_CRSHGSMICON_CMD_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf) + (_cbCtx))
     232
    224233
    225234#define VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) VBOXWDDM_ROUNDBOUND((VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[_cBuffers]))), 8)
    … …  
    467476}
    468477
    469 static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportSendWriteAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd, PVOID pvContext)
     478static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportVdmaSendWriteAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd, PVOID pvContext)
    470479{
    471480    /* we should be called from our DPC routine */
    … …  
    505514}
    506515
     516static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportVbvaSendWriteAsyncCompletion(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext)
     517{
     518    /* we should be called from our DPC routine */
     519    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
     520
     521    PVBOXMP_CRSHGSMITRANSPORT pCon;
     522    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
     523    VBOXCMDVBVA_CRCMD_CMD *pCmd;
     524    int rc = VBoxCmdVbvaConCmdCompletionData(pvCmd, &pCmd);
     525    const UINT cBuffers = 2;
     526    Assert(pCmd->cBuffers == cBuffers);
     527    PVBOXMP_CRHGSMICMD_WRITE pWrData = VBOXMP_CRSHGSMICON_CMD_GET_CMDBUF(pCmd, cBuffers, VBOXMP_CRHGSMICMD_WRITE);
     528    uint64_t *pu64Completion = (uint64_t*)(pWrData + 1);
     529    PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion = (PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION)(*pu64Completion);
     530
     531    if (!RT_SUCCESS(rc))
     532        WARN(("CRVBOXHGSMIWRITE failed, rc %d", rc));
     533
     534    if (pfnCompletion)
     535        pfnCompletion(pCon, rc, (void*)(pu64Completion+1));
     536}
     537
    507538void* VBoxMpCrShgsmiTransportCmdCreateWriteReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
    508539        PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
    … …  
    571602}
    572603
    573 void* VBoxMpCrShgsmiTransportCmdCreateWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
     604static void * vboxMpCrShgsmiTransportCmdVbvaCreateWriteAsync(PVBOXMP_DEVEXT pDevExt, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer, PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
     605{
     606    const uint32_t cBuffers = 2;
     607    const uint32_t cbCmd = VBOXMP_CRSHGSMICON_CMD_SIZE(cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITE) + 8, cbContextData);
     608    VBOXCMDVBVA_CRCMD_CMD* pCmd = VBoxCmdVbvaConCmdAlloc(pDevExt, cbCmd);
     609    if (!pCmd)
     610    {
     611        WARN(("VBoxCmdVbvaConCmdAlloc failed"));
     612        return NULL;
     613    }
     614
     615    pCmd->cBuffers = cBuffers;
     616
     617    PVBOXMP_CRHGSMICMD_WRITE pWrData = VBOXMP_CRSHGSMICON_CMD_GET_CMDBUF(pCmd, cBuffers, VBOXMP_CRHGSMICMD_WRITE);
     618    CRVBOXHGSMIWRITE *pCmdWrite = &pWrData->Cmd;
     619
     620    pCmdWrite->hdr.result      = VERR_WRONG_ORDER;
     621    pCmdWrite->hdr.u32ClientID = u32ClientID;
     622    pCmdWrite->hdr.u32Function = SHCRGL_GUEST_FN_WRITE;
     623    //    pCmdWrite->hdr.u32Reserved = 0;
     624    pCmdWrite->iBuffer = 1;
     625
     626    VBOXCMDVBVA_CRCMD_BUFFER *pBufCmd = &pCmd->aBuffers[0];
     627    pBufCmd->offBuffer = (VBOXCMDVBVAOFFSET)vboxMpCrShgsmiBufferOffset(pDevExt, pCmdWrite);
     628    pBufCmd->cbBuffer = sizeof (*pCmdWrite);
     629
     630    pBufCmd = &pCmd->aBuffers[1];
     631    pBufCmd->offBuffer = (VBOXCMDVBVAOFFSET)vboxMpCrShgsmiBufferOffset(pDevExt, pvBuffer);
     632    pBufCmd->cbBuffer = cbBuffer;
     633
     634    uint64_t*pu64Completion = VBOXMP_CRSHGSMICON_CMD_GET_CMDCTX(pCmd, cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITE), uint64_t);
     635    *pu64Completion = (uint64_t)pfnCompletion;
     636    return (void*)(pu64Completion+1);
     637}
     638
     639void* vboxMpCrShgsmiTransportCmdVdmaCreateWriteAsync(PVBOXMP_DEVEXT pDevExt, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
    574640        PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
    575641{
    576642    const uint32_t cBuffers = 2;
    577643    const uint32_t cbCmd = VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITE), cbContextData);
    578     PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
    579644    PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
    580645    if (!pDr)
    … …  
    612677
    613678    pBufCmd = &pBody->aBuffers[1];
    614     pBufCmd->offBuffer = vboxMpCrShgsmiTransportBufOffset(pCon, pvBuffer);
     679    pBufCmd->offBuffer = vboxMpCrShgsmiBufferOffset(pDevExt, pvBuffer);
    615680    pBufCmd->cbBuffer = cbBuffer;
    616681    pBufCmd->u32GuestData = 0;
    … …  
    620685}
    621686
     687void* VBoxMpCrShgsmiTransportCmdCreateWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
     688        PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
     689{
     690    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
     691    if (pDevExt->fCmdVbvaEnabled)
     692        return vboxMpCrShgsmiTransportCmdVbvaCreateWriteAsync(pDevExt, u32ClientID, pvBuffer, cbBuffer, pfnCompletion, cbContextData);
     693    return vboxMpCrShgsmiTransportCmdVdmaCreateWriteAsync(pDevExt, u32ClientID, pvBuffer, cbBuffer, pfnCompletion, cbContextData);
     694}
     695
    622696int VBoxMpCrShgsmiTransportCmdSubmitWriteReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
    623697{
    … …  
    626700}
    627701
     702static int vboxMpCrShgsmiTransportCmdVdmaSubmitWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
     703{
     704    VBOXVDMACMD* pHdr = VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_WRITE));
     705    return vboxMpCrShgsmiTransportCmdSubmitDmaCmd(pCon, pHdr, vboxMpCrShgsmiTransportVdmaSendWriteAsyncCompletion);
     706}
     707
     708static int vboxMpCrShgsmiTransportCmdVbvaSubmitWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
     709{
     710    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
     711    VBOXCMDVBVA_CRCMD_CMD* pCmd = VBOXMP_CRSHGSMICON_CMD_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_WRITE) + 8, VBOXCMDVBVA_CRCMD_CMD);
     712    return VBoxCmdVbvaConCmdSubmitAsync(pDevExt, pCmd, vboxMpCrShgsmiTransportVbvaSendWriteAsyncCompletion, pCon);
     713}
     714
    628715int VBoxMpCrShgsmiTransportCmdSubmitWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
    629716{
    630     VBOXVDMACMD* pHdr = VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_WRITE));
    631     return vboxMpCrShgsmiTransportCmdSubmitDmaCmd(pCon, pHdr, vboxMpCrShgsmiTransportSendWriteAsyncCompletion);
     717    if (pCon->pDevExt->fCmdVbvaEnabled)
     718        return vboxMpCrShgsmiTransportCmdVbvaSubmitWriteAsync(pCon, pvContext);
     719    return vboxMpCrShgsmiTransportCmdVdmaSubmitWriteAsync(pCon, pvContext);
    632720}
    633721
    … …  
    638726}
    639727
    640 void VBoxMpCrShgsmiTransportCmdTermWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
     728static void vboxMpCrShgsmiTransportCmdVbvaTermWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
     729{
     730    VBOXCMDVBVA_CRCMD_CMD* pCmd = VBOXMP_CRSHGSMICON_CMD_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_WRITE) + 8, VBOXCMDVBVA_CRCMD_CMD);
     731    VBoxCmdVbvaConCmdFree(pCon->pDevExt, pCmd);
     732}
     733
     734static void vboxMpCrShgsmiTransportCmdVdmaTermWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
    641735{
    642736    VBOXVDMACMD* pHdr = VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_WRITE));
    643737    vboxMpCrShgsmiTransportCmdTermDmaCmd(pCon, pHdr);
     738}
     739
     740void VBoxMpCrShgsmiTransportCmdTermWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
     741{
     742    if (pCon->pDevExt->fCmdVbvaEnabled)
     743        vboxMpCrShgsmiTransportCmdVbvaTermWriteAsync(pCon, pvContext);
     744    else
     745        vboxMpCrShgsmiTransportCmdVdmaTermWriteAsync(pCon, pvContext);
    644746}
    645747
    … …  
    778880}
    779881
    780 int VBoxMpCrCtlConConnect(PVBOXMP_CRCTLCON pCrCtlCon,
     882int VBoxMpCrCtlConConnectHgcm(PVBOXMP_CRCTLCON pCrCtlCon,
    781883        uint32_t crVersionMajor, uint32_t crVersionMinor,
    782884        uint32_t *pu32ClientID)
    … …  
    825927}
    826928
    827 int VBoxMpCrCtlConDisconnect(PVBOXMP_CRCTLCON pCrCtlCon, uint32_t u32ClientID)
     929int VBoxMpCrCtlConConnectVbva(PVBOXMP_DEVEXT pDevExt, PVBOXMP_CRCTLCON pCrCtlCon,
     930        uint32_t crVersionMajor, uint32_t crVersionMinor,
     931        uint32_t *pu32ClientID)
     932{
     933    if (pCrCtlCon->hCrCtl)
     934    {
     935        WARN(("pCrCtlCon is HGCM connection"));
     936        return VERR_INVALID_STATE;
     937    }
     938
     939    Assert(!pCrCtlCon->cCrCtlRefs);
     940    return VBoxCmdVbvaConConnect(pDevExt, &pDevExt->CmdVbva,
     941            crVersionMajor, crVersionMinor,
     942            pu32ClientID);
     943}
     944
     945int VBoxMpCrCtlConConnect(PVBOXMP_DEVEXT pDevExt, PVBOXMP_CRCTLCON pCrCtlCon,
     946        uint32_t crVersionMajor, uint32_t crVersionMinor,
     947        uint32_t *pu32ClientID)
     948{
     949    if (pDevExt->fCmdVbvaEnabled)
     950    {
     951        return VBoxMpCrCtlConConnectVbva(pDevExt, pCrCtlCon,
     952                crVersionMajor, crVersionMinor,
     953                pu32ClientID);
     954    }
     955    return VBoxMpCrCtlConConnectHgcm(pCrCtlCon,
     956            crVersionMajor, crVersionMinor,
     957            pu32ClientID);
     958}
     959
     960int VBoxMpCrCtlConDisconnectHgcm(PVBOXMP_CRCTLCON pCrCtlCon, uint32_t u32ClientID)
    828961{
    829962    int rc = vboxCrCtlConDisconnect(pCrCtlCon->hCrCtl, u32ClientID);
    … …  
    838971    }
    839972    return rc;
     973}
     974
     975int VBoxMpCrCtlConDisconnectVbva(PVBOXMP_DEVEXT pDevExt, PVBOXMP_CRCTLCON pCrCtlCon, uint32_t u32ClientID)
     976{
     977    Assert(!pCrCtlCon->hCrCtl);
     978    Assert(!pCrCtlCon->cCrCtlRefs);
     979    return VBoxCmdVbvaConDisconnect(pDevExt, &pDevExt->CmdVbva, u32ClientID);
     980}
     981
     982int VBoxMpCrCtlConDisconnect(PVBOXMP_DEVEXT pDevExt, PVBOXMP_CRCTLCON pCrCtlCon, uint32_t u32ClientID)
     983{
     984    if (!pCrCtlCon->hCrCtl)
     985        return VBoxMpCrCtlConDisconnectVbva(pDevExt, pCrCtlCon, u32ClientID);
     986    return VBoxMpCrCtlConDisconnectHgcm(pCrCtlCon, u32ClientID);
    840987}
    841988
    … …  
    8681015    VBOXMP_CRCTLCON CrCtlCon = {0};
    8691016    uint32_t u32ClientID = 0;
    870     int rc = VBoxMpCrCtlConConnect(&CrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &u32ClientID);
     1017    int rc = VBoxMpCrCtlConConnectHgcm(&CrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &u32ClientID);
    8711018    if (RT_FAILURE(rc))
    8721019    {
    873         LOGREL(("VBoxMpCrCtlConConnect failed with rc(%d), 3D not supported!"));
     1020        LOGREL(("VBoxMpCrCtlConConnectHgcm failed with rc(%d), 3D not supported!"));
    8741021        return;
    8751022    }
    … …  
    8881035#endif
    8891036
    890     rc = VBoxMpCrCtlConDisconnect(&CrCtlCon, u32ClientID);
     1037    rc = VBoxMpCrCtlConDisconnectHgcm(&CrCtlCon, u32ClientID);
    8911038    if (RT_FAILURE(rc))
    892         WARN(("VBoxMpCrCtlConDisconnect failed rc (%d), ignoring..", rc));
     1039        WARN(("VBoxMpCrCtlConDisconnectHgcm failed rc (%d), ignoring..", rc));
    8931040#endif
    8941041}

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

    r49244 r50859  
    3232bool VBoxMpCrCtlConIs3DSupported();
    3333
    34 int VBoxMpCrCtlConConnect(PVBOXMP_CRCTLCON pCrCtlCon,
     34int VBoxMpCrCtlConConnect(PVBOXMP_DEVEXT pDevExt, PVBOXMP_CRCTLCON pCrCtlCon,
    3535        uint32_t crVersionMajor, uint32_t crVersionMinor,
    3636        uint32_t *pu32ClientID);
    37 int VBoxMpCrCtlConDisconnect(PVBOXMP_CRCTLCON pCrCtlCon, uint32_t u32ClientID);
     37int VBoxMpCrCtlConDisconnect(PVBOXMP_DEVEXT pDevExt, PVBOXMP_CRCTLCON pCrCtlCon, uint32_t u32ClientID);
    3838int VBoxMpCrCtlConCall(PVBOXMP_CRCTLCON pCrCtlCon, struct VBoxGuestHGCMCallInfo *pData, uint32_t cbData);
    3939int VBoxMpCrCtlConCallUserData(PVBOXMP_CRCTLCON pCrCtlCon, struct VBoxGuestHGCMCallInfo *pData, uint32_t cbData);
    4040
    4141# include <cr_pack.h>
    42 
    43 typedef struct VBOXMP_CRDATACON
    44 {
    45     PVBOXMP_CRCTLCON pCtl;
    46     uint32_t u32ClientID;
    47 } VBOXMP_CRDATACON, *PVBOXMP_CRDATACON;
    48 
    49 DECLINLINE(int) VBoxMpCrDataConCreate(PVBOXMP_CRDATACON pDataCon, PVBOXMP_CRCTLCON pCtlCon)
    50 {
    51     int rc = VBoxMpCrCtlConConnect(pCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pDataCon->u32ClientID);
    52     if (RT_SUCCESS(rc))
    53     {
    54         Assert(pDataCon->u32ClientID);
    55         pDataCon->pCtl = pCtlCon;
    56         return VINF_SUCCESS;
    57     }
    58     WARN(("VBoxMpCrCtlConConnect failed, rc %d", rc));
    59     return rc;
    60 }
    61 
    62 DECLINLINE(int) VBoxMpCrDataConDestroy(PVBOXMP_CRDATACON pDataCon)
    63 {
    64     int rc = VBoxMpCrCtlConDisconnect(pDataCon->pCtl, pDataCon->u32ClientID);
    65     if (RT_SUCCESS(rc))
    66     {
    67         /* sanity */
    68         pDataCon->pCtl = NULL;
    69         pDataCon->u32ClientID = 0;
    70         return VINF_SUCCESS;
    71     }
    72     WARN(("VBoxMpCrCtlConDisconnect failed, rc %d", rc));
    73     return rc;
    74 }
    7542
    7643typedef struct VBOXMP_CRSHGSMICON_BUFDR

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

    r50482 r50859  
    235235            void *pvCallback = (void*)pCur->u64Info2;
    236236
    237             pfnCallback(pHeap, VBoxSHGSMIBufferData(pCur), pvCallback, &pfnCompletion, &pvCompletion);
     237            pfnCompletion = pfnCallback(pHeap, VBoxSHGSMIBufferData(pCur), pvCallback, &pvCompletion);
    238238            if (pfnCompletion)
    239239            {

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

    r50482 r50859  
    3434typedef FNVBOXSHGSMICMDCOMPLETION *PFNVBOXSHGSMICMDCOMPLETION;
    3535
    36 typedef DECLCALLBACK(void) FNVBOXSHGSMICMDCOMPLETION_IRQ(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext,
    37                                         PFNVBOXSHGSMICMDCOMPLETION *ppfnCompletion, void **ppvCompletion);
     36typedef DECLCALLBACK(PFNVBOXSHGSMICMDCOMPLETION) FNVBOXSHGSMICMDCOMPLETION_IRQ(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext, void **ppvCompletion);
    3837typedef FNVBOXSHGSMICMDCOMPLETION_IRQ *PFNVBOXSHGSMICMDCOMPLETION_IRQ;
    3938

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

    r50831 r50859  
    172172}
    173173
    174 static int vboxCmdVbvaCtlSubmitAsync(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, VBOXCMDVBVA_CTL * pCtl, PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletionIrq, void *pvCompletionIrq)
    175 {
    176     const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepAsynchIrq(&pHGSMICtx->heapCtx, pCtl, pfnCompletionIrq, pvCompletionIrq, VBOXSHGSMI_FLAG_GH_ASYNCH_FORCE);
    177     if (!pHdr)
    178     {
    179         WARN(("VBoxSHGSMICommandPrepAsynchIrq returnd NULL"));
    180         return VERR_INVALID_PARAMETER;
    181     }
    182 
     174static int vboxCmdVbvaCtlSubmitAsync(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, VBOXCMDVBVA_CTL * pCtl, FNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion)
     175{
     176    const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepAsynch(&pHGSMICtx->heapCtx, pCtl, pfnCompletion, pvCompletion, 0);
    183177    HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&pHGSMICtx->heapCtx, pHdr);
    184178    if (offCmd == HGSMIOFFSET_VOID)
    … …  
    11271121}
    11281122
     1123int vboxCmdVbvaConConnect(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx,
     1124        uint32_t crVersionMajor, uint32_t crVersionMinor,
     1125        uint32_t *pu32ClientID)
     1126{
     1127    VBOXCMDVBVA_CTL_3DCTL_CONNECT *pConnect = (VBOXCMDVBVA_CTL_3DCTL_CONNECT*)vboxCmdVbvaCtlCreate(pHGSMICtx, sizeof (VBOXCMDVBVA_CTL_3DCTL_CONNECT));
     1128    if (!pConnect)
     1129    {
     1130        WARN(("vboxCmdVbvaCtlCreate failed"));
     1131        return VERR_OUT_OF_RESOURCES;
     1132    }
     1133    pConnect->Hdr.u32Type = VBOXCMDVBVACTL_TYPE_3DCTL;
     1134    pConnect->Hdr.i32Result = VERR_NOT_SUPPORTED;
     1135    pConnect->Connect.Hdr.u32Type = VBOXCMDVBVA3DCTL_TYPE_CONNECT;
     1136    pConnect->Connect.Hdr.u32CmdClientId = 0;
     1137    pConnect->Connect.u32MajorVersion = crVersionMajor;
     1138    pConnect->Connect.u32MinorVersion = crVersionMinor;
     1139    pConnect->Connect.u64Pid = (uint64_t)PsGetCurrentProcessId();
     1140
     1141    int rc = vboxCmdVbvaCtlSubmitSync(pHGSMICtx, &pConnect->Hdr);
     1142    if (RT_SUCCESS(rc))
     1143    {
     1144        rc = pConnect->Hdr.i32Result;
     1145        if (RT_SUCCESS(rc))
     1146            *pu32ClientID = pConnect->Connect.Hdr.u32CmdClientId;
     1147        else
     1148            WARN(("VBOXCMDVBVA3DCTL_TYPE_CONNECT Disable failed %d", rc));
     1149    }
     1150    else
     1151        WARN(("vboxCmdVbvaCtlSubmitSync returnd %d", rc));
     1152
     1153    vboxCmdVbvaCtlFree(pHGSMICtx, &pConnect->Hdr);
     1154
     1155    return rc;
     1156}
     1157
     1158int vboxCmdVbvaConDisconnect(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, uint32_t u32ClientID)
     1159{
     1160    VBOXCMDVBVA_CTL_3DCTL *pDisconnect = (VBOXCMDVBVA_CTL_3DCTL*)vboxCmdVbvaCtlCreate(pHGSMICtx, sizeof (VBOXCMDVBVA_CTL_3DCTL));
     1161    if (!pDisconnect)
     1162    {
     1163        WARN(("vboxCmdVbvaCtlCreate failed"));
     1164        return VERR_OUT_OF_RESOURCES;
     1165    }
     1166    pDisconnect->Hdr.u32Type = VBOXCMDVBVACTL_TYPE_3DCTL;
     1167    pDisconnect->Hdr.i32Result = VERR_NOT_SUPPORTED;
     1168    pDisconnect->Ctl.u32Type = VBOXCMDVBVA3DCTL_TYPE_DISCONNECT;
     1169    pDisconnect->Ctl.u32CmdClientId = u32ClientID;
     1170
     1171    int rc = vboxCmdVbvaCtlSubmitSync(pHGSMICtx, &pDisconnect->Hdr);
     1172    if (RT_SUCCESS(rc))
     1173    {
     1174        rc = pDisconnect->Hdr.i32Result;
     1175        if (!RT_SUCCESS(rc))
     1176            WARN(("VBOXCMDVBVA3DCTL_TYPE_DISCONNECT Disable failed %d", rc));
     1177    }
     1178    else
     1179        WARN(("vboxCmdVbvaCtlSubmitSync returnd %d", rc));
     1180
     1181    vboxCmdVbvaCtlFree(pHGSMICtx, &pDisconnect->Hdr);
     1182
     1183    return rc;
     1184}
     1185
     1186int VBoxCmdVbvaConConnect(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva,
     1187        uint32_t crVersionMajor, uint32_t crVersionMinor,
     1188        uint32_t *pu32ClientID)
     1189{
     1190    return vboxCmdVbvaConConnect(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, crVersionMajor, crVersionMinor, pu32ClientID);
     1191}
     1192
     1193int VBoxCmdVbvaConDisconnect(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, uint32_t u32ClientID)
     1194{
     1195    return vboxCmdVbvaConDisconnect(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, u32ClientID);
     1196}
     1197
     1198VBOXCMDVBVA_CRCMD_CMD* vboxCmdVbvaConCmdAlloc(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, uint32_t cbCmd)
     1199{
     1200    VBOXCMDVBVA_CTL_3DCTL_CMD *pCmd = (VBOXCMDVBVA_CTL_3DCTL_CMD*)vboxCmdVbvaCtlCreate(pHGSMICtx, sizeof (VBOXCMDVBVA_CTL_3DCTL_CMD) + cbCmd);
     1201    if (!pCmd)
     1202    {
     1203        WARN(("vboxCmdVbvaCtlCreate failed"));
     1204        return NULL;
     1205    }
     1206    pCmd->Hdr.u32Type = VBOXCMDVBVACTL_TYPE_3DCTL;
     1207    pCmd->Hdr.i32Result = VERR_NOT_SUPPORTED;
     1208    pCmd->Cmd.Hdr.u32Type = VBOXCMDVBVA3DCTL_TYPE_CMD;
     1209    pCmd->Cmd.Hdr.u32CmdClientId = 0;
     1210    pCmd->Cmd.Cmd.u8OpCode = VBOXCMDVBVA_OPTYPE_CRCMD;
     1211    pCmd->Cmd.Cmd.u8Flags = 0;
     1212    pCmd->Cmd.Cmd.u8State = VBOXCMDVBVA_STATE_SUBMITTED;
     1213    pCmd->Cmd.Cmd.u.i8Result = -1;
     1214    pCmd->Cmd.Cmd.u32FenceID = 0;
     1215
     1216    return (VBOXCMDVBVA_CRCMD_CMD*)(pCmd+1);
     1217}
     1218
     1219void vboxCmdVbvaConCmdFree(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, VBOXCMDVBVA_CRCMD_CMD *pCmd)
     1220{
     1221    VBOXCMDVBVA_CTL_3DCTL_CMD *pHdr = ((VBOXCMDVBVA_CTL_3DCTL_CMD*)pCmd)-1;
     1222    vboxCmdVbvaCtlFree(pHGSMICtx, &pHdr->Hdr);
     1223}
     1224
     1225int vboxCmdVbvaConSubmitAsync(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, VBOXCMDVBVA_CRCMD_CMD* pCmd, FNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion)
     1226{
     1227    VBOXCMDVBVA_CTL_3DCTL_CMD *pHdr = ((VBOXCMDVBVA_CTL_3DCTL_CMD*)pCmd)-1;
     1228    return vboxCmdVbvaCtlSubmitAsync(pHGSMICtx, &pHdr->Hdr, pfnCompletion, pvCompletion);
     1229}
     1230
     1231VBOXCMDVBVA_CRCMD_CMD* VBoxCmdVbvaConCmdAlloc(PVBOXMP_DEVEXT pDevExt, uint32_t cbCmd)
     1232{
     1233    return vboxCmdVbvaConCmdAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, cbCmd);
     1234}
     1235
     1236void VBoxCmdVbvaConCmdFree(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD *pCmd)
     1237{
     1238    vboxCmdVbvaConCmdFree(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, pCmd);
     1239}
     1240
     1241int VBoxCmdVbvaConCmdSubmitAsync(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD* pCmd, FNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion)
     1242{
     1243    return vboxCmdVbvaConSubmitAsync(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, pCmd, pfnCompletion, pvCompletion);
     1244}
     1245
     1246int VBoxCmdVbvaConCmdCompletionData(void *pvCmd, VBOXCMDVBVA_CRCMD_CMD **ppCmd)
     1247{
     1248    VBOXCMDVBVA_CTL_3DCTL_CMD *pCmd = (VBOXCMDVBVA_CTL_3DCTL_CMD*)pvCmd;
     1249    if (ppCmd)
     1250        *ppCmd = (VBOXCMDVBVA_CRCMD_CMD*)(pCmd+1);
     1251    return pCmd->Hdr.i32Result;
     1252}

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

    r50778 r50859  
    224224uint32_t VBoxCVDdiPTransferVRamSysBuildEls(VBOXCMDVBVA_PAGING_TRANSFER *pCmd, PMDL pMdl, uint32_t iPfn, uint32_t cPages, uint32_t cbBuffer, uint32_t *pcPagesWritten);
    225225
     226int VBoxCmdVbvaConConnect(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva,
     227        uint32_t crVersionMajor, uint32_t crVersionMinor,
     228        uint32_t *pu32ClientID);
     229int VBoxCmdVbvaConDisconnect(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, uint32_t u32ClientID);
     230VBOXCMDVBVA_CRCMD_CMD* VBoxCmdVbvaConCmdAlloc(PVBOXMP_DEVEXT pDevExt, uint32_t cbCmd);
     231void VBoxCmdVbvaConCmdFree(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD* pCmd);
     232int VBoxCmdVbvaConCmdSubmitAsync(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD* pCmd, FNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion);
     233int VBoxCmdVbvaConCmdCompletionData(void *pvCmd, VBOXCMDVBVA_CRCMD_CMD **ppCmd);
     234
    226235#endif /* #ifndef ___VBoxMPVbva_h___ */

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

    r50542 r50859  
    358358                return STATUS_SUCCESS;
    359359            }
    360             WARN(("VBoxMpCrShgsmiTransportCmdSubmitWriteAsync failed, rc %d", rc));
     360            WARN(("VBoxMpCrShgsmiTransportCmdSubmitWriteReadAsync failed, rc %d", rc));
    361361            Status = STATUS_UNSUCCESSFUL;
    362362            VBoxMpCrShgsmiTransportCmdTermWriteReadAsync(&pDevExt->CrHgsmiTransport, pvCompletionData);
    … …  
    364364        else
    365365        {
    366             WARN(("VBoxMpCrShgsmiTransportCmdCreateWriteAsync failed"));
     366            WARN(("VBoxMpCrShgsmiTransportCmdCreateWriteReadAsync failed"));
    367367            Status = STATUS_INSUFFICIENT_RESOURCES;
    368368        }
    … …  
    10411041        VBoxMpCrPackerInit(&CrPacker);
    10421042
    1043         int rc = VBoxMpCrCtlConConnect(&pDevExt->CrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pDevExt->u32CrConDefaultClientID);
     1043        int rc = VBoxMpCrCtlConConnect(pDevExt, &pDevExt->CrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pDevExt->u32CrConDefaultClientID);
    10441044        if (!RT_SUCCESS(rc))
    10451045        {
    … …  
    10991099        }
    11001100
    1101         int rc = VBoxMpCrCtlConConnect(&pDevExt->CrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pDevExt->u32CrConDefaultClientID);
     1101        int rc = VBoxMpCrCtlConConnect(pDevExt, &pDevExt->CrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pDevExt->u32CrConDefaultClientID);
    11021102        if (!RT_SUCCESS(rc))
    11031103        {
    … …  
    16161616}
    16171617
    1618 static DECLCALLBACK(void) vboxVdmaCBufDrCompletionIrq(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext,
    1619                                         PFNVBOXSHGSMICMDCOMPLETION *ppfnCompletion, void **ppvCompletion)
     1618static DECLCALLBACK(PFNVBOXSHGSMICMDCOMPLETION) vboxVdmaCBufDrCompletionIrq(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext, void **ppvCompletion)
    16201619{
    16211620    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)pvContext;
    … …  
    16461645
    16471646    /* inform SHGSMI we DO NOT want to be called at DPC later */
    1648     *ppfnCompletion = NULL;
     1647    return NULL;
    16491648//    *ppvCompletion = pvContext;
    16501649}

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

    r50773 r50859  
    30893089    /* the DMA command buffer is located in system RAM, the host will need to pick it from there */
    30903090    //BufInfo.fFlags = 0; /* see VBOXVDMACBUF_FLAG_xx */
     3091    VBOXCMDVBVA_HDR *pHdr;
     3092    VBOXCMDVBVA_SYSMEMCMD SysMem;
    30913093    uint32_t cbCmd = pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset - pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset;
    3092     if (cbCmd < sizeof (VBOXCMDVBVA_HDR))
    3093     {
    3094         WARN(("DmaBufferPrivateDataSubmissionEndOffset (%d) - DmaBufferPrivateDataSubmissionStartOffset (%d) < sizeof (VBOXCMDVBVA_HDR) (%d)",
    3095                 pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset,
    3096                 pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset,
    3097                 sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
    3098         return STATUS_INVALID_PARAMETER;
    3099     }
    3100 
    3101     VBOXCMDVBVA_HDR *pHdr = (VBOXCMDVBVA_HDR*)((uint8_t*)pSubmitCommand->pDmaBufferPrivateData + pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset);
     3094    if (!cbCmd)
     3095    {
     3096        cbCmd = pSubmitCommand->DmaBufferSubmissionEndOffset - pSubmitCommand->DmaBufferSubmissionStartOffset;
     3097        if (cbCmd < sizeof (VBOXCMDVBVA_HDR))
     3098        {
     3099            WARN(("DmaBufferPrivateDataSubmissionEndOffset (%d) - DmaBufferPrivateDataSubmissionStartOffset (%d) < sizeof (VBOXCMDVBVA_HDR) (%d)",
     3100                    pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset,
     3101                    pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset,
     3102                    sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
     3103            return STATUS_INVALID_PARAMETER;
     3104        }
     3105
     3106        if (cbCmd > 0xffff)
     3107        {
     3108            WARN(("cbCmd too big"));
     3109            return STATUS_INVALID_PARAMETER;
     3110        }
     3111
     3112        if (VBOXWDDM_DUMMY_DMABUFFER_SIZE == cbCmd)
     3113        {
     3114            SysMem.Hdr.u8OpCode = VBOXCMDVBVA_OPTYPE_NOPCMD;
     3115            SysMem.Hdr.u8Flags = 0;
     3116            SysMem.Hdr.u8State = VBOXCMDVBVA_STATE_SUBMITTED;
     3117            cbCmd = sizeof (SysMem.Hdr);
     3118        }
     3119        else
     3120        {
     3121            SysMem.Hdr.u8OpCode = VBOXCMDVBVA_OPTYPE_SYSMEMCMD;
     3122            SysMem.Hdr.u8Flags = cbCmd & 0xff;
     3123            SysMem.Hdr.u.u8PrimaryID = (cbCmd >> 8) & 0xff;
     3124            SysMem.Hdr.u8State = VBOXCMDVBVA_STATE_SUBMITTED;
     3125            SysMem.phSysMem = pSubmitCommand->DmaBufferPhysicalAddress.QuadPart + pSubmitCommand->DmaBufferSubmissionStartOffset;
     3126            if (SysMem.phSysMem & PAGE_OFFSET_MASK)
     3127            {
     3128                WARN(("command should be page aligned for now"));
     3129                return STATUS_INVALID_PARAMETER;
     3130            }
     3131        }
     3132
     3133        pHdr = &SysMem.Hdr;
     3134        cbCmd = sizeof (SysMem);
     3135    }
     3136    else
     3137    {
     3138        if (cbCmd < sizeof (VBOXCMDVBVA_HDR))
     3139        {
     3140            WARN(("DmaBufferPrivateDataSubmissionEndOffset (%d) - DmaBufferPrivateDataSubmissionStartOffset (%d) < sizeof (VBOXCMDVBVA_HDR) (%d)",
     3141                    pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset,
     3142                    pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset,
     3143                    sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
     3144            return STATUS_INVALID_PARAMETER;
     3145        }
     3146
     3147        pHdr = (VBOXCMDVBVA_HDR*)((uint8_t*)pSubmitCommand->pDmaBufferPrivateData + pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset);
     3148    }
    31023149    pHdr->u32FenceID = pSubmitCommand->SubmissionFenceId;
    31033150    int rc = VBoxCmdVbvaSubmit(pDevExt, &pDevExt->CmdVbva, pHdr, cbCmd);
    … …  
    33683415        case DXGK_OPERATION_TRANSFER:
    33693416        {
    3370             VBOXCMDVBVA_HDR *pHdr = (VBOXCMDVBVA_HDR*)pBuildPagingBuffer->pDmaBuffer;
    3371             pHdr->u8Flags = 0;
    3372             pHdr->u8State = VBOXCMDVBVA_STATE_SUBMITTED;
    3373             /* sanity */
    3374             pHdr->u32FenceID = 0;
    3375 
    33763417            if ((!pBuildPagingBuffer->Transfer.Source.SegmentId) == (!pBuildPagingBuffer->Transfer.Destination.SegmentId))
    33773418            {
    … …  
    33893430            if (pAlloc->AllocData.hostID)
    33903431            {
    3391                 pHdr->u8OpCode = VBOXCMDVBVA_OPTYPE_NOPCMD;
    33923432                cbBuffer = VBOXWDDM_DUMMY_DMABUFFER_SIZE;
    3393                 cbPrivateData = sizeof (*pHdr);
    33943433                break;
    33953434            }
    33963435
    3397             if (pBuildPagingBuffer->DmaBufferPrivateDataSize < sizeof (VBOXCMDVBVA_PAGING_TRANSFER))
    3398             {
    3399                 WARN(("pBuildPagingBuffer->DmaBufferPrivateDataSize(%d) < sizeof VBOXCMDVBVA_PAGING_TRANSFER (%d)", pBuildPagingBuffer->DmaBufferPrivateDataSize , sizeof (VBOXCMDVBVA_PAGING_TRANSFER)));
     3436            if (pBuildPagingBuffer->DmaSize < sizeof (VBOXCMDVBVA_PAGING_TRANSFER))
     3437            {
     3438                WARN(("pBuildPagingBuffer->DmaSize(%d) < sizeof VBOXCMDVBVA_PAGING_TRANSFER (%d)", pBuildPagingBuffer->DmaSize , sizeof (VBOXCMDVBVA_PAGING_TRANSFER)));
    34003439                /* @todo: can this actually happen? what status to return? */
    34013440                return STATUS_INVALID_PARAMETER;
    … …  
    34043443            VBOXCMDVBVA_PAGING_TRANSFER *pPaging = (VBOXCMDVBVA_PAGING_TRANSFER*)pBuildPagingBuffer->pDmaBuffer;
    34053444            pPaging->Hdr.u8OpCode = VBOXCMDVBVA_OPTYPE_PAGING_TRANSFER;
     3445            /* sanity */
     3446            pPaging->Hdr.u8Flags = 0;
     3447            pPaging->Hdr.u8State = VBOXCMDVBVA_STATE_SUBMITTED;
     3448            pPaging->Hdr.u32FenceID = 0;
     3449
    34063450
    34073451            PMDL pMdl;
    … …  
    34373481            if (fIn)
    34383482                pPaging->Hdr.u8Flags |= VBOXCMDVBVA_OPF_PAGING_TRANSFER_IN;
    3439             cbPrivateData = VBoxCVDdiPTransferVRamSysBuildEls(pPaging, pMdl, iFirstPage, cPages, pBuildPagingBuffer->DmaBufferPrivateDataSize, &cPagesWritten);
     3483            cbBuffer = VBoxCVDdiPTransferVRamSysBuildEls(pPaging, pMdl, iFirstPage, cPages, pBuildPagingBuffer->DmaBufferPrivateDataSize, &cPagesWritten);
    34403484            if (cPagesWritten != cPages)
    34413485                pBuildPagingBuffer->MultipassOffset += cPagesWritten;
    … …  
    34433487                pBuildPagingBuffer->MultipassOffset = 0;
    34443488
    3445             cbBuffer = VBOXWDDM_DUMMY_DMABUFFER_SIZE;
    34463489            break;
    34473490        }
    … …  
    34753518        }
    34763519    }
     3520
     3521    Assert(!cbPrivateData);
    34773522
    34783523    pBuildPagingBuffer->pDmaBuffer = ((uint8_t*)pBuildPagingBuffer->pDmaBuffer) + cbBuffer;
    … …  
    66086653            {
    66096654                VBoxMpCrPackerInit(&pContext->CrPacker);
    6610                 int rc = VBoxMpCrCtlConConnect(&pDevExt->CrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pContext->u32CrConClientID);
     6655                int rc = VBoxMpCrCtlConConnect(pDevExt, &pDevExt->CrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pContext->u32CrConClientID);
    66116656                if (!RT_SUCCESS(rc))
    66126657                    WARN(("VBoxMpCrCtlConConnect failed rc (%d), ignoring for system context", rc));
    … …  
    66446689                                        if (pDevExt->f3DEnabled)
    66456690                                        {
    6646                                             int rc = VBoxMpCrCtlConConnect(&pDevExt->CrCtlCon,
     6691                                            int rc = VBoxMpCrCtlConConnect(pDevExt, &pDevExt->CrCtlCon,
    66476692                                                pInfo->crVersionMajor, pInfo->crVersionMinor,
    66486693                                                &pContext->u32CrConClientID);
    … …  
    66896734                                if (pDevExt->f3DEnabled)
    66906735                                {
    6691                                     int rc = VBoxMpCrCtlConConnect(&pDevExt->CrCtlCon,
     6736                                    int rc = VBoxMpCrCtlConConnect(pDevExt, &pDevExt->CrCtlCon,
    66926737                                        pInfo->crVersionMajor, pInfo->crVersionMinor,
    66936738                                        &pContext->u32CrConClientID);
    … …  
    68256870    if (pContext->u32CrConClientID)
    68266871    {
    6827         VBoxMpCrCtlConDisconnect(&pDevExt->CrCtlCon, pContext->u32CrConClientID);
     6872        VBoxMpCrCtlConDisconnect(pDevExt, &pDevExt->CrCtlCon, pContext->u32CrConClientID);
    68286873    }
    68296874
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