VirtualBox

Changeset 43489 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Oct 1, 2012 11:55:58 AM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
81049
Message:

wddm: basics for miniport-based visible rects processing

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Video
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/common/VBoxVideoLog.h

    r41472 r43489  
    9797#endif
    9898
    99 #define WARN_NOBP(_a) _LOGMSG(VBOX_VIDEO_LOG_LOGGER, "WARNING! :", _a)
     99#define WARN_NOBP(_a) _LOGMSG(_WARN_LOGGER, "WARNING! :", _a)
    100100#define WARN(_a)           \
    101101    do                     \
    … …  
    108108            WARN(_w); \
    109109        }\
     110    } while (0)
     111
     112#define STOP_FATAL() do {      \
     113        AssertReleaseFailed(); \
     114    } while (0)
     115#define ERR(_a) do { \
     116        _LOGMSG(VBOX_VIDEO_LOGREL_LOGGER, "FATAL! :", _a); \
     117        STOP_FATAL();                             \
    110118    } while (0)
    111119

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/Makefile.kmk

    r42314 r43489  
    129129        $(VBOX_PATH_CROGL_GENFILES)/pack_bounds_swap.c \
    130130        wddm/VBoxMPCrUtil.cpp
    131    VBoxVideoWddm_DEFS       + VBOX_WDDM_WITH_CRCMD
     131   VBoxVideoWddm_DEFS      += VBOX_WDDM_WITH_CRCMD
    132132 endif
    133133 ifdef VBOXWDDM_WITH_VBVA

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h

    r41638 r43489  
    9696   LIST_ENTRY SwapchainList3D;
    9797   /* mutex for context list operations */
     98#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     99   KSPIN_LOCK ContextLock;
     100#else
    98101   FAST_MUTEX ContextMutex;
     102#endif
    99103   KSPIN_LOCK SynchLock;
    100104   volatile uint32_t cContexts3D;
    … …  
    106110
    107111   VBOXMP_CRCTLCON CrCtlCon;
     112#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     113   VBOXMP_CRSHGSMITRANSPORT CrHgsmiTransport;
     114#endif
    108115
    109116   VBOXWDDM_GLOBAL_POINTER_INFO PointerInfo;

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

    r42028 r43489  
    2626
    2727# ifdef VBOX_WDDM_WITH_CRCMD
    28 #  include <cr_pack.h>
    29 
    30 typedef struct VBOXMP_CRSHGSMICON_BUFDR
    31 {
    32     uint32_t cbBuf;
    33     void *pvBuf;
    34 } VBOXMP_CRSHGSMICON_BUFDR, *PVBOXMP_CRSHGSMICON_BUFDR;
    35 
    36 typedef struct VBOXMP_CRSHGSMICON_BUFDR_CACHE
    37 {
    38     volatile PVBOXMP_CRSHGSMICON_BUFDR pBufDr;
    39 } VBOXMP_CRSHGSMICON_BUFDR_CACHE, *PVBOXMP_CRSHGSMICON_BUFDR_CACHE;
    40 
    41 typedef struct VBOXMP_CRSHGSMICON
    42 {
    43     PVBOXMP_DEVEXT pDevExt;
    44     PVBOXMP_CRCTLCON pCtlCon;
    45     uint32_t u32ClientID;
    46     VBOXMP_CRSHGSMICON_BUFDR_CACHE CmdDrCache;
    47     VBOXMP_CRSHGSMICON_BUFDR_CACHE WbDrCache;
    48 } VBOXMP_CRSHGSMICON, *PVBOXMP_CRSHGSMICON;
    49 
    50 typedef struct VBOXMP_CRSHGSMIPACKER
    51 {
    52     PVBOXMP_CRSHGSMICON pCon;
    53     CRPackContext CrPacker;
    54     CRPackBuffer CrBuffer;
    55 } VBOXMP_CRSHGSMIPACKER, *PVBOXMP_CRSHGSMIPACKER;
    5628
    5729static void* vboxMpCrShgsmiBufferAlloc(PVBOXMP_DEVEXT pDevExt, HGSMISIZE cbData)
    … …  
    6234static VBOXVIDEOOFFSET vboxMpCrShgsmiBufferOffset(PVBOXMP_DEVEXT pDevExt, void *pvBuffer)
    6335{
    64     return HGSMIPointerToOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, (const HGSMIBUFFERHEADER *)pvBuffer);
     36    return (VBOXVIDEOOFFSET)HGSMIPointerToOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, (const HGSMIBUFFERHEADER *)pvBuffer);
     37}
     38
     39static void* vboxMpCrShgsmiBufferFromOffset(PVBOXMP_DEVEXT pDevExt, VBOXVIDEOOFFSET offBuffer)
     40{
     41    return HGSMIOffsetToPointer(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, (HGSMIOFFSET)offBuffer);
    6542}
    6643
    … …  
    7047}
    7148
    72 static void* vboxMpCrShgsmiConAlloc(PVBOXMP_CRSHGSMICON pCon, uint32_t cbBuffer)
     49static VBOXVIDEOOFFSET vboxMpCrShgsmiTransportBufOffset(PVBOXMP_CRSHGSMITRANSPORT pCon, void* pvBuffer)
     50{
     51    return vboxMpCrShgsmiBufferOffset(pCon->pDevExt, pvBuffer);
     52}
     53
     54static void* vboxMpCrShgsmiTransportBufFromOffset(PVBOXMP_CRSHGSMITRANSPORT pCon, VBOXVIDEOOFFSET offBuffer)
     55{
     56    return vboxMpCrShgsmiBufferFromOffset(pCon->pDevExt, offBuffer);
     57}
     58
     59void* VBoxMpCrShgsmiTransportBufAlloc(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t cbBuffer)
    7360{
    7461    return vboxMpCrShgsmiBufferAlloc(pCon->pDevExt, cbBuffer);
    7562}
    7663
    77 static VBOXVIDEOOFFSET vboxMpCrShgsmiConBufOffset(PVBOXMP_CRSHGSMICON pCon, void* pvBuffer)
    78 {
    79     return vboxMpCrShgsmiBufferOffset(pCon->pDevExt, pvBuffer);
    80 }
    81 
    82 
    83 static void vboxMpCrShgsmiConFree(PVBOXMP_CRSHGSMICON pCon, void* pvBuffer)
     64void VBoxMpCrShgsmiTransportBufFree(PVBOXMP_CRSHGSMITRANSPORT pCon, void* pvBuffer)
    8465{
    8566    vboxMpCrShgsmiBufferFree(pCon->pDevExt, pvBuffer);
    8667}
    8768
    88 #define VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) VBOXWDDM_ROUNDBOUND((VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[_cBuffers]))), 8)
    89 #define VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(_pDr, _cBuffers, _type) ((_type*)(((uint8_t*)(_pDr)) + VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers)))
    90 #define VBOXMP_CRSHGSMICON_DR_SIZE(_cBuffers, _cbCmdBuf) ( VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) + _cbCmdBuf)
    91 
    92 static int vboxMpCrShgsmiBufCacheBufReinit(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, PVBOXMP_CRSHGSMICON_BUFDR pDr, uint32_t cbRequested)
     69static int vboxMpCrShgsmiBufCacheBufReinit(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, PVBOXMP_CRSHGSMICON_BUFDR pDr, uint32_t cbRequested)
    9370{
    9471    if (pDr->cbBuf >= cbRequested)
    … …  
    9673
    9774    if (pDr->pvBuf)
    98         vboxMpCrShgsmiConFree(pCon, pDr->pvBuf);
    99 
    100     pDr->pvBuf = vboxMpCrShgsmiConAlloc(pCon, cbRequested);
     75        VBoxMpCrShgsmiTransportBufFree(pCon, pDr->pvBuf);
     76
     77    pDr->pvBuf = VBoxMpCrShgsmiTransportBufAlloc(pCon, cbRequested);
    10178    if (!pDr->pvBuf)
    10279    {
    103         WARN(("vboxMpCrShgsmiConAlloc failed"));
     80        WARN(("VBoxMpCrShgsmiTransportBufAlloc failed"));
    10481        pDr->cbBuf = 0;
    10582        return VERR_NO_MEMORY;
    … …  
    11087}
    11188
    112 static void vboxMpCrShgsmiBufCacheFree(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, PVBOXMP_CRSHGSMICON_BUFDR pDr)
     89static void vboxMpCrShgsmiBufCacheFree(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, PVBOXMP_CRSHGSMICON_BUFDR pDr)
    11390{
    11491    if (ASMAtomicCmpXchgPtr(&pCache->pBufDr, pDr, NULL))
    … …  
    11693
    11794    /* the value is already cached, free the current one */
    118     vboxMpCrShgsmiConFree(pCon, pDr->pvBuf);
     95    VBoxMpCrShgsmiTransportBufFree(pCon, pDr->pvBuf);
    11996    vboxWddmMemFree(pDr);
    12097}
    … …  
    135112}
    136113
    137 static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAlloc(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
     114static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAlloc(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
    138115{
    139116    PVBOXMP_CRSHGSMICON_BUFDR pBufDr = vboxMpCrShgsmiBufCacheGetAllocDr(pCache);
    … …  
    148125}
    149126
    150 static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAllocAny(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
     127static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAllocAny(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
    151128{
    152129    PVBOXMP_CRSHGSMICON_BUFDR pBufDr = vboxMpCrShgsmiBufCacheGetAllocDr(pCache);
    … …  
    166143
    167144
    168 static int vboxMpCrShgsmiBufCacheInit(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
     145static int vboxMpCrShgsmiBufCacheInit(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
    169146{
    170147    memset(pCache, 0, sizeof (*pCache));
    … …  
    172149}
    173150
    174 static void vboxMpCrShgsmiBufCacheTerm(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
     151static void vboxMpCrShgsmiBufCacheTerm(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
    175152{
    176153    if (pCache->pBufDr)
    … …  
    178155}
    179156
    180 static int vboxMpCrShgsmiConConnect(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_DEVEXT pDevExt, PVBOXMP_CRCTLCON pCrCtlCon)
     157int VBoxMpCrShgsmiTransportCreate(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_DEVEXT pDevExt)
    181158{
    182159    memset(pCon, 0, sizeof (*pCon));
    183     int rc = vboxMpCrShgsmiBufCacheInit(pCon, &pCon->CmdDrCache);
    184     if (RT_SUCCESS(rc))
     160    pCon->pDevExt = pDevExt;
     161    return VINF_SUCCESS;
     162    int rc;
     163//    int rc = vboxMpCrShgsmiBufCacheInit(pCon, &pCon->CmdDrCache);
     164//    if (RT_SUCCESS(rc))
    185165    {
    186166        rc = vboxMpCrShgsmiBufCacheInit(pCon, &pCon->WbDrCache);
    187167        if (RT_SUCCESS(rc))
    188168        {
    189             rc = VBoxMpCrCtlConConnect(pCrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pCon->u32ClientID);
    190             if (RT_SUCCESS(rc))
     169        }
     170        else
     171        {
     172            WARN(("vboxMpCrShgsmiBufCacheInit2 failed rc %d", rc));
     173        }
     174//        vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->CmdDrCache);
     175    }
     176//    else
     177//    {
     178//        WARN(("vboxMpCrShgsmiBufCacheInit1 failed rc %d", rc));
     179//    }
     180
     181    return rc;
     182}
     183
     184void VBoxMpCrShgsmiTransportTerm(PVBOXMP_CRSHGSMITRANSPORT pCon)
     185{
     186    vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->WbDrCache);
     187//    vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->CmdDrCache);
     188}
     189
     190//typedef struct VBOXMP_CRHGSMICMD_HDR
     191//{
     192//    union
     193//    {
     194//        PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnWriteReadCompletion;
     195//        PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnWriteCompletion;
     196//    };
     197//} VBOXMP_CRHGSMICMD_HDR, *PVBOXMP_CRHGSMICMD_HDR;
     198
     199typedef struct VBOXMP_CRHGSMICMD_BASE
     200{
     201//    VBOXMP_CRHGSMICMD_HDR Hdr;
     202    CRVBOXHGSMIHDR CmdHdr;
     203} VBOXMP_CRHGSMICMD_BASE, *PVBOXMP_CRHGSMICMD_BASE;
     204
     205typedef struct VBOXMP_CRHGSMICMD_WRITEREAD
     206{
     207//    VBOXMP_CRHGSMICMD_HDR Hdr;
     208    CRVBOXHGSMIWRITEREAD Cmd;
     209} VBOXMP_CRHGSMICMD_WRITEREAD, *PVBOXMP_CRHGSMICMD_WRITEREAD;
     210
     211typedef struct VBOXMP_CRHGSMICMD_READ
     212{
     213//    VBOXMP_CRHGSMICMD_HDR Hdr;
     214    CRVBOXHGSMIREAD Cmd;
     215} VBOXMP_CRHGSMICMD_READ, *PVBOXMP_CRHGSMICMD_READ;
     216
     217typedef struct VBOXMP_CRHGSMICMD_WRITE
     218{
     219//    VBOXMP_CRHGSMICMD_HDR Hdr;
     220    CRVBOXHGSMIWRITE Cmd;
     221} VBOXMP_CRHGSMICMD_WRITE, *PVBOXMP_CRHGSMICMD_WRITE;
     222
     223#define VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) VBOXWDDM_ROUNDBOUND((VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[_cBuffers]))), 8)
     224#define VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf) ( VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) + VBOXWDDM_ROUNDBOUND(_cbCmdBuf, 8))
     225#define VBOXMP_CRSHGSMICON_DR_GET_CRCMD(_pDr) (VBOXVDMACMD_BODY((_pDr), VBOXVDMACMD_CHROMIUM_CMD))
     226#define VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(_pDr, _cBuffers, _type) ((_type*)(((uint8_t*)(_pDr)) + VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers)))
     227#define VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(_pDr, _cBuffers, _cbCmdBuf, _type) ((_type*)(((uint8_t*)(_pDr)) +  VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)))
     228#define VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(_pCtx, _cBuffers, _cbCmdBuf) ((VBOXVDMACMD*)(((uint8_t*)(_pCtx)) -  VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)))
     229#define VBOXMP_CRSHGSMICON_DR_SIZE(_cBuffers, _cbCmdBuf, _cbCtx) (VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf) + (_cbCtx))
     230
     231
     232static int vboxMpCrShgsmiTransportCmdSubmitDr(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXVDMACBUF_DR pDr, PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete)
     233{
     234
     235    PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);
     236    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
     237    vboxVdmaDdiCmdInit(pDdiCmd, 0, 0, pfnComplete, pCon);
     238    /* mark command as submitted & invisible for the dx runtime since dx did not originate it */
     239    vboxVdmaDdiCmdSubmittedNotDx(pDdiCmd);
     240    int rc = vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);
     241    if (RT_SUCCESS(rc))
     242    {
     243        return VINF_SUCCESS;
     244    }
     245
     246    WARN(("vboxVdmaCBufDrSubmit failed rc %d", rc));
     247    return rc;
     248}
     249
     250static int vboxMpCrShgsmiTransportCmdSubmitDmaCmd(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXVDMACMD pHdr, PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete)
     251{
     252    PVBOXVDMACBUF_DR pDr = VBOXVDMACBUF_DR_FROM_TAIL(pHdr);
     253    return vboxMpCrShgsmiTransportCmdSubmitDr(pCon, pDr, pfnComplete);
     254}
     255
     256static void vboxMpCrShgsmiTransportCmdTermDmaCmd(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXVDMACMD pHdr)
     257{
     258    PVBOXVDMACBUF_DR pDr = VBOXVDMACBUF_DR_FROM_TAIL(pHdr);
     259    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
     260    vboxVdmaCBufDrFree (&pDevExt->u.primary.Vdma, pDr);
     261}
     262
     263
     264typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvRx, uint32_t cbRx, void *pvCtx);
     265typedef FNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION *PFNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION;
     266
     267static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportSendReadAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd, PVOID pvContext)
     268{
     269    /* we should be called from our DPC routine */
     270    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
     271
     272    PVBOXMP_CRSHGSMITRANSPORT pCon = (PVBOXMP_CRSHGSMITRANSPORT)pvContext;
     273    PVBOXVDMACBUF_DR pDr = VBOXVDMACBUF_DR_FROM_DDI_CMD(pDdiCmd);
     274    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
     275    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXMP_CRSHGSMICON_DR_GET_CRCMD(pHdr);
     276    const UINT cBuffers = 2;
     277    Assert(pBody->cBuffers == cBuffers);
     278    PVBOXMP_CRHGSMICMD_READ pWrData = VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(pHdr, cBuffers, VBOXMP_CRHGSMICMD_READ);
     279    CRVBOXHGSMIREAD *pCmd = &pWrData->Cmd;
     280    VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[0];
     281    Assert(pBufCmd->cbBuffer == sizeof (CRVBOXHGSMIREAD));
     282    CRVBOXHGSMIREAD * pWr = (CRVBOXHGSMIREAD*)vboxMpCrShgsmiTransportBufFromOffset(pCon, pBufCmd->offBuffer);
     283    PFNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION pfnCompletion = (PFNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION)pBufCmd->u64GuestData;
     284    VBOXVDMACMD_CHROMIUM_BUFFER *pRxBuf = &pBody->aBuffers[1];
     285    PVBOXMP_CRSHGSMICON_BUFDR pWbDr = (PVBOXMP_CRSHGSMICON_BUFDR)pRxBuf->u64GuestData;
     286    void *pvRx = NULL;
     287    uint32_t cbRx = 0;
     288
     289    int rc = pDr->rc;
     290    if (RT_SUCCESS(rc))
     291    {
     292        rc = pWr->hdr.result;
     293        if (RT_SUCCESS(rc))
     294        {
     295            cbRx = pCmd->cbBuffer;
     296            if (cbRx)
     297                pvRx = pWbDr->pvBuf;
     298        }
     299        else
     300        {
     301            WARN(("CRVBOXHGSMIREAD failed, rc %d", rc));
     302        }
     303    }
     304    else
     305    {
     306        WARN(("dma command buffer failed rc %d!", rc));
     307    }
     308
     309    if (pfnCompletion)
     310    {
     311        void *pvCtx = VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(pHdr, cBuffers, sizeof (VBOXMP_CRHGSMICMD_READ), void);
     312        pfnCompletion(pCon, rc, pvRx, cbRx, pvCtx);
     313    }
     314
     315    vboxMpCrShgsmiBufCacheFree(pCon, &pCon->WbDrCache, pWbDr);
     316}
     317
     318static void* vboxMpCrShgsmiTransportCmdCreateReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, PVBOXVDMACBUF_DR pDr, uint32_t cbDrData, PVBOXMP_CRSHGSMICON_BUFDR pWbDr,
     319        PFNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
     320{
     321    const uint32_t cBuffers = 2;
     322    const uint32_t cbCmd = VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (VBOXMP_CRHGSMICMD_READ), cbContextData);
     323    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
     324    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
     325    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXMP_CRSHGSMICON_DR_GET_CRCMD(pHdr);
     326    PVBOXMP_CRHGSMICMD_READ pWrData = VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(pHdr, cBuffers, VBOXMP_CRHGSMICMD_READ);
     327    CRVBOXHGSMIREAD *pCmd = &pWrData->Cmd;
     328
     329    if (cbCmd > cbContextData)
     330    {
     331        ERR(("the passed descriptor is less than needed!"));
     332        return NULL;
     333    }
     334
     335    memset(pDr, 0, VBOXVDMACBUF_DR_SIZE(cbCmd));
     336
     337    pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_VRAM_OFFSET;
     338    pDr->cbBuf = cbCmd;
     339    pDr->rc = VERR_NOT_IMPLEMENTED;
     340    pDr->Location.offVramBuf = vboxMpCrShgsmiTransportBufOffset(pCon, pCmd);
     341
     342    pHdr->enmType = VBOXVDMACMD_TYPE_CHROMIUM_CMD;
     343    pHdr->u32CmdSpecific = 0;
     344
     345    pBody->cBuffers = cBuffers;
     346
     347    pCmd->hdr.result      = VERR_WRONG_ORDER;
     348    pCmd->hdr.u32ClientID = u32ClientID;
     349    pCmd->hdr.u32Function = SHCRGL_GUEST_FN_WRITE_READ;
     350    //    pCmd->hdr.u32Reserved = 0;
     351    pCmd->iBuffer = 1;
     352
     353    VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[0];
     354    pBufCmd->offBuffer = vboxMpCrShgsmiTransportBufOffset(pCon, pCmd);
     355    pBufCmd->cbBuffer = sizeof (*pCmd);
     356    pBufCmd->u32GuestData = 0;
     357    pBufCmd->u64GuestData = (uint64_t)pfnCompletion;
     358
     359    pBufCmd = &pBody->aBuffers[1];
     360    pBufCmd->offBuffer = vboxMpCrShgsmiTransportBufOffset(pCon, pWbDr->pvBuf);
     361    pBufCmd->cbBuffer = pWbDr->cbBuf;
     362    pBufCmd->u32GuestData = 0;
     363    pBufCmd->u64GuestData = (uint64_t)pWbDr;
     364
     365    return VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(pHdr, cBuffers, sizeof (VBOXMP_CRHGSMICMD_READ), void);
     366}
     367
     368static int vboxMpCrShgsmiTransportCmdSubmitReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
     369{
     370    VBOXVDMACMD* pHdr = VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_READ));
     371    return vboxMpCrShgsmiTransportCmdSubmitDmaCmd(pCon, pHdr, vboxMpCrShgsmiTransportSendReadAsyncCompletion);
     372}
     373
     374typedef struct VBOXMP_CRHGSMICON_WRR_COMPLETION_CTX
     375{
     376    PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion;
     377    void *pvContext;
     378
     379} VBOXMP_CRHGSMICON_WRR_COMPLETION_CTX, *PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX;
     380
     381static DECLCALLBACK(void) vboxMpCrShgsmiTransportSendWriteReadReadRepostCompletion(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvRx, uint32_t cbRx, void *pvCtx)
     382{
     383    PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX pData = (PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX)pvCtx;
     384    PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion = pData->pfnCompletion;
     385    if (pfnCompletion)
     386        pfnCompletion(pCon, rc, pvRx, cbRx, pData->pvContext);
     387}
     388
     389static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportSendWriteReadAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd, PVOID pvContext)
     390{
     391    /* we should be called from our DPC routine */
     392    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
     393
     394    PVBOXMP_CRSHGSMITRANSPORT pCon = (PVBOXMP_CRSHGSMITRANSPORT)pvContext;
     395    PVBOXVDMACBUF_DR pDr = VBOXVDMACBUF_DR_FROM_DDI_CMD(pDdiCmd);
     396    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
     397    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXMP_CRSHGSMICON_DR_GET_CRCMD(pHdr);
     398    const UINT cBuffers = 3;
     399    Assert(pBody->cBuffers == cBuffers);
     400    PVBOXMP_CRHGSMICMD_WRITEREAD pWrData = VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(pHdr, cBuffers, VBOXMP_CRHGSMICMD_WRITEREAD);
     401    CRVBOXHGSMIWRITEREAD *pCmd = &pWrData->Cmd;
     402    VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[0];
     403    Assert(pBufCmd->cbBuffer == sizeof (CRVBOXHGSMIWRITEREAD));
     404    CRVBOXHGSMIWRITEREAD * pWr = (CRVBOXHGSMIWRITEREAD*)vboxMpCrShgsmiTransportBufFromOffset(pCon, pBufCmd->offBuffer);
     405    VBOXVDMACMD_CHROMIUM_BUFFER *pRxBuf = &pBody->aBuffers[2];
     406    PVBOXMP_CRSHGSMICON_BUFDR pWbDr = (PVBOXMP_CRSHGSMICON_BUFDR)pRxBuf->u64GuestData;
     407    PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion = (PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION)pBufCmd->u64GuestData;
     408    void *pvRx = NULL;
     409    uint32_t cbRx = 0;
     410
     411    int rc = pDr->rc;
     412    if (RT_SUCCESS(rc))
     413    {
     414        rc = pWr->hdr.result;
     415        if (RT_SUCCESS(rc))
     416        {
     417            cbRx = pCmd->cbWriteback;
     418            if (cbRx)
     419                pvRx = pWbDr->pvBuf;
     420        }
     421        else if (rc == VERR_BUFFER_OVERFLOW)
     422        {
     423            /* issue read */
     424            void *pvCtx = VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(pHdr, cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITEREAD), void);
     425            vboxMpCrShgsmiBufCacheFree(pCon, &pCon->WbDrCache, pWbDr);
     426            pWbDr =  vboxMpCrShgsmiBufCacheAlloc(pCon, &pCon->WbDrCache, pCmd->cbWriteback);
     427            if (pWbDr)
    191428            {
    192                 pCon->pDevExt = pDevExt;
    193                 pCon->pCtlCon = pCrCtlCon;
    194                 return VINF_SUCCESS;
     429                /* the Read Command is shorter than WriteRead, so just reuse the Write-Read descriptor here */
     430                PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX pReadCtx = (PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX)vboxMpCrShgsmiTransportCmdCreateReadAsync(pCon, pCmd->hdr.u32ClientID,
     431                            pDr, VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITEREAD), 0),
     432                            pWbDr, vboxMpCrShgsmiTransportSendWriteReadReadRepostCompletion, sizeof (*pReadCtx));
     433                pReadCtx->pfnCompletion = pfnCompletion;
     434                pReadCtx->pvContext = pvCtx;
     435                vboxMpCrShgsmiTransportCmdSubmitReadAsync(pCon, pReadCtx);
     436                /* don't do completion here, the completion will be called from the read completion we issue here */
     437                pfnCompletion = NULL;
     438                /* the current pWbDr was already freed, and we'll free the Read dr in the Read Completion */
     439                pWbDr = NULL;
    195440            }
    196441            else
    197442            {
    198                 WARN(("VBoxMpCrCtlConConnect failed rc %d", rc));
     443                WARN(("vboxMpCrShgsmiBufCacheAlloc failed for %d", pCmd->cbWriteback));
     444                rc = VERR_NO_MEMORY;
    199445            }
    200             vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->WbDrCache);
    201446        }
    202447        else
    203448        {
    204             WARN(("vboxMpCrShgsmiBufCacheInit2 failed rc %d", rc));
    205         }
    206         vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->CmdDrCache);
     449            WARN(("CRVBOXHGSMIWRITEREAD failed, rc %d", rc));
     450        }
    207451    }
    208452    else
    209453    {
    210         WARN(("vboxMpCrShgsmiBufCacheInit1 failed rc %d", rc));
    211     }
    212 
    213     return rc;
    214 }
    215 
    216 static int vboxMpCrShgsmiConDisconnect(PVBOXMP_CRSHGSMICON pCon)
    217 {
    218     int rc = VBoxMpCrCtlConDisconnect(pCon->pCtlCon, pCon->u32ClientID);
    219     if (RT_FAILURE(rc))
    220     {
    221         WARN(("VBoxMpCrCtlConDisconnect failed rc %d", rc));
    222         return rc;
    223     }
    224 
    225     vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->WbDrCache);
    226     vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->CmdDrCache);
    227 
    228     return VINF_SUCCESS;
    229 }
    230 
    231 typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMICON_SEND_COMPLETION(PVBOXMP_CRSHGSMICON pCon, void *pvRx, uint32_t cbRx, void *pvCtx);
    232 typedef FNVBOXMP_CRSHGSMICON_SEND_COMPLETION *PFNVBOXMP_CRSHGSMICON_SEND_COMPLETION;
    233 
    234 typedef struct VBOXMP_CRSHGSMICON_SEND_COMPLETION
    235 {
    236     PVBOXMP_CRSHGSMICON pCon;
    237     PFNVBOXMP_CRSHGSMICON_SEND_COMPLETION pvnCompletion;
    238     void *pvCompletion;
    239 } VBOXMP_CRSHGSMICON_SEND_COMPLETION, *PVBOXMP_CRSHGSMICON_SEND_COMPLETION;
    240 
    241 static DECLCALLBACK(VOID) vboxMpCrShgsmiConSendAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
     454        WARN(("dma command buffer failed rc %d!", rc));
     455    }
     456
     457    if (pfnCompletion)
     458    {
     459        void *pvCtx = VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(pHdr, cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITEREAD), void);
     460        pfnCompletion(pCon, rc, pvRx, cbRx, pvCtx);
     461    }
     462
     463    if (pWbDr)
     464        vboxMpCrShgsmiBufCacheFree(pCon, &pCon->WbDrCache, pWbDr);
     465}
     466
     467static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportSendWriteAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd, PVOID pvContext)
    242468{
    243469    /* we should be called from our DPC routine */
    244470    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
    245471
    246     PVBOXMP_CRSHGSMICON_SEND_COMPLETION pData = (PVBOXMP_CRSHGSMICON_SEND_COMPLETION)pvContext;
    247     PVBOXVDMACBUF_DR pDr = VBOXVDMACBUF_DR_FROM_DDI_CMD(pCmd);
     472    PVBOXMP_CRSHGSMITRANSPORT pCon = (PVBOXMP_CRSHGSMITRANSPORT)pvContext;
     473    PVBOXVDMACBUF_DR pDr = VBOXVDMACBUF_DR_FROM_DDI_CMD(pDdiCmd);
    248474    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
    249     VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHROMIUM_CMD);
    250     UINT cBufs = pBody->cBuffers;
    251     /* the first one is a command buffer: obtain it and get the result */
    252 
    253     /* if write back buffer is too small, issue read command.
    254      * we can use exactly the same command buffer for it */
    255     /* impl */
    256     Assert(0);
    257 }
    258 
    259 static int vboxMpCrShgsmiConSendAsync(PVBOXMP_CRSHGSMICON pCon, void *pvTx, uint32_t cbTx, PFNVBOXMP_CRSHGSMICON_SEND_COMPLETION pfnCompletion, void *pvCompletion)
     475    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXMP_CRSHGSMICON_DR_GET_CRCMD(pHdr);
     476    const UINT cBuffers = 2;
     477    Assert(pBody->cBuffers == cBuffers);
     478    PVBOXMP_CRHGSMICMD_WRITE pWrData = VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(pHdr, cBuffers, VBOXMP_CRHGSMICMD_WRITE);
     479    CRVBOXHGSMIWRITE *pCmd = &pWrData->Cmd;
     480    VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[0];
     481    Assert(pBufCmd->cbBuffer == sizeof (CRVBOXHGSMIWRITE));
     482    CRVBOXHGSMIWRITE * pWr = (CRVBOXHGSMIWRITE*)vboxMpCrShgsmiTransportBufFromOffset(pCon, pBufCmd->offBuffer);
     483    PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion = (PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION)pBufCmd->u64GuestData;
     484
     485    int rc = pDr->rc;
     486    if (RT_SUCCESS(rc))
     487    {
     488        rc = pWr->hdr.result;
     489        if (!RT_SUCCESS(rc))
     490        {
     491            WARN(("CRVBOXHGSMIWRITE failed, rc %d", rc));
     492        }
     493    }
     494    else
     495    {
     496        WARN(("dma command buffer failed rc %d!", rc));
     497    }
     498
     499    if (pfnCompletion)
     500    {
     501        void *pvCtx = VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(pHdr, cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITE), void);
     502        pfnCompletion(pCon, rc, pvCtx);
     503    }
     504}
     505
     506void* VBoxMpCrShgsmiTransportCmdCreateWriteReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
     507        PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
    260508{
    261509    const uint32_t cBuffers = 3;
    262     const uint32_t cbCmd = VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (CRVBOXHGSMIWRITEREAD));
    263     PVBOXMP_CRSHGSMICON_BUFDR pCmdDr = vboxMpCrShgsmiBufCacheAlloc(pCon, &pCon->CmdDrCache, cbCmd);
    264     if (!pCmdDr)
    265     {
    266         WARN(("vboxMpCrShgsmiBufCacheAlloc for cmd dr failed"));
    267         return VERR_NO_MEMORY;
    268     }
     510    const uint32_t cbCmd = VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITEREAD), cbContextData);
     511    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
     512    PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
     513    if (!pDr)
     514    {
     515        WARN(("vboxVdmaCBufDrCreate failed"));
     516        return NULL;
     517    }
     518
    269519    PVBOXMP_CRSHGSMICON_BUFDR pWbDr = vboxMpCrShgsmiBufCacheAllocAny(pCon, &pCon->WbDrCache, 1000);
    270520    if (!pWbDr)
    271521    {
    272522        WARN(("vboxMpCrShgsmiBufCacheAlloc for wb dr failed"));
    273         vboxMpCrShgsmiBufCacheFree(pCon, &pCon->CmdDrCache, pCmdDr);
    274         return VERR_NO_MEMORY;
    275     }
    276 
    277     PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)pCmdDr->pvBuf;
    278     pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR;
     523        vboxVdmaCBufDrFree(&pDevExt->u.primary.Vdma, pDr);
     524        return NULL;
     525    }
     526
     527    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
     528    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXMP_CRSHGSMICON_DR_GET_CRCMD(pHdr);
     529    PVBOXMP_CRHGSMICMD_WRITEREAD pWrData = VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(pHdr, cBuffers, VBOXMP_CRHGSMICMD_WRITEREAD);
     530    CRVBOXHGSMIWRITEREAD *pCmd = &pWrData->Cmd;
     531
     532    pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_VRAM_OFFSET;
    279533    pDr->cbBuf = cbCmd;
    280534    pDr->rc = VERR_NOT_IMPLEMENTED;
    281 
    282     PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
     535    pDr->Location.offVramBuf = vboxMpCrShgsmiTransportBufOffset(pCon, pCmd);
     536
    283537    pHdr->enmType = VBOXVDMACMD_TYPE_CHROMIUM_CMD;
    284538    pHdr->u32CmdSpecific = 0;
    285     VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHROMIUM_CMD);
     539
    286540    pBody->cBuffers = cBuffers;
    287     CRVBOXHGSMIWRITEREAD *pCmd = VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(pDr, cBuffers, CRVBOXHGSMIWRITEREAD);
     541
    288542    pCmd->hdr.result      = VERR_WRONG_ORDER;
    289     pCmd->hdr.u32ClientID = pCon->u32ClientID;
     543    pCmd->hdr.u32ClientID = u32ClientID;
    290544    pCmd->hdr.u32Function = SHCRGL_GUEST_FN_WRITE_READ;
    291545    //    pCmd->hdr.u32Reserved = 0;
    … …  
    295549
    296550    VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[0];
    297     pBufCmd->offBuffer = vboxMpCrShgsmiConBufOffset(pCon, pCmd);
     551    pBufCmd->offBuffer = vboxMpCrShgsmiTransportBufOffset(pCon, pCmd);
    298552    pBufCmd->cbBuffer = sizeof (*pCmd);
    299553    pBufCmd->u32GuestData = 0;
    300     pBufCmd->u64GuestData = (uint64_t)pCmdDr;
     554    pBufCmd->u64GuestData = (uint64_t)pfnCompletion;
    301555
    302556    pBufCmd = &pBody->aBuffers[1];
    303     pBufCmd->offBuffer = vboxMpCrShgsmiConBufOffset(pCon, pvTx);
    304     pBufCmd->cbBuffer = cbTx;
     557    pBufCmd->offBuffer = vboxMpCrShgsmiTransportBufOffset(pCon, pvBuffer);
     558    pBufCmd->cbBuffer = cbBuffer;
    305559    pBufCmd->u32GuestData = 0;
    306560    pBufCmd->u64GuestData = 0;
    307561
    308562    pBufCmd = &pBody->aBuffers[2];
    309     pBufCmd->offBuffer = vboxMpCrShgsmiConBufOffset(pCon, pWbDr->pvBuf);
     563    pBufCmd->offBuffer = vboxMpCrShgsmiTransportBufOffset(pCon, pWbDr->pvBuf);
    310564    pBufCmd->cbBuffer = pWbDr->cbBuf;
    311565    pBufCmd->u32GuestData = 0;
    312566    pBufCmd->u64GuestData = (uint64_t)pWbDr;
    313567
     568    return VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(pHdr, cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITEREAD), void);
     569}
     570
     571void* VBoxMpCrShgsmiTransportCmdCreateWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
     572        PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
     573{
     574
     575    const uint32_t cBuffers = 2;
     576    const uint32_t cbCmd = VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITE), cbContextData);
    314577    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
    315     PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);
    316     vboxVdmaDdiCmdInit(pDdiCmd, 0, 0, vboxMpCrShgsmiConSendAsyncCompletion, pDr);
    317     /* mark command as submitted & invisible for the dx runtime since dx did not originate it */
    318     vboxVdmaDdiCmdSubmittedNotDx(pDdiCmd);
    319     int rc = vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);
    320     if (RT_SUCCESS(rc))
    321     {
    322         return STATUS_SUCCESS;
    323     }
    324 
    325     /* impl failure branch */
    326     Assert(0);
    327     return rc;
    328 }
    329 
    330 static CRMessageOpcodes *
    331 vboxMpCrPackerPrependHeader( CRPackBuffer *buf, unsigned int *len, unsigned int senderID )
    332 {
    333     UINT num_opcodes;
    334     CRMessageOpcodes *hdr;
    335 
    336     Assert(buf);
    337     Assert(buf->opcode_current < buf->opcode_start);
    338     Assert(buf->opcode_current >= buf->opcode_end);
    339     Assert(buf->data_current > buf->data_start);
    340     Assert(buf->data_current <= buf->data_end);
    341 
    342     num_opcodes = (UINT)(buf->opcode_start - buf->opcode_current);
    343     hdr = (CRMessageOpcodes *)
    344         ( buf->data_start - ( ( num_opcodes + 3 ) & ~0x3 ) - sizeof(*hdr) );
    345 
    346     Assert((void *) hdr >= buf->pack);
    347 
    348     hdr->header.type = CR_MESSAGE_OPCODES;
    349     hdr->numOpcodes  = num_opcodes;
    350 
    351     *len = (UINT)(buf->data_current - (unsigned char *) hdr);
    352 
    353     return hdr;
    354 }
    355 
    356 static void vboxMpCrShgsmiPackerCbFlush(void *pvFlush)
    357 {
    358     PVBOXMP_CRSHGSMIPACKER pPacker = (PVBOXMP_CRSHGSMIPACKER)pvFlush;
    359 
    360     crPackReleaseBuffer(&pPacker->CrPacker);
    361 
    362     if (pPacker->CrBuffer.opcode_current != pPacker->CrBuffer.opcode_start)
    363     {
    364         CRMessageOpcodes *pHdr;
    365         unsigned int len;
    366         pHdr = vboxMpCrPackerPrependHeader(&pPacker->CrBuffer, &len, 0);
    367 
    368         /*Send*/
    369     }
    370 
    371 
    372     crPackSetBuffer(&pPacker->CrPacker, &pPacker->CrBuffer);
    373     crPackResetPointers(&pPacker->CrPacker);
    374 }
    375 
    376 int vboxMpCrShgsmiPackerInit(PVBOXMP_CRSHGSMIPACKER pPacker, PVBOXMP_CRSHGSMICON pCon)
    377 {
    378     memset(pPacker, 0, sizeof (*pPacker));
    379 
    380     static const HGSMISIZE cbBuffer = 1000;
    381     void *pvBuffer = vboxMpCrShgsmiConAlloc(pCon, cbBuffer);
    382     if (!pvBuffer)
    383     {
    384         WARN(("vboxMpCrShgsmiConAlloc failed"));
    385         return VERR_NO_MEMORY;
    386     }
    387     pPacker->pCon = pCon;
    388     crPackInitBuffer(&pPacker->CrBuffer, pvBuffer, cbBuffer, cbBuffer);
    389     crPackSetBuffer(&pPacker->CrPacker, &pPacker->CrBuffer);
    390     crPackFlushFunc(&pPacker->CrPacker, vboxMpCrShgsmiPackerCbFlush);
    391     crPackFlushArg(&pPacker->CrPacker, pPacker);
    392 //    crPackSendHugeFunc( thread->packer, packspuHuge );
    393     return VINF_SUCCESS;
    394 }
     578    PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
     579    if (!pDr)
     580    {
     581        WARN(("vboxVdmaCBufDrCreate failed"));
     582        return NULL;
     583    }
     584
     585    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
     586    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXMP_CRSHGSMICON_DR_GET_CRCMD(pHdr);
     587    PVBOXMP_CRHGSMICMD_WRITE pWrData = VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(pHdr, cBuffers, VBOXMP_CRHGSMICMD_WRITE);
     588    CRVBOXHGSMIWRITE *pCmd = &pWrData->Cmd;
     589
     590    pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_VRAM_OFFSET;
     591    pDr->cbBuf = cbCmd;
     592    pDr->rc = VERR_NOT_IMPLEMENTED;
     593    pDr->Location.offVramBuf = vboxMpCrShgsmiTransportBufOffset(pCon, pCmd);
     594
     595    pHdr->enmType = VBOXVDMACMD_TYPE_CHROMIUM_CMD;
     596    pHdr->u32CmdSpecific = 0;
     597
     598    pBody->cBuffers = cBuffers;
     599
     600    pCmd->hdr.result      = VERR_WRONG_ORDER;
     601    pCmd->hdr.u32ClientID = u32ClientID;
     602    pCmd->hdr.u32Function = SHCRGL_GUEST_FN_WRITE_READ;
     603    //    pCmd->hdr.u32Reserved = 0;
     604    pCmd->iBuffer = 1;
     605
     606    VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[0];
     607    pBufCmd->offBuffer = vboxMpCrShgsmiTransportBufOffset(pCon, pCmd);
     608    pBufCmd->cbBuffer = sizeof (*pCmd);
     609    pBufCmd->u32GuestData = 0;
     610    pBufCmd->u64GuestData = (uint64_t)pfnCompletion;
     611
     612    pBufCmd = &pBody->aBuffers[1];
     613    pBufCmd->offBuffer = vboxMpCrShgsmiTransportBufOffset(pCon, pvBuffer);
     614    pBufCmd->cbBuffer = cbBuffer;
     615    pBufCmd->u32GuestData = 0;
     616    pBufCmd->u64GuestData = 0;
     617
     618    return VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(pHdr, cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITE), void);
     619}
     620
     621int VBoxMpCrShgsmiTransportCmdSubmitWriteReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
     622{
     623    VBOXVDMACMD* pHdr = VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(pvContext, 3, sizeof (VBOXMP_CRHGSMICMD_WRITEREAD));
     624    return vboxMpCrShgsmiTransportCmdSubmitDmaCmd(pCon, pHdr, vboxMpCrShgsmiTransportSendWriteReadAsyncCompletion);
     625}
     626
     627int VBoxMpCrShgsmiTransportCmdSubmitWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
     628{
     629    VBOXVDMACMD* pHdr = VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_WRITE));
     630    return vboxMpCrShgsmiTransportCmdSubmitDmaCmd(pCon, pHdr, vboxMpCrShgsmiTransportSendWriteAsyncCompletion);
     631}
     632
     633void VBoxMpCrShgsmiTransportCmdTermWriteReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
     634{
     635    VBOXVDMACMD* pHdr = VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(pvContext, 3, sizeof (VBOXMP_CRHGSMICMD_WRITEREAD));
     636    vboxMpCrShgsmiTransportCmdTermDmaCmd(pCon, pHdr);
     637}
     638
     639void VBoxMpCrShgsmiTransportCmdTermWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
     640{
     641    VBOXVDMACMD* pHdr = VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_WRITE));
     642    vboxMpCrShgsmiTransportCmdTermDmaCmd(pCon, pHdr);
     643}
     644
    395645# endif
    396646#endif

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

    r40897 r43489  
    3737int VBoxMpCrCtlConCallUserData(PVBOXMP_CRCTLCON pCrCtlCon, struct VBoxGuestHGCMCallInfo *pData, uint32_t cbData);
    3838
     39#ifdef VBOX_WDDM_WITH_CRCMD
     40# include <cr_pack.h>
     41
     42typedef struct VBOXMP_CRDATACON
     43{
     44    PVBOXMP_CRCTLCON pCtl;
     45    uint32_t u32ClientID;
     46} VBOXMP_CRDATACON, *PVBOXMP_CRDATACON;
     47
     48DECLINLINE(int) VBoxMpCrDataConCreate(PVBOXMP_CRDATACON pDataCon, PVBOXMP_CRCTLCON pCtlCon)
     49{
     50    int rc = VBoxMpCrCtlConConnect(pCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pDataCon->u32ClientID);
     51    if (RT_SUCCESS(rc))
     52    {
     53        Assert(pDataCon->u32ClientID);
     54        pDataCon->pCtl = pCtlCon;
     55        return VINF_SUCCESS;
     56    }
     57    WARN(("VBoxMpCrCtlConConnect failed, rc %d", rc));
     58    return rc;
     59}
     60
     61DECLINLINE(int) VBoxMpCrDataConDestroy(PVBOXMP_CRDATACON pDataCon)
     62{
     63    int rc = VBoxMpCrCtlConDisconnect(pDataCon->pCtl, pDataCon->u32ClientID);
     64    if (RT_SUCCESS(rc))
     65    {
     66        /* sanity */
     67        pDataCon->pCtl = NULL;
     68        pDataCon->u32ClientID = 0;
     69        return VINF_SUCCESS;
     70    }
     71    WARN(("VBoxMpCrCtlConDisconnect failed, rc %d", rc));
     72    return rc;
     73}
     74
     75typedef struct VBOXMP_CRSHGSMICON_BUFDR
     76{
     77    uint32_t cbBuf;
     78    void *pvBuf;
     79} VBOXMP_CRSHGSMICON_BUFDR, *PVBOXMP_CRSHGSMICON_BUFDR;
     80
     81typedef struct VBOXMP_CRSHGSMICON_BUFDR_CACHE
     82{
     83    volatile PVBOXMP_CRSHGSMICON_BUFDR pBufDr;
     84} VBOXMP_CRSHGSMICON_BUFDR_CACHE, *PVBOXMP_CRSHGSMICON_BUFDR_CACHE;
     85
     86typedef struct VBOXMP_CRSHGSMITRANSPORT
     87{
     88    PVBOXMP_DEVEXT pDevExt;
     89    VBOXMP_CRSHGSMICON_BUFDR_CACHE WbDrCache;
     90} VBOXMP_CRSHGSMITRANSPORT, *PVBOXMP_CRSHGSMITRANSPORT;
     91
     92/** the rx buffer passed here is only valid in the context of the callback.
     93 * the callee must NOT free it or use outside of the callback context.
     94 * */
     95typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvRx, uint32_t cbRx, void *pvCtx);
     96typedef FNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION *PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION;
     97
     98typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvCtx);
     99typedef FNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION *PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION;
     100
     101int VBoxMpCrShgsmiTransportCreate(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_DEVEXT pDevExt);
     102void VBoxMpCrShgsmiTransportTerm(PVBOXMP_CRSHGSMITRANSPORT pCon);
     103void* VBoxMpCrShgsmiTransportCmdCreateWriteReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
     104        PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion, uint32_t cbContextData);
     105void* VBoxMpCrShgsmiTransportCmdCreateWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
     106        PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion, uint32_t cbContextData);
     107int VBoxMpCrShgsmiTransportCmdSubmitWriteReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext);
     108int VBoxMpCrShgsmiTransportCmdSubmitWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext);
     109void VBoxMpCrShgsmiTransportCmdTermWriteReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext);
     110void VBoxMpCrShgsmiTransportCmdTermWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext);
     111
     112void* VBoxMpCrShgsmiTransportBufAlloc(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t cbBuffer);
     113void VBoxMpCrShgsmiTransportBufFree(PVBOXMP_CRSHGSMITRANSPORT pCon, void* pvBuffer);
     114
     115typedef struct VBOXMP_CRPACKER
     116{
     117    CRPackContext CrPacker;
     118    CRPackBuffer CrBuffer;
     119} VBOXMP_CRPACKER, *PVBOXMP_CRPACKER;
     120
     121DECLINLINE(void) VBoxMpCrPackerInit(PVBOXMP_CRPACKER pPacker)
     122{
     123    memset(pPacker, 0, sizeof (*pPacker));
     124}
     125
     126DECLINLINE(void) VBoxMpCrPackerTerm(PVBOXMP_CRPACKER pPacker)
     127{}
     128
     129DECLINLINE(void) VBoxMpCrPackerTxBufferInit(PVBOXMP_CRPACKER pPacker, void *pvBuffer, uint32_t cbBuffer, uint32_t cCommands)
     130{
     131    crPackInitBuffer(&pPacker->CrBuffer, pvBuffer, cbBuffer, cbBuffer, cCommands);
     132    crPackSetBuffer(&pPacker->CrPacker, &pPacker->CrBuffer);
     133}
     134
     135DECLINLINE(CRMessageOpcodes*) vboxMpCrPackerPrependHeader( const CRPackBuffer *pBuffer, uint32_t *cbData, void **ppvPackBuffer)
     136{
     137    UINT num_opcodes;
     138    CRMessageOpcodes *hdr;
     139
     140    Assert(pBuffer);
     141    Assert(pBuffer->opcode_current < pBuffer->opcode_start);
     142    Assert(pBuffer->opcode_current >= pBuffer->opcode_end);
     143    Assert(pBuffer->data_current > pBuffer->data_start);
     144    Assert(pBuffer->data_current <= pBuffer->data_end);
     145
     146    num_opcodes = (UINT)(pBuffer->opcode_start - pBuffer->opcode_current);
     147    hdr = (CRMessageOpcodes *)
     148        ( pBuffer->data_start - ( ( num_opcodes + 3 ) & ~0x3 ) - sizeof(*hdr) );
     149
     150    Assert((void *) hdr >= pBuffer->pack);
     151
     152    hdr->header.type = CR_MESSAGE_OPCODES;
     153    hdr->numOpcodes  = num_opcodes;
     154
     155    *cbData = (UINT)(pBuffer->data_current - (unsigned char *) hdr);
     156    *ppvPackBuffer = pBuffer->pack;
     157
     158    return hdr;
     159}
     160
     161DECLINLINE(void*) VBoxMpCrPackerTxBufferComplete(PVBOXMP_CRPACKER pPacker, uint32_t *pcbBuffer, void **ppvPackBuffer)
     162{
     163    crPackReleaseBuffer(&pPacker->CrPacker);
     164    uint32_t cbData;
     165    CRMessageOpcodes *pHdr;
     166    void *pvPackBuffer;
     167    if (pPacker->CrBuffer.opcode_current != pPacker->CrBuffer.opcode_start)
     168        pHdr = vboxMpCrPackerPrependHeader(&pPacker->CrBuffer, &cbData, &pvPackBuffer);
     169    else
     170    {
     171        cbData = 0;
     172        pHdr = NULL;
     173        pvPackBuffer = NULL;
     174    }
     175    *pcbBuffer = cbData;
     176    *ppvPackBuffer = pvPackBuffer;
     177    return pHdr;
     178}
     179
     180DECLINLINE(uint32_t) VBoxMpCrPackerTxBufferGetFreeBufferSize(PVBOXMP_CRPACKER pPacker)
     181{
     182    return (uint32_t)(pPacker->CrBuffer.data_end - pPacker->CrBuffer.data_start);
     183}
     184
     185DECLINLINE(void) vboxMpCrUnpackerRxWriteback(CRMessageWriteback *pWb)
     186{
     187    int *pWriteback;
     188    memcpy(&pWriteback, &(pWb->writeback_ptr), sizeof (pWriteback));
     189    (*pWriteback)--;
     190}
     191
     192DECLINLINE(void) vboxMpCrUnpackerRxReadback(CRMessageReadback *pRb, uint32_t cbRx)
     193{
     194    int cbPayload = cbRx - sizeof (*pRb);
     195    int *pWriteback;
     196    void *pDst;
     197    memcpy(&pWriteback, &(pRb->writeback_ptr), sizeof (pWriteback));
     198    memcpy(&pDst, &(pRb->readback_ptr), sizeof (pDst));
     199
     200    (*pWriteback)--;
     201    memcpy(pDst, ((uint8_t*)pRb) + sizeof (*pRb), cbPayload);
     202}
     203
     204DECLINLINE(int) VBoxMpCrUnpackerRxBufferProcess(void *pvBuffer, uint32_t cbBuffer)
     205{
     206    CRMessage *pMsg = (CRMessage*)pvBuffer;
     207    switch (pMsg->header.type)
     208    {
     209        case CR_MESSAGE_WRITEBACK:
     210            vboxMpCrUnpackerRxWriteback(&(pMsg->writeback));
     211            return VINF_SUCCESS;
     212        case CR_MESSAGE_READBACK:
     213            vboxMpCrUnpackerRxReadback(&(pMsg->readback), cbBuffer);
     214            return VINF_SUCCESS;
     215        default:
     216            WARN(("unknown msg code %d", pMsg->header.type));
     217            return VERR_NOT_SUPPORTED;
     218    }
     219}
     220
     221#define VBOXMP_CRCMD_SIZE_WINDOWPOSITION 20
     222#define VBOXMP_CRCMD_SIZE_WINDOWVISIBLEREGIONS(_cRects) (16 + _cRects * 4 * sizeof(GLint))
     223
     224#endif
    39225#endif /* #ifndef ___VBoxMPCr_h__ */

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

    r43341 r43489  
    313313    vboxWddmSwapchainAllocRemoveAllInternal(pDevExt, pSwapchain, TRUE);
    314314
     315#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    315316    Assert(pSwapchain->pContext);
    316317    if (pSwapchain->pContext)
    … …  
    322323        }
    323324    }
     325#endif
    324326
    325327    vboxWddmSwapchainRelease(pSwapchain);
    … …  
    357359{
    358360    BOOLEAN bRc;
    359     ExAcquireFastMutex(&pDevExt->ContextMutex);
     361    VBOXWDDM_CTXLOCK_DATA
     362    VBOXWDDM_CTXLOCK_LOCK(pDevExt);
    360363    bRc = vboxWddmSwapchainCtxAddLocked(pDevExt, pContext, pSwapchain);
    361     ExReleaseFastMutex(&pDevExt->ContextMutex);
     364    VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
    362365    return bRc;
    363366}
    … …  
    367370VOID vboxWddmSwapchainCtxRemove(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain)
    368371{
    369     ExAcquireFastMutex(&pDevExt->ContextMutex);
     372    VBOXWDDM_CTXLOCK_DATA
     373    VBOXWDDM_CTXLOCK_LOCK(pDevExt);
    370374    vboxWddmSwapchainCtxRemoveLocked(pDevExt, pContext, pSwapchain);
    371     ExReleaseFastMutex(&pDevExt->ContextMutex);
     375    VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
    372376}
    373377
    … …  
    377381{
    378382    VBOXWDDM_HTABLE_ITERATOR Iter;
     383    VBOXWDDM_CTXLOCK_DATA
    379384    do
    380385    {
    381         ExAcquireFastMutex(&pDevExt->ContextMutex);
     386        VBOXWDDM_CTXLOCK_LOCK(pDevExt);
    382387        vboxWddmHTableIterInit(&pContext->Swapchains, &Iter);
    383388        PVBOXWDDM_SWAPCHAIN pSwapchain = (PVBOXWDDM_SWAPCHAIN)vboxWddmHTableIterNext(&Iter, NULL);
    … …  
    388393        vboxWddmSwapchainCtxRemoveLocked(pDevExt, pContext, pSwapchain);
    389394
    390         ExReleaseFastMutex(&pDevExt->ContextMutex);
     395        VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
    391396        /* we must not do vboxWddmSwapchainDestroy inside a context mutex */
    392397        vboxWddmSwapchainDestroy(pDevExt, pSwapchain);
    … …  
    395400
    396401    /* no swapchains left, we exiteed the while loop via the "break", and we still owning the mutex */
    397     ExReleaseFastMutex(&pDevExt->ContextMutex);
     402    VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
    398403}
    399404
    … …  
    412417    Assert(KeGetCurrentIrql() == PASSIVE_LEVEL);
    413418    NTSTATUS Status = STATUS_SUCCESS;
     419    VBOXWDDM_CTXLOCK_DATA
    414420
    415421    do {
    … …  
    453459        if (pSwapchainInfo->SwapchainInfo.hSwapchainKm)
    454460        {
    455             ExAcquireFastMutex(&pDevExt->ContextMutex);
     461            VBOXWDDM_CTXLOCK_LOCK(pDevExt);
    456462            pSwapchain = (PVBOXWDDM_SWAPCHAIN)vboxWddmHTableGet(&pContext->Swapchains, (VBOXWDDM_HANDLE)pSwapchainInfo->SwapchainInfo.hSwapchainKm);
    457463            Assert(pSwapchain);
    458464            if (!pSwapchain)
    459465            {
    460                 ExReleaseFastMutex(&pDevExt->ContextMutex);
     466                VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
    461467                Status = STATUS_INVALID_PARAMETER;
    462468                break;
    … …  
    466472            if (pSwapchain->pContext != pContext)
    467473            {
    468                 ExReleaseFastMutex(&pDevExt->ContextMutex);
     474                VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
    469475                Status = STATUS_INVALID_PARAMETER;
    470476                break;
    … …  
    480486            }
    481487
    482             ExAcquireFastMutex(&pDevExt->ContextMutex);
     488            VBOXWDDM_CTXLOCK_LOCK(pDevExt);
    483489            BOOLEAN bRc = vboxWddmSwapchainCtxAddLocked(pDevExt, pContext, pSwapchain);
    484490            Assert(bRc);
    … …  
    510516        }
    511517
    512         ExReleaseFastMutex(&pDevExt->ContextMutex);
     518        VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
    513519
    514520        if (pSwapchainInfo->SwapchainInfo.cAllocs)
    … …  
    12411247    UINT cbCmd = VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[cBuffers]));
    12421248
    1243     PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, cbCmd);
     1249    PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
    12441250    if (pDr)
    12451251    {

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

    r42081 r43489  
    236236    BOOLEAN fRenderFromShadowDisabled;
    237237    uint32_t u32CrConClientID;
     238#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     239    VBOXMP_CRPACKER CrPacker;
     240#endif
    238241    VBOXWDDM_HTABLE Swapchains;
    239242    VBOXVIDEOCM_CTX CmContext;

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

    r42158 r43489  
    383383 * @param pDevExt
    384384 */
    385 static NTSTATUS vboxVdmaGgDirtyRectsProcess(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain, RECT *pSrcRect, VBOXVDMAPIPE_RECTS *pContextRects)
     385static NTSTATUS vboxVdmaGgDirtyRectsProcess(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain, RECT *pSrcRect, VBOXVDMAPIPE_RECTS *pContextRects
     386#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     387        , PVBOXMP_CRPACKER pPacker
     388#endif
     389        )
    386390{
    387391    PVBOXWDDM_RECTS_INFO pRects = &pContextRects->UpdateRects;
    388392    NTSTATUS Status = STATUS_SUCCESS;
     393#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    389394    PVBOXVIDEOCM_CMD_RECTS_INTERNAL pCmdInternal = NULL;
     395#else
     396    void *pvCommandBuffer = NULL;
     397#endif
    390398    uint32_t cbCmdInternal = VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pRects->cRects);
    391399    BOOLEAN fCurChanged = FALSE, fCurRectChanged = FALSE;
    392400    POINT CurPos;
    393401    Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
    394 
    395     ExAcquireFastMutex(&pDevExt->ContextMutex);
     402    VBOXWDDM_CTXLOCK_DATA
     403
     404    VBOXWDDM_CTXLOCK_LOCK(pDevExt);
    396405
    397406    if (pSwapchain)
    … …  
    426435    }
    427436
     437#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    428438    /* before posting the add visible rects diff, we need to first hide rects for other windows */
    429439
    … …  
    470480        }
    471481    }
    472 
     482#endif
    473483    if (!pSwapchain)
    474484        goto done;
    … …  
    476486    RECT *pVisRects;
    477487
     488#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     489    uint32_t cbCommandBuffer = 0, cCommands = 0;
     490    ++cCommand;
     491    cbCommandBuffer += VBOXMP_CRCMD_SIZE_WINDOWVISIBLEREGIONS(pRects->cRects);
     492#endif
    478493    if (fCurRectChanged && fCurChanged)
    479494    {
     495#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     496        ++cCommand;
     497        cbCommandBuffer += VBOXMP_CRCMD_SIZE_WINDOWPOSITION;
     498
     499        pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommand);
     500        if (!pvCommandBuffer)
     501        {
     502            WARN(("VBoxMpCrShgsmiTransportBufAlloc failed!"));
     503            Status = STATUS_NO_MEMORY;
     504            goto done;
     505        }
     506        VBoxMpCrPackerTxBufferInit(pPacker,pvCommandBuffer, cbCommandBuffer, cCommands);
     507        crPackWindowPosition(&pPacker->CrPacker, window, CurPos.x, CurPos.y);
     508#else
    480509        cbCmdInternal = VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pRects->cRects + 1);
    481510        if (pCmdInternal)
    … …  
    491520        pCmdInternal->Cmd.RectsInfo.aRects[0].bottom = CurPos.y + pSwapchain->height;
    492521        pVisRects = &pCmdInternal->Cmd.RectsInfo.aRects[1];
    493     }
     522#endif
     523    }
     524#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    494525    else
    495526    {
    … …  
    523554    vboxVideoCmCmdSubmit(pCmdInternal, VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pCmdInternal->Cmd.RectsInfo.cRects));
    524555    pCmdInternal = NULL;
     556#else
     557    if (!pvCommandBuffer)
     558    {
     559        pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommand);
     560        if (!pvCommandBuffer)
     561        {
     562            WARN(("VBoxMpCrShgsmiTransportBufAlloc failed!"));
     563            Status = STATUS_NO_MEMORY;
     564            goto done;
     565        }
     566        VBoxMpCrPackerTxBufferInit(pPacker,pvCommandBuffer, cbCommandBuffer, cCommands);
     567    }
     568    crPackWindowVisibleRegion(&pPacker->CrPacker, window, pRects->cRects, (GLint*)pRects->aRects);
     569#endif
    525570
    526571done:
    527     ExReleaseFastMutex(&pDevExt->ContextMutex);
    528 
     572    VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
     573
     574#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    529575    if (pCmdInternal)
    530576        vboxVideoCmCmdRelease(pCmdInternal);
    531 
     577#endif
    532578    return Status;
    533579}
    … …  
    747793}
    748794
    749 static NTSTATUS vboxVdmaGgDmaCmdProcessFast(PVBOXMP_DEVEXT pDevExt, VBOXVDMAPIPE_CMD_DMACMD *pDmaCmd)
     795static NTSTATUS vboxVdmaGgDmaCmdProcessFast(PVBOXMP_DEVEXT pDevExt
     796#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     797        , VBOXVDMAPIPE_CMD_DMACMD *pDmaCmd
     798#else
     799        , PVBOXWDDM_CONTEXT pContext
     800        , PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR *pDmaCmd
     801        , VBOXVDMAPIPE_FLAGS_DMACMD fFlags
     802        , uint32_t u32FenceId
     803#endif
     804        )
    750805{
    751806    NTSTATUS Status = STATUS_SUCCESS;
     807    DXGK_INTERRUPT_TYPE enmComplType = DXGK_INTERRUPT_DMA_COMPLETED;
     808#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    752809    PVBOXWDDM_CONTEXT pContext = pDmaCmd->pContext;
    753     DXGK_INTERRUPT_TYPE enmComplType = DXGK_INTERRUPT_DMA_COMPLETED;
     810    VBOXVDMAPIPE_FLAGS_DMACMD fFlags = pDmaCmd->fFlags;
     811#else
     812    BOOLEAN fCompleteCmd = TRUE;
     813#endif
    754814    switch (pDmaCmd->enmCmd)
    755815    {
    756816        case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT:
    757817        {
     818#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    758819            PVBOXVDMAPIPE_CMD_DMACMD_BLT pBlt = (PVBOXVDMAPIPE_CMD_DMACMD_BLT)pDmaCmd;
     820#else
     821            PVBOXWDDM_DMA_PRIVATEDATA_BLT pBlt = (PVBOXWDDM_DMA_PRIVATEDATA_BLT)pDmaCmd;
     822#endif
    759823            PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
    760824            PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
    761825
    762             if (pBlt->Hdr.fFlags.fRealOp)
     826            if (fFlags.fRealOp)
    763827            {
    764828                vboxVdmaGgDmaBlt(pDevExt, &pBlt->Blt);
    … …  
    790854            }
    791855
    792             if (pBlt->Hdr.fFlags.fVisibleRegions)
     856            if (fFlags.fVisibleRegions)
    793857            {
     858#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    794859                Status = STATUS_MORE_PROCESSING_REQUIRED;
    795860                vboxWddmAllocationRetain(pDstAlloc);
    796861                vboxWddmAllocationRetain(pSrcAlloc);
     862#else
     863                Status = vboxVdmaGgDmaCmdProcessSlow(pDevExt, pContext, pDmaCmd, fFlags, u32FenceId);
     864                fCompleteCmd = FALSE;
     865#endif
    797866            }
    798867            break;
    … …  
    801870        case VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP:
    802871        {
     872#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    803873            PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlip = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)pDmaCmd;
    804             Assert(pFlip->Hdr.fFlags.fVisibleRegions);
    805             Assert(!pFlip->Hdr.fFlags.fRealOp);
     874#else
     875            PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlip = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)pDmaCmd;
     876#endif
     877            Assert(fFlags.fVisibleRegions);
     878            Assert(!fFlags.fRealOp);
    806879            PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
    807880            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
    808881            vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
    809             if (pFlip->Hdr.fFlags.fVisibleRegions)
     882            if (fFlags.fVisibleRegions)
    810883            {
     884#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    811885                Status = STATUS_MORE_PROCESSING_REQUIRED;
    812886                vboxWddmAllocationRetain(pFlip->Flip.Alloc.pAlloc);
     887#else
     888                Status = vboxVdmaGgDmaCmdProcessSlow(pDevExt, pContext, pDmaCmd, fFlags, u32FenceId);
     889                fCompleteCmd = FALSE;
     890#endif
    813891            }
    814892
    … …  
    817895        case VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL:
    818896        {
     897#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    819898            PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCF = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)pDmaCmd;
    820             Assert(pCF->Hdr.fFlags.fRealOp);
    821             Assert(!pCF->Hdr.fFlags.fVisibleRegions);
     899#else
     900            PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pDmaCmd;
     901#endif
     902            Assert(fFlags.fRealOp);
     903            Assert(!fFlags.fVisibleRegions);
    822904            Status = vboxVdmaGgDmaColorFill(pDevExt, pCF);
    823905            Assert(Status == STATUS_SUCCESS);
    … …  
    830912    }
    831913
     914#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    832915    /* Corresponding Release is done by dma command completion handler */
    833916    vboxVdmaGgCmdAddRef(&pDmaCmd->Hdr);
    … …  
    841924        Status = tmpStatus;
    842925    }
    843 
     926#else
     927    if (fCompleteCmd)
     928        Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, u32FenceId, enmComplType);
     929#endif
    844930    return Status;
    845931}
    846932
    847 static NTSTATUS vboxVdmaGgDmaCmdProcessSlow(PVBOXMP_DEVEXT pDevExt, VBOXVDMAPIPE_CMD_DMACMD *pDmaCmd)
     933#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     934typedef struct VBOXMP_VDMACR_WRITECOMPLETION
     935{
     936    void *pvBufferToFree;
     937} VBOXMP_VDMACR_WRITECOMPLETION, *PVBOXMP_VDMACR_WRITECOMPLETION;
     938
     939static DECLCALLBACK(void) vboxVdmaCrWriteCompletion(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvCtx)
     940{
     941    PVBOXMP_VDMACR_WRITECOMPLETION pData = (PVBOXMP_VDMACR_WRITECOMPLETION)pvCtx;
     942    void* pvBufferToFree = pData->pvBufferToFree;
     943    if (pvBufferToFree)
     944        VBoxMpCrShgsmiTransportBufFree(pCon, pvBufferToFree);
     945
     946    VBoxMpCrShgsmiTransportCmdTermWriteAsync(pCon, pvCtx);
     947}
     948#endif
     949
     950static NTSTATUS vboxVdmaGgDmaCmdProcessSlow(PVBOXMP_DEVEXT pDevExt
     951#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     952        , VBOXVDMAPIPE_CMD_DMACMD *pDmaCmd
     953#else
     954        , PVBOXWDDM_CONTEXT pContext
     955        , PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR *pDmaCmd
     956        , VBOXVDMAPIPE_FLAGS_DMACMD fFlags
     957        , uint32_t u32FenceId
     958#endif
     959        )
    848960{
    849961    NTSTATUS Status = STATUS_SUCCESS;
     962#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    850963    PVBOXWDDM_CONTEXT pContext = pDmaCmd->pContext;
     964    VBOXVDMAPIPE_FLAGS_DMACMD fFlags = pDmaCmd->fFlags;
     965#else
     966    PVBOXMP_CRPACKER pPacker = &pContext->CrPacker;
     967#endif
    851968    DXGK_INTERRUPT_TYPE enmComplType = DXGK_INTERRUPT_DMA_COMPLETED;
    852969
    853     Assert(pDmaCmd->fFlags.Value);
    854     Assert(!pDmaCmd->fFlags.fRealOp);
     970    Assert(fFlags.Value);
     971    Assert(!fFlags.fRealOp);
    855972
    856973    switch (pDmaCmd->enmCmd)
    … …  
    865982            Assert(pDstAlloc->AllocData.SurfDesc.VidPnSourceId < VBOX_VIDEO_MAX_SCREENS);
    866983
    867             if (pBlt->Hdr.fFlags.fVisibleRegions)
     984            if (fFlags.fVisibleRegions)
    868985            {
    869986                PVBOXWDDM_SWAPCHAIN pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pSrcAlloc);
    … …  
    875992                }
    876993
    877                 Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, pSwapchain, &pBlt->Blt.SrcRect, &pBlt->Blt.DstRects);
     994                Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, pSwapchain, &pBlt->Blt.SrcRect, &pBlt->Blt.DstRects
     995#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     996                        , pPacker
     997#endif
     998                        );
    878999                Assert(Status == STATUS_SUCCESS);
    8791000
    … …  
    8861007            }
    8871008
     1009#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    8881010            vboxWddmAllocationRelease(pDstAlloc);
    8891011            vboxWddmAllocationRelease(pSrcAlloc);
     1012#endif
    8901013
    8911014            break;
    … …  
    8971020            PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
    8981021            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
    899             if (pFlip->Hdr.fFlags.fVisibleRegions)
     1022            if (fFlags.fVisibleRegions)
    9001023            {
    9011024                PVBOXWDDM_SWAPCHAIN pSwapchain;
    … …  
    9161039                    Rects.UpdateRects.cRects = 1;
    9171040                    Rects.UpdateRects.aRects[0] = Rects.ContextRect;
    918                     Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, pSwapchain, &SrcRect, &Rects);
     1041                    Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, pSwapchain, &SrcRect, &Rects
     1042#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     1043                        , pPacker
     1044#endif
     1045                            );
    9191046                    Assert(Status == STATUS_SUCCESS);
    9201047                    vboxWddmSwapchainRelease(pSwapchain);
    … …  
    9261053            }
    9271054
     1055#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    9281056            vboxWddmAllocationRelease(pAlloc);
     1057#endif
    9291058
    9301059            break;
    … …  
    9381067    }
    9391068
     1069#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    9401070    vboxVdmaGgCmdRelease(pDevExt, &pDmaCmd->Hdr);
     1071#else
     1072    uint32_t cbBuffer
     1073    void * pvPackBuffer;
     1074    void * pvBuffer = VBoxMpCrPackerTxBufferComplete(pPacker, &cbBuffer, &pvPackBuffer);
     1075    if (pvBuffer)
     1076    {
     1077        PVBOXMP_VDMACR_WRITECOMPLETION pvCompletionData = VBoxMpCrShgsmiTransportCmdCreateWriteAsync(&pDevExt->CrHgsmiTransport, pContext->u32CrConClientID, pvBuffer, cbBuffer,
     1078                vboxVdmaCrWriteCompletion, sizeof (*pvCompletionData));
     1079        if (pvCompletionData)
     1080        {
     1081            int rc = VBoxMpCrShgsmiTransportCmdSubmitWriteAsync(&pDevExt->CrHgsmiTransport, pvCompletionData);
     1082            if (!RT_SUCCESS(rc))
     1083            {
     1084                WARN(("VBoxMpCrShgsmiTransportCmdSubmitWriteAsync failed, rc %d", rc));
     1085                Status = STATUS_UNSUCCESSFUL;
     1086            }
     1087        }
     1088        else
     1089        {
     1090            WARN(("VBoxMpCrShgsmiTransportCmdCreateWriteAsync failed"));
     1091            Status = STATUS_NO_MEMORY;
     1092        }
     1093    }
     1094
     1095    Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, u32FenceId, DXGK_INTERRUPT_DMA_COMPLETED);
     1096    if (!NT_SUCCESS(Status))
     1097    {
     1098        WARN(("vboxVdmaDdiCmdFenceComplete failed, Status 0x%x", Status));
     1099    }
     1100#endif
    9411101
    9421102    return Status;
    9431103}
    9441104
     1105#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    9451106static DECLCALLBACK(UINT) vboxVdmaGgCmdCancelVisitor(PVBOXVIDEOCM_CTX pContext, PVOID pvCmd, uint32_t cbCmd, PVOID pvVisitor)
    9461107{
    … …  
    10911252            break;
    10921253    }
    1093     /* correspondinf Release is done by the pipe command handler */
     1254    /* corresponding Release is done by the pipe command handler */
    10941255    vboxVdmaGgCmdAddRef(pCmd);
    10951256    return vboxVdmaPipeCltCmdPut(&pDevExt->u.primary.Vdma.DmaGg.CmdPipe, &pCmd->PipeHdr);
    … …  
    11931354    return Status;
    11941355}
     1356#else /* if defined VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS */
     1357NTSTATUS vboxVdmaGgCmdProcess(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAPIPE_CMD_DR pCmd)
     1358{
     1359    switch (pCmd->enmType)
     1360    {
     1361        case VBOXVDMAPIPE_CMD_TYPE_DMACMD:
     1362        {
     1363            PVBOXVDMAPIPE_CMD_DMACMD pDmaCmd = (PVBOXVDMAPIPE_CMD_DMACMD)pCmd;
     1364            NTSTATUS Status = vboxVdmaGgDmaCmdProcessFast(pDevExt, pDmaCmd);
     1365            if (Status == STATUS_MORE_PROCESSING_REQUIRED)
     1366                break;
     1367            return Status;
     1368        }
     1369        default:
     1370            break;
     1371    }
     1372    /* corresponding Release is done by the pipe command handler */
     1373    vboxVdmaGgCmdAddRef(pCmd);
     1374    return vboxVdmaPipeCltCmdPut(&pDevExt->u.primary.Vdma.DmaGg.CmdPipe, &pCmd->PipeHdr);
     1375}
     1376
     1377#endif
    11951378
    11961379/* end */

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

    r42154 r43489  
    341341        vboxVdmaGgCmdDestroy(pDevExt, pDr);
    342342}
     343#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    343344NTSTATUS vboxVdmaGgCmdFinish(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, PKEVENT pEvent);
    344345NTSTATUS vboxVdmaGgCmdCancel(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, PVBOXWDDM_SWAPCHAIN pSwapchain);
     346#endif
    345347
    346348NTSTATUS vboxVdmaPostHideSwapchain(PVBOXWDDM_SWAPCHAIN pSwapchain);

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

    r43286 r43489  
    11221122                    pDevExt->cContexts2D = 0;
    11231123                    pDevExt->cUnlockedVBVADisabled = 0;
    1124                     ExInitializeFastMutex(&pDevExt->ContextMutex);
     1124                    VBOXWDDM_CTXLOCK_INIT(pDevExt);
    11251125                    KeInitializeSpinLock(&pDevExt->SynchLock);
    11261126
    … …  
    11371137#endif
    11381138                    VBoxWddmSlInit(pDevExt);
     1139
     1140#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     1141                    VBoxMpCrShgsmiTransportCreate(&pDevExt->CrHgsmiTransport, pDevExt);
     1142#endif
    11391143
    11401144                    for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    … …  
    12261230    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
    12271231    NTSTATUS Status = STATUS_SUCCESS;
     1232
     1233#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     1234    VBoxMpCrShgsmiTransportTerm(&pDevExt->CrHgsmiTransport);
     1235#endif
    12281236
    12291237    VBoxWddmSlTerm(pDevExt);
    … …  
    61376145                                            pInfo->crVersionMajor, pInfo->crVersionMinor,
    61386146                                            &pContext->u32CrConClientID);
    6139                                         if (!RT_SUCCESS(rc))
     6147                                        if (RT_SUCCESS(rc))
     6148                                        {
     6149#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     6150                                            VBoxMpCrPackerInit(&pContext->CrPacker);
     6151#endif
     6152                                        }
     6153                                        else
    61406154                                        {
    61416155                                            WARN(("VBoxMpCrCtlConConnect failed rc (%d)", rc));

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

    r42158 r43489  
    215215#endif
    216216
     217#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     218# define VBOXWDDM_CTXLOCK_INIT(_p) do { \
     219        KeInitializeSpinLock(&(_p)->ContextLock); \
     220    } while (0)
     221# define VBOXWDDM_CTXLOCK_DATA KIRQL _ctxLockOldIrql;
     222# define VBOXWDDM_CTXLOCK_LOCK(_p) do { \
     223        KeAcquireSpinLock(&(_p)->ContextLock, &_ctxLockOldIrql); \
     224    } while (0)
     225# define VBOXWDDM_CTXLOCK_UNLOCK(_p) do { \
     226        KeReleaseSpinLock(&(_p)->ContextLock, _ctxLockOldIrql); \
     227    } while (0)
     228#else
     229# define VBOXWDDM_CTXLOCK_INIT(_p) do { \
     230        ExInitializeFastMutex(&(_p)->ContextMutex); \
     231    } while (0)
     232# define VBOXWDDM_CTXLOCK_LOCK(_p) do { \
     233        ExAcquireFastMutex(&(_p)->ContextMutex); \
     234    } while (0)
     235# define VBOXWDDM_CTXLOCK_UNLOCK(_p) do { \
     236        ExReleaseFastMutex(&(_p)->ContextMutex); \
     237    } while (0)
     238# define VBOXWDDM_CTXLOCK_DATA
     239#endif
     240
    217241#endif /* #ifndef ___VBoxMPWddm_h___ */
    218242
Note: See TracChangeset for help on using the changeset viewer.

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