VirtualBox

Changeset 63053 in vbox for trunk/src


Ignore:
Timestamp:
Aug 5, 2016 3:36:51 PM (9 years ago)
Author:
vboxsync
Message:

GA/NT/Graphics: warnings

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

Legend:

Unmodified
Added
Removed

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

    r62522 r63053  
    11/* $Id$ */
    2 
    32/** @file
    43 * VBox WDDM Miniport driver
    … …  
    128127}
    129128
    130 static DECLCALLBACK(VOID) vboxVideoCmCmdCbSetEventAndDereference(PVBOXVIDEOCM_CTX pContext, PVBOXVIDEOCM_CMD_CTL_KM pCmd, PVOID pvContext)
    131 {
     129static DECLCALLBACK(VOID) vboxVideoCmCmdCbSetEventAndDereference(PVBOXVIDEOCM_CTX pContext, PVBOXVIDEOCM_CMD_CTL_KM pCmd,
     130                                                                 PVOID pvContext)
     131{
     132    RT_NOREF(pContext);
    132133    PKEVENT pEvent = (PKEVENT)pvContext;
    133134    KeSetEvent(pEvent, 0, FALSE);
    … …  
    221222}
    222223
    223 NTSTATUS vboxVideoCmCmdVisit(PVBOXVIDEOCM_CTX pContext, BOOLEAN bEntireSession, PFNVBOXVIDEOCMCMDVISITOR pfnVisitor, PVOID pvVisitor)
     224NTSTATUS vboxVideoCmCmdVisit(PVBOXVIDEOCM_CTX pContext, BOOLEAN bEntireSession, PFNVBOXVIDEOCMCMDVISITOR pfnVisitor,
     225                             PVOID pvVisitor)
    224226{
    225227    PVBOXVIDEOCM_SESSION pSession = pContext->pSession;
    … …  
    397399
    398400/* the session gets destroyed once the last context is removed from it */
    399 NTSTATUS vboxVideoCmSessionCreateLocked(PVBOXVIDEOCM_MGR pMgr, PVBOXVIDEOCM_SESSION *ppSession, PKEVENT pUmEvent, PVBOXVIDEOCM_CTX pContext)
     401NTSTATUS vboxVideoCmSessionCreateLocked(PVBOXVIDEOCM_MGR pMgr, PVBOXVIDEOCM_SESSION *ppSession, PKEVENT pUmEvent,
     402                                        PVBOXVIDEOCM_CTX pContext)
    400403{
    401404    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    … …  
    501504NTSTATUS vboxVideoCmTerm(PVBOXVIDEOCM_MGR pMgr)
    502505{
     506    RT_NOREF(pMgr);
    503507    Assert(IsListEmpty(&pMgr->SessionList));
    504508    return STATUS_SUCCESS;
    … …  
    565569    LIST_ENTRY DetachedPpList;
    566570    PLIST_ENTRY pCurEntry = NULL;
    567     uint32_t cbCmdsReturned = 0;
    568571    uint32_t cbRemainingCmds = 0;
    569572    uint32_t cbRemainingFirstCmd = 0;

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

    r63039 r63053  
    4545static VBOXVIDEOOFFSET vboxMpCrShgsmiBufferOffset(PVBOXMP_DEVEXT pDevExt, void *pvBuffer)
    4646{
    47     return (VBOXVIDEOOFFSET)HGSMIPointerToOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, (const HGSMIBUFFERHEADER *)pvBuffer);
     47    return (VBOXVIDEOOFFSET)HGSMIPointerToOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area,
     48                                                 (const HGSMIBUFFERHEADER *)pvBuffer);
    4849}
    4950
    … …  
    7879}
    7980
    80 static int vboxMpCrShgsmiBufCacheBufReinit(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, PVBOXMP_CRSHGSMICON_BUFDR pDr, uint32_t cbRequested)
    81 {
     81static int vboxMpCrShgsmiBufCacheBufReinit(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache,
     82                                           PVBOXMP_CRSHGSMICON_BUFDR pDr, uint32_t cbRequested)
     83{
     84    RT_NOREF(pCache);
    8285    if (pDr->cbBuf >= cbRequested)
    8386        return VINF_SUCCESS;
    … …  
    98101}
    99102
    100 static void vboxMpCrShgsmiBufCacheFree(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, PVBOXMP_CRSHGSMICON_BUFDR pDr)
     103static void vboxMpCrShgsmiBufCacheFree(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache,
     104                                       PVBOXMP_CRSHGSMICON_BUFDR pDr)
    101105{
    102106    if (ASMAtomicCmpXchgPtr(&pCache->pBufDr, pDr, NULL))
    … …  
    123127}
    124128
    125 static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAlloc(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
     129static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAlloc(PVBOXMP_CRSHGSMITRANSPORT pCon,
     130                                                             PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
    126131{
    127132    PVBOXMP_CRSHGSMICON_BUFDR pBufDr = vboxMpCrShgsmiBufCacheGetAllocDr(pCache);
    … …  
    136141}
    137142
    138 static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAllocAny(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
     143static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAllocAny(PVBOXMP_CRSHGSMITRANSPORT pCon,
     144                                                                PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
    139145{
    140146    PVBOXMP_CRSHGSMICON_BUFDR pBufDr = vboxMpCrShgsmiBufCacheGetAllocDr(pCache);
    … …  
    156162static int vboxMpCrShgsmiBufCacheInit(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
    157163{
     164    RT_NOREF(pCon);
    158165    memset(pCache, 0, sizeof (*pCache));
    159166    return VINF_SUCCESS;
    … …  
    171178    pCon->pDevExt = pDevExt;
    172179    return VINF_SUCCESS;
     180#if 0 /** @todo should this be unreachable? */
    173181    int rc;
    174182//    int rc = vboxMpCrShgsmiBufCacheInit(pCon, &pCon->CmdDrCache);
    … …  
    191199
    192200    return rc;
     201#endif
    193202}
    194203
    … …  
    224233
    225234
    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 
    233 
    234 #define VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) VBOXWDDM_ROUNDBOUND((VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[_cBuffers]))), 8)
    235 #define VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf) ( VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) + VBOXWDDM_ROUNDBOUND(_cbCmdBuf, 8))
    236 #define VBOXMP_CRSHGSMICON_DR_GET_CRCMD(_pDr) (VBOXVDMACMD_BODY((_pDr), VBOXVDMACMD_CHROMIUM_CMD))
    237 #define VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(_pDr, _cBuffers, _type) ((_type*)(((uint8_t*)(_pDr)) + VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers)))
    238 #define VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(_pDr, _cBuffers, _cbCmdBuf, _type) ((_type*)(((uint8_t*)(_pDr)) +  VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)))
    239 #define VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(_pCtx, _cBuffers, _cbCmdBuf) ((VBOXVDMACMD*)(((uint8_t*)(_pCtx)) -  VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)))
    240 #define VBOXMP_CRSHGSMICON_DR_SIZE(_cBuffers, _cbCmdBuf, _cbCtx) (VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf) + (_cbCtx))
    241 
    242 
    243 static int vboxMpCrShgsmiTransportCmdSubmitDr(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXVDMACBUF_DR pDr, PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete)
     235#define VBOXMP_CRSHGSMICON_CMD_CMDBUF_OFFSET(_cBuffers) \
     236    VBOXWDDM_ROUNDBOUND(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[_cBuffers]), 8)
     237#define VBOXMP_CRSHGSMICON_CMD_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)  \
     238    ( VBOXMP_CRSHGSMICON_CMD_CMDBUF_OFFSET(_cBuffers) + VBOXWDDM_ROUNDBOUND(_cbCmdBuf, 8))
     239#define VBOXMP_CRSHGSMICON_CMD_GET_CMDBUF(_pCmd, _cBuffers, _type)  \
     240    ((_type*)(((uint8_t*)(_pCmd)) + VBOXMP_CRSHGSMICON_CMD_CMDBUF_OFFSET(_cBuffers)))
     241#define VBOXMP_CRSHGSMICON_CMD_GET_CMDCTX(_pCmd, _cBuffers, _cbCmdBuf, _type)  \
     242    ((_type*)(((uint8_t*)(_pCmd)) +  VBOXMP_CRSHGSMICON_CMD_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)))
     243#define VBOXMP_CRSHGSMICON_CMD_GET_FROM_CMDCTX(_pCtx, _cBuffers, _cbCmdBuf, _type)  \
     244    ((_type*)(((uint8_t*)(_pCtx)) -  VBOXMP_CRSHGSMICON_CMD_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)))
     245#define VBOXMP_CRSHGSMICON_CMD_SIZE(_cBuffers, _cbCmdBuf, _cbCtx)  \
     246    (VBOXMP_CRSHGSMICON_CMD_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf) + (_cbCtx))
     247
     248
     249#define VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers)  \
     250    VBOXWDDM_ROUNDBOUND((VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[_cBuffers]))), 8)
     251#define VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)  \
     252    ( VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) + VBOXWDDM_ROUNDBOUND(_cbCmdBuf, 8))
     253#define VBOXMP_CRSHGSMICON_DR_GET_CRCMD(_pDr)  \
     254    (VBOXVDMACMD_BODY((_pDr), VBOXVDMACMD_CHROMIUM_CMD))
     255#define VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(_pDr, _cBuffers, _type)  \
     256    ((_type*)(((uint8_t*)(_pDr)) + VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers)))
     257#define VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(_pDr, _cBuffers, _cbCmdBuf, _type)  \
     258    ((_type*)(((uint8_t*)(_pDr)) +  VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)))
     259#define VBOXMP_CRSHGSMICON_DR_GET_FROM_CMDCTX(_pCtx, _cBuffers, _cbCmdBuf)  \
     260    ((VBOXVDMACMD*)(((uint8_t*)(_pCtx)) -  VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf)))
     261#define VBOXMP_CRSHGSMICON_DR_SIZE(_cBuffers, _cbCmdBuf, _cbCtx)  \
     262    (VBOXMP_CRSHGSMICON_DR_CMDCTX_OFFSET(_cBuffers, _cbCmdBuf) + (_cbCtx))
     263
     264
     265static int vboxMpCrShgsmiTransportCmdSubmitDr(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXVDMACBUF_DR pDr,
     266                                              PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete)
    244267{
    245268
    … …  
    259282}
    260283
    261 static int vboxMpCrShgsmiTransportCmdSubmitDmaCmd(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXVDMACMD pHdr, PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete)
     284static int vboxMpCrShgsmiTransportCmdSubmitDmaCmd(PVBOXMP_CRSHGSMITRANSPORT pCon, PVBOXVDMACMD pHdr,
     285                                                  PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete)
    262286{
    263287    PVBOXVDMACBUF_DR pDr = VBOXVDMACBUF_DR_FROM_TAIL(pHdr);
    … …  
    273297
    274298
    275 typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvRx, uint32_t cbRx, void *pvCtx);
     299typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc,
     300                                                                               void *pvRx, uint32_t cbRx, void *pvCtx);
    276301typedef FNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION *PFNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION;
    277302
    278 static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportSendReadAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd, PVOID pvContext)
    279 {
     303static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportSendReadAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd,
     304                                                                         PVOID pvContext)
     305{
     306    RT_NOREF(pDevExt);
    280307    /* we should be called from our DPC routine */
    281308    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
    … …  
    327354}
    328355
    329 static void* vboxMpCrShgsmiTransportCmdCreateReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, PVBOXVDMACBUF_DR pDr, uint32_t cbDrData, PVBOXMP_CRSHGSMICON_BUFDR pWbDr,
    330         PFNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
    331 {
     356static void* vboxMpCrShgsmiTransportCmdCreateReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, PVBOXVDMACBUF_DR pDr,
     357                                                       uint32_t cbDrData, PVBOXMP_CRSHGSMICON_BUFDR pWbDr,
     358                                                       PFNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION pfnCompletion,
     359                                                       uint32_t cbContextData)
     360{
     361    RT_NOREF(cbDrData);
    332362    const uint32_t cBuffers = 2;
    333363    const uint32_t cbCmd = VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (VBOXMP_CRHGSMICMD_READ), cbContextData);
    334     PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
    335364    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
    336365    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXMP_CRSHGSMICON_DR_GET_CRCMD(pHdr);
    … …  
    390419} VBOXMP_CRHGSMICON_WRR_COMPLETION_CTX, *PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX;
    391420
    392 static DECLCALLBACK(void) vboxMpCrShgsmiTransportSendWriteReadReadRepostCompletion(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvRx, uint32_t cbRx, void *pvCtx)
     421static DECLCALLBACK(void) vboxMpCrShgsmiTransportSendWriteReadReadRepostCompletion(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc,
     422                                                                                   void *pvRx, uint32_t cbRx, void *pvCtx)
    393423{
    394424    PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX pData = (PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX)pvCtx;
    … …  
    398428}
    399429
    400 static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportSendWriteReadAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd, PVOID pvContext)
    401 {
     430static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportSendWriteReadAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd,
     431                                                                              PVOID pvContext)
     432{
     433    RT_NOREF(pDevExt);
    402434    /* we should be called from our DPC routine */
    403435    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
    … …  
    439471            {
    440472                /* the Read Command is shorter than WriteRead, so just reuse the Write-Read descriptor here */
    441                 PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX pReadCtx = (PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX)vboxMpCrShgsmiTransportCmdCreateReadAsync(pCon, pCmd->hdr.u32ClientID,
    442                             pDr, VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITEREAD), 0),
    443                             pWbDr, vboxMpCrShgsmiTransportSendWriteReadReadRepostCompletion, sizeof (*pReadCtx));
     473                PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX pReadCtx;
     474                pReadCtx = (PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX)vboxMpCrShgsmiTransportCmdCreateReadAsync(pCon,
     475                                                    pCmd->hdr.u32ClientID,
     476                                                    pDr,
     477                                                    VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof(VBOXMP_CRHGSMICMD_WRITEREAD), 0),
     478                                                    pWbDr,
     479                                                    vboxMpCrShgsmiTransportSendWriteReadReadRepostCompletion,
     480                                                    sizeof(*pReadCtx));
    444481                pReadCtx->pfnCompletion = pfnCompletion;
    445482                pReadCtx->pvContext = pvCtx;
    … …  
    476513}
    477514
    478 static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportVdmaSendWriteAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd, PVOID pvContext)
    479 {
     515static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportVdmaSendWriteAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd,
     516                                                                              PVOID pvContext)
     517{
     518    RT_NOREF(pDevExt);
    480519    /* we should be called from our DPC routine */
    481520    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
    … …  
    516555static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportVbvaSendWriteAsyncCompletion(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext)
    517556{
     557    RT_NOREF(pHeap);
    518558    /* we should be called from our DPC routine */
    519559    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
    520560
    521561    PVBOXMP_CRSHGSMITRANSPORT pCon = (PVBOXMP_CRSHGSMITRANSPORT)pvContext;
    522     PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
    523562    VBOXCMDVBVA_CRCMD_CMD *pCmd;
    524563    int rc = VBoxCmdVbvaConCmdCompletionData(pvCmd, &pCmd);
    525564    const UINT cBuffers = 2;
    526565    Assert(pCmd->cBuffers == cBuffers);
    527     PVBOXMP_CRHGSMICMD_WRITE pWrData = VBOXMP_CRSHGSMICON_CMD_GET_CMDBUF(pCmd, cBuffers, VBOXMP_CRHGSMICMD_WRITE);
    528566    uint64_t*pu64Completion = VBOXMP_CRSHGSMICON_CMD_GET_CMDCTX(pCmd, cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITE), uint64_t);
    529567    PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion = (PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION)(*pu64Completion);
    … …  
    536574}
    537575
    538 void* VBoxMpCrShgsmiTransportCmdCreateWriteReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
    539         PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
     576void* VBoxMpCrShgsmiTransportCmdCreateWriteReadAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer,
     577                                                     uint32_t cbBuffer,
     578                                                     PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion,
     579                                                     uint32_t cbContextData)
    540580{
    541581    const uint32_t cBuffers = 3;
    … …  
    602642}
    603643
    604 static void * vboxMpCrShgsmiTransportCmdVbvaCreateWriteAsync(PVBOXMP_DEVEXT pDevExt, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer, PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
     644static void * vboxMpCrShgsmiTransportCmdVbvaCreateWriteAsync(PVBOXMP_DEVEXT pDevExt, uint32_t u32ClientID, void *pvBuffer,
     645                                                             uint32_t cbBuffer,
     646                                                             PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion,
     647                                                             uint32_t cbContextData)
    605648{
    606649    const uint32_t cBuffers = 2;
    … …  
    637680}
    638681
    639 void* vboxMpCrShgsmiTransportCmdVdmaCreateWriteAsync(PVBOXMP_DEVEXT pDevExt, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
    640         PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
     682void* vboxMpCrShgsmiTransportCmdVdmaCreateWriteAsync(PVBOXMP_DEVEXT pDevExt, uint32_t u32ClientID, void *pvBuffer,
     683                                                     uint32_t cbBuffer,
     684                                                     PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion,
     685                                                     uint32_t cbContextData)
    641686{
    642687    const uint32_t cBuffers = 2;
    … …  
    685730}
    686731
    687 void* VBoxMpCrShgsmiTransportCmdCreateWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer, uint32_t cbBuffer,
    688         PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion, uint32_t cbContextData)
     732void* VBoxMpCrShgsmiTransportCmdCreateWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t u32ClientID, void *pvBuffer,
     733                                                 uint32_t cbBuffer,
     734                                                 PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion,
     735                                                 uint32_t cbContextData)
    689736{
    690737    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
    691738    if (pDevExt->fCmdVbvaEnabled)
    692         return vboxMpCrShgsmiTransportCmdVbvaCreateWriteAsync(pDevExt, u32ClientID, pvBuffer, cbBuffer, pfnCompletion, cbContextData);
     739        return vboxMpCrShgsmiTransportCmdVbvaCreateWriteAsync(pDevExt, u32ClientID, pvBuffer, cbBuffer, pfnCompletion,
     740                                                              cbContextData);
    693741    return vboxMpCrShgsmiTransportCmdVdmaCreateWriteAsync(pDevExt, u32ClientID, pvBuffer, cbBuffer, pfnCompletion, cbContextData);
    694742}
    … …  
    709757{
    710758    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);
     759    VBOXCMDVBVA_CRCMD_CMD* pCmd = VBOXMP_CRSHGSMICON_CMD_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_WRITE) + 8,
     760                                                                         VBOXCMDVBVA_CRCMD_CMD);
    712761    return VBoxCmdVbvaConCmdSubmitAsync(pDevExt, pCmd, vboxMpCrShgsmiTransportVbvaSendWriteAsyncCompletion, pCon);
    713762}
    … …  
    728777static void vboxMpCrShgsmiTransportCmdVbvaTermWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext)
    729778{
    730     VBOXCMDVBVA_CRCMD_CMD* pCmd = VBOXMP_CRSHGSMICON_CMD_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_WRITE) + 8, VBOXCMDVBVA_CRCMD_CMD);
     779    VBOXCMDVBVA_CRCMD_CMD* pCmd = VBOXMP_CRSHGSMICON_CMD_GET_FROM_CMDCTX(pvContext, 2, sizeof (VBOXMP_CRHGSMICMD_WRITE) + 8,
     780                                                                         VBOXCMDVBVA_CRCMD_CMD);
    731781    VBoxCmdVbvaConCmdFree(pCon->pDevExt, pCmd);
    732782}
    … …  
    10151065int VBoxMpCrCtlConDisconnectVbva(PVBOXMP_DEVEXT pDevExt, PVBOXMP_CRCTLCON pCrCtlCon, uint32_t u32ClientID)
    10161066{
     1067    RT_NOREF(pDevExt, pCrCtlCon);
    10171068    Assert(!pCrCtlCon->hCrCtl);
    10181069    Assert(!pCrCtlCon->cCrCtlRefs);
    … …  
    11271178}
    11281179
    1129 #endif
     1180#endif /* VBOX_WITH_CROGL */

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

    r62522 r63053  
    11/* $Id$ */
    2 
    32/** @file
    43 * VBox WDDM Miniport driver
    … …  
    2120
    2221/* SHGSMI */
    23 DECLINLINE(void) vboxSHGSMICommandRetain (PVBOXSHGSMIHEADER pCmd)
     22DECLINLINE(void) vboxSHGSMICommandRetain(PVBOXSHGSMIHEADER pCmd)
    2423{
    2524    ASMAtomicIncU32(&pCmd->cRefs);
    2625}
    2726
    28 void vboxSHGSMICommandFree (PVBOXSHGSMI pHeap, PVBOXSHGSMIHEADER pCmd)
     27void vboxSHGSMICommandFree(PVBOXSHGSMI pHeap, PVBOXSHGSMIHEADER pCmd)
    2928{
    3029    VBoxSHGSMIHeapFree(pHeap, pCmd);
    3130}
    3231
    33 DECLINLINE(void) vboxSHGSMICommandRelease (PVBOXSHGSMI pHeap, PVBOXSHGSMIHEADER pCmd)
     32DECLINLINE(void) vboxSHGSMICommandRelease(PVBOXSHGSMI pHeap, PVBOXSHGSMIHEADER pCmd)
    3433{
    3534    uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
    … …  
    4140static DECLCALLBACK(void) vboxSHGSMICompletionSetEvent(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext)
    4241{
     42    RT_NOREF(pHeap, pvCmd);
    4343    RTSemEventSignal((RTSEMEVENT)pvContext);
    4444}
    … …  
    4646DECLCALLBACK(void) vboxSHGSMICompletionCommandRelease(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext)
    4747{
    48     vboxSHGSMICommandRelease (pHeap, VBoxSHGSMIBufferHeader(pvCmd));
     48    RT_NOREF(pvContext);
     49    vboxSHGSMICommandRelease(pHeap, VBoxSHGSMIBufferHeader(pvCmd));
    4950}
    5051
    5152/* do not wait for completion */
    52 DECLINLINE(const VBOXSHGSMIHEADER*) vboxSHGSMICommandPrepAsynch (PVBOXSHGSMI pHeap, PVBOXSHGSMIHEADER pHeader)
    53 {
     53DECLINLINE(const VBOXSHGSMIHEADER *) vboxSHGSMICommandPrepAsynch(PVBOXSHGSMI pHeap, PVBOXSHGSMIHEADER pHeader)
     54{
     55    RT_NOREF(pHeap);
    5456    /* ensure the command is not removed until we're processing it */
    5557    vboxSHGSMICommandRetain(pHeader);
    … …  
    5759}
    5860
    59 DECLINLINE(void) vboxSHGSMICommandDoneAsynch (PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
     61DECLINLINE(void) vboxSHGSMICommandDoneAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
    6062{
    6163    if(!(ASMAtomicReadU32((volatile uint32_t *)&pHeader->fFlags) & VBOXSHGSMI_FLAG_HG_ASYNCH))
    … …  
    6365        PFNVBOXSHGSMICMDCOMPLETION pfnCompletion = (PFNVBOXSHGSMICMDCOMPLETION)pHeader->u64Info1;
    6466        if (pfnCompletion)
    65             pfnCompletion(pHeap, VBoxSHGSMIBufferData (pHeader), (PVOID)pHeader->u64Info2);
     67            pfnCompletion(pHeap, VBoxSHGSMIBufferData(pHeader), (PVOID)pHeader->u64Info2);
    6668    }
    6769
    … …  
    6971}
    7072
    71 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchEvent (PVBOXSHGSMI pHeap, PVOID pvBuff, RTSEMEVENT hEventSem)
    72 {
    73     PVBOXSHGSMIHEADER pHeader = VBoxSHGSMIBufferHeader (pvBuff);
     73const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchEvent(PVBOXSHGSMI pHeap, PVOID pvBuff, RTSEMEVENT hEventSem)
     74{
     75    PVBOXSHGSMIHEADER pHeader = VBoxSHGSMIBufferHeader(pvBuff);
    7476    pHeader->u64Info1 = (uint64_t)vboxSHGSMICompletionSetEvent;
    7577    pHeader->u64Info2 = (uint64_t)hEventSem;
    7678    pHeader->fFlags   = VBOXSHGSMI_FLAG_GH_ASYNCH_IRQ;
    7779
    78     return vboxSHGSMICommandPrepAsynch (pHeap, pHeader);
    79 }
    80 
    81 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepSynch (PVBOXSHGSMI pHeap, PVOID pCmd)
     80    return vboxSHGSMICommandPrepAsynch(pHeap, pHeader);
     81}
     82
     83const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepSynch(PVBOXSHGSMI pHeap, PVOID pCmd)
    8284{
    8385    RTSEMEVENT hEventSem;
    … …  
    8688    if (RT_SUCCESS(rc))
    8789    {
    88         return VBoxSHGSMICommandPrepAsynchEvent (pHeap, pCmd, hEventSem);
     90        return VBoxSHGSMICommandPrepAsynchEvent(pHeap, pCmd, hEventSem);
    8991    }
    9092    return NULL;
    9193}
    9294
    93 void VBoxSHGSMICommandDoneAsynch (PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER * pHeader)
     95void VBoxSHGSMICommandDoneAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER * pHeader)
    9496{
    9597    vboxSHGSMICommandDoneAsynch(pHeap, pHeader);
    9698}
    9799
    98 int VBoxSHGSMICommandDoneSynch (PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
    99 {
    100     VBoxSHGSMICommandDoneAsynch (pHeap, pHeader);
     100int VBoxSHGSMICommandDoneSynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
     101{
     102    VBoxSHGSMICommandDoneAsynch(pHeap, pHeader);
    101103    RTSEMEVENT hEventSem = (RTSEMEVENT)pHeader->u64Info2;
    102104    int rc = RTSemEventWait(hEventSem, RT_INDEFINITE_WAIT);
    … …  
    107109}
    108110
    109 void VBoxSHGSMICommandCancelAsynch (PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
     111void VBoxSHGSMICommandCancelAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
    110112{
    111113    vboxSHGSMICommandRelease(pHeap, (PVBOXSHGSMIHEADER)pHeader);
    … …  
    119121}
    120122
    121 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynch (PVBOXSHGSMI pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION pfnCompletion, PVOID pvCompletion, uint32_t fFlags)
     123const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynch(PVBOXSHGSMI pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION pfnCompletion,
     124                                                    PVOID pvCompletion, uint32_t fFlags)
    122125{
    123126    fFlags &= ~VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ;
    … …  
    130133}
    131134
    132 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchIrq (PVBOXSHGSMI pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletion, PVOID pvCompletion, uint32_t fFlags)
     135const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchIrq(PVBOXSHGSMI pHeap, PVOID pvBuff,
     136                                                       PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletion, PVOID pvCompletion,
     137                                                       uint32_t fFlags)
    133138{
    134139    fFlags |= VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ | VBOXSHGSMI_FLAG_GH_ASYNCH_IRQ;
    … …  
    201206{
    202207    /* Issue the flush command. */
    203     PVBOXSHGSMIHEADER pHeader = (PVBOXSHGSMIHEADER)VBoxSHGSMIHeapAlloc(pHeap, cbData + sizeof (VBOXSHGSMIHEADER), u8Channel, u16ChannelInfo);
     208    PVBOXSHGSMIHEADER pHeader = (PVBOXSHGSMIHEADER)VBoxSHGSMIHeapAlloc(pHeap, cbData + sizeof (VBOXSHGSMIHEADER), u8Channel,
     209                                                                       u16ChannelInfo);
    204210    Assert(pHeader);
    205211    if (pHeader)

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

    r62522 r63053  
    142142NTSTATUS vboxVdmaPipeSvrCmdGetList(PVBOXVDMAPIPE pPipe, PLIST_ENTRY pDetachHead)
    143143{
    144     PLIST_ENTRY pEntry = NULL;
    145144    KIRQL OldIrql;
    146145    NTSTATUS Status = STATUS_SUCCESS;
    … …  
    319318static DECLCALLBACK(void) vboxVdmaCrWriteCompletion(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvCtx)
    320319{
     320    RT_NOREF(rc);
    321321    PVBOXMP_VDMACR_WRITECOMPLETION pData = (PVBOXMP_VDMACR_WRITECOMPLETION)pvCtx;
    322322    void* pvBufferToFree = pData->pvBufferToFree;
    … …  
    472472    NTSTATUS Status = STATUS_SUCCESS;
    473473    int rc;
    474     bool fCurChanged = FALSE, fCurRectChanged = FALSE;
    475     POINT CurPos;
     474    bool fCurChanged = FALSE;
     475    bool fCurRectChanged = FALSE;
     476    POINT CurPos = { 0, 0 }; /* MSC is confused (me too), maybe used uninitialized. */
    476477    RTRECT *pVRectsBuff = NULL;
    477478    uint32_t cVRectsBuff = 0;
    … …  
    811812        uint32_t cbSrcLine = vboxWddmCalcRowSize(pSrcRect->left, pSrcRect->right, pSrcAlloc->SurfDesc.format);
    812813        uint32_t offSrcStart = vboxWddmCalcOffXYrd(pSrcRect->left, pSrcRect->top, pSrcAlloc->SurfDesc.pitch, pSrcAlloc->SurfDesc.format);
    813         Assert(cbSrcLine <= pSrcAlloc->SurfDesc.pitch);
     814        Assert(cbSrcLine <= pSrcAlloc->SurfDesc.pitch); NOREF(cbSrcLine);
    814815        uint32_t cbSrcSkip = pSrcAlloc->SurfDesc.pitch;
    815816        const uint8_t * pvSrcStart = pvSrcSurf + offSrcStart;
    … …  
    12571258                            RTRECT Rect;
    12581259                            VBoxVrListRectsGet(&pSource->VrList, 1, &Rect);
    1259                             if (Rect.xLeft == 0
    1260                                     && Rect.yTop == 0
    1261                                     && Rect.xRight == pDstAllocData->SurfDesc.width
    1262                                     && Rect.yBottom == pDstAllocData->SurfDesc.height)
     1260                            if (   Rect.xLeft  == 0
     1261                                && Rect.yTop    == 0
     1262                                && Rect.xRight  == (int32_t)pDstAllocData->SurfDesc.width
     1263                                && Rect.yBottom == (int32_t)pDstAllocData->SurfDesc.height)
    12631264                            {
    12641265                                pSource->fHas3DVrs = FALSE;
    … …  
    14681469NTSTATUS vboxVdmaProcessClrFillCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, VBOXWDDM_DMA_PRIVATEDATA_CLRFILL *pCF)
    14691470{
     1471    RT_NOREF(pContext);
    14701472    NTSTATUS Status = STATUS_SUCCESS;
    14711473    PVBOXWDDM_ALLOCATION pAlloc = pCF->ClrFill.Alloc.pAlloc;
    … …  
    15101512    return rc;
    15111513}
    1512 #define vboxWddmVdmaSubmit vboxWddmVdmaSubmitVbva
     1514# define vboxWddmVdmaSubmit vboxWddmVdmaSubmitVbva
    15131515#else
    15141516static int vboxWddmVdmaSubmitHgsmi(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, HGSMIOFFSET offDr)
    15151517{
     1518    RT_NOREF(pInfo);
    15161519    VBoxVideoCmnPortWriteUlong(VBoxCommonFromDeviceExt(pDevExt)->guestCtx.port, offDr);
    15171520    /* Make the compiler aware that the host has changed memory. */
    … …  
    15191522    return VINF_SUCCESS;
    15201523}
    1521 #define vboxWddmVdmaSubmit vboxWddmVdmaSubmitHgsmi
     1524# define vboxWddmVdmaSubmit vboxWddmVdmaSubmitHgsmi
    15221525#endif
    15231526
    … …  
    17321735static DECLCALLBACK(void) vboxVdmaCBufDrCompletion(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext)
    17331736{
     1737    RT_NOREF(pHeap);
    17341738    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)pvContext;
    17351739    PVBOXVDMAINFO pInfo = &pDevExt->u.primary.Vdma;
    17361740
    1737     vboxVdmaCBufDrFree (pInfo, (PVBOXVDMACBUF_DR)pvCmd);
    1738 }
    1739 
    1740 static DECLCALLBACK(PFNVBOXSHGSMICMDCOMPLETION) vboxVdmaCBufDrCompletionIrq(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext, void **ppvCompletion)
    1741 {
     1741    vboxVdmaCBufDrFree(pInfo, (PVBOXVDMACBUF_DR)pvCmd);
     1742}
     1743
     1744static DECLCALLBACK(PFNVBOXSHGSMICMDCOMPLETION) vboxVdmaCBufDrCompletionIrq(PVBOXSHGSMI pHeap, void *pvCmd,
     1745                                                                            void *pvContext, void **ppvCompletion)
     1746{
     1747    RT_NOREF(pHeap, ppvCompletion);
    17421748    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)pvContext;
    1743     PVBOXVDMAINFO pVdma = &pDevExt->u.primary.Vdma;
    17441749    PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)pvCmd;
    17451750
    … …  
    18591864DECLCALLBACK(VOID) vboxVdmaDdiCmdCompletionCbFree(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
    18601865{
     1866    RT_NOREF(pDevExt, pvContext);
    18611867    vboxWddmMemFree(pCmd);
    18621868}
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