VirtualBox

Changeset 29742 in vbox for trunk


Ignore:
Timestamp:
May 21, 2010 3:58:56 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
61925
Message:

wddm/2D: more impl (get caps + initialization working)

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/HGSMI/HGSMI.h

    r28800 r29742  
    241241}
    242242
     243DECLINLINE(uint8_t *) HGSMIBufferDataAndChInfoFromOffset (const HGSMIAREA *pArea, HGSMIOFFSET offBuffer, uint16_t * pChInfo)
     244{
     245    HGSMIBUFFERHEADER *pHeader = HGSMIOffsetToPointer (pArea, offBuffer);
     246    Assert(pHeader);
     247    if(pHeader)
     248    {
     249        *pChInfo = pHeader->u16ChannelInfo;
     250        return HGSMIBufferData(pHeader);
     251    }
     252    return NULL;
     253}
     254
    243255HGSMICHANNEL *HGSMIChannelFindById (HGSMICHANNELINFO * pChannelInfo, uint8_t u8Channel);
    244256

  • trunk/include/VBox/VBoxVideo.h

    r29488 r29742  
    812812# define VBVA_VDMA_CMD    11 /* G->H DMA command             */
    813813#endif
     814#define VBVA_INFO_CAPS   12 /* informs host about HGSMI caps. see _VBVACAPS below */
    814815
    815816/* host->guest commands */
    … …  
    10131014
    10141015} VBVAMOUSEPOINTERSHAPE;
     1016
     1017/* the guest driver can handle asynch guest cmd completion by reading the command offset from io port */
     1018#define VBVACAPS_COMPLETEGCMD_BY_IOREAD 0x00000001
     1019/* the guest driver can handle video adapter IRQs */
     1020#define VBVACAPS_IRQ                    0x00000002
     1021typedef struct _VBVACAPS
     1022{
     1023    int32_t rc;
     1024    uint32_t fCaps;
     1025} VBVACAPS;
    10151026
    10161027#pragma pack()

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

    r29731 r29742  
    15681568                    vboxVDbgPrintR((__FUNCTION__": pfnDirect3DCreate9Ex failed, hr (%d)\n", hr));
    15691569
    1570                 hr = VBoxDispD3DClose(&pAdapter->D3D);
     1570                VBoxDispD3DClose(&pAdapter->D3D);
    15711571            }
    15721572            else

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h

    r29710 r29742  
    288288   VBOXSHGSMILIST CtlList;
    289289   VBOXSHGSMILIST DmaCmdList;
     290#ifdef VBOX_WITH_VIDEOHWACCEL
     291   VBOXSHGSMILIST VhwaCmdList;
     292#endif
    290293   BOOL bSetNotifyDxDpc;
    291294   BOOL bNotifyDxDpc;

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp

    r28800 r29742  
    380380    AssertFailed ();
    381381    return VERR_INTERNAL_ERROR;
     382}
     383#else
     384int vbvaInitInfoCaps (PDEVICE_EXTENSION PrimaryExtension, void *pvContext, void *pvData)
     385{
     386    VBVACAPS *pCaps = (VBVACAPS*)pvData;
     387    pCaps->rc = VERR_NOT_IMPLEMENTED;
     388    pCaps->fCaps = VBVACAPS_COMPLETEGCMD_BY_IOREAD | VBVACAPS_IRQ;
     389    return VINF_SUCCESS;
     390}
     391
     392
     393int vbvaFinalizeInfoCaps (PDEVICE_EXTENSION PrimaryExtension, void *pvContext, void *pvData)
     394{
     395    VBVACAPS *pCaps = (VBVACAPS*)pvData;
     396    AssertRC(pCaps->rc);
     397    return pCaps->rc;
    382398}
    383399#endif
    … …  
    436452         * i.e. it is assigned by Video Memory Manager,
    437453         * The FB information should be passed to guest from our DxgkDdiSetVidPnSourceAddress callback */
     454
     455        /* Inform about caps */
     456        rc = vboxCallVBVA (PrimaryExtension,
     457                               VBVA_INFO_CAPS,
     458                               sizeof (VBVACAPS),
     459                               vbvaInitInfoCaps,
     460                               vbvaFinalizeInfoCaps,
     461                               NULL);
     462        AssertRC(rc);
     463        if (RT_SUCCESS (rc))
    438464#endif
    439465        {

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoShgsmi.cpp

    r28800 r29742  
    188188#define VBOXSHGSMI_LISTENTRY2CMD(_pEntry) ( (PVBOXSHGSMIHEADER)((uint8_t *)(_pEntry) - RT_OFFSETOF(VBOXSHGSMIHEADER, pvNext)) )
    189189
    190 int VBoxSHGSMICommandProcessCompletion (struct _HGSMIHEAP * pHeap, HGSMIOFFSET offCmd, bool bIrq, PVBOXSHGSMILIST pPostProcessList)
     190int VBoxSHGSMICommandProcessCompletion (struct _HGSMIHEAP * pHeap, VBOXSHGSMIHEADER* pCur, bool bIrq, PVBOXSHGSMILIST pPostProcessList)
    191191{
    192192    int rc = VINF_SUCCESS;
    193193
    194     PVBOXSHGSMIHEADER pCur = (PVBOXSHGSMIHEADER)HGSMIBufferDataFromOffset (&pHeap->area, offCmd);
    195     Assert(pCur);
    196     if (pCur)
    197     {
    198         do
     194    do
     195    {
     196        if (pCur->fFlags & VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ)
    199197        {
    200             if (pCur->fFlags & VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ)
     198            Assert(bIrq);
     199
     200            PFNVBOXSHGSMICMDCOMPLETION pfnCompletion = NULL;
     201            void *pvCompletion;
     202            PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCallback = (PFNVBOXSHGSMICMDCOMPLETION_IRQ)pCur->u64Info1;
     203            void *pvCallback = (void*)pCur->u64Info2;
     204
     205            pfnCallback(pHeap, VBoxSHGSMIBufferData(pCur), pvCallback, &pfnCompletion, &pvCompletion);
     206            if (pfnCompletion)
    201207            {
    202                 Assert(bIrq);
    203 
    204                 PFNVBOXSHGSMICMDCOMPLETION pfnCompletion = NULL;
    205                 void *pvCompletion;
    206                 PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCallback = (PFNVBOXSHGSMICMDCOMPLETION_IRQ)pCur->u64Info1;
    207                 void *pvCallback = (void*)pCur->u64Info2;
    208 
    209                 pfnCallback(pHeap, VBoxSHGSMIBufferData(pCur), pvCallback, &pfnCompletion, &pvCompletion);
    210                 if (pfnCompletion)
    211                 {
    212                     pCur->u64Info1 = (uint64_t)pfnCompletion;
    213                     pCur->u64Info2 = (uint64_t)pvCompletion;
    214                     pCur->fFlags &= ~VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ;
    215                 }
    216                 else
    217                 {
    218                     /* nothing to do with this command */
    219                     break;
    220                 }
    221             }
    222 
    223             if (!bIrq)
    224             {
    225                 PFNVBOXSHGSMICMDCOMPLETION pfnCallback = (PFNVBOXSHGSMICMDCOMPLETION)pCur->u64Info1;
    226                 void *pvCallback = (void*)pCur->u64Info2;
    227                 pfnCallback(pHeap, VBoxSHGSMIBufferData(pCur), pvCallback);
     208                pCur->u64Info1 = (uint64_t)pfnCompletion;
     209                pCur->u64Info2 = (uint64_t)pvCompletion;
     210                pCur->fFlags &= ~VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ;
    228211            }
    229212            else
    230                 vboxSHGSMIListPut(pPostProcessList, VBOXSHGSMI_CMD2LISTENTRY(pCur), VBOXSHGSMI_CMD2LISTENTRY(pCur));
    231         } while (0);
    232     }
    233     else
    234     {
    235         rc = VERR_INVALID_PARAMETER;
    236     }
     213            {
     214                /* nothing to do with this command */
     215                break;
     216            }
     217        }
     218
     219        if (!bIrq)
     220        {
     221            PFNVBOXSHGSMICMDCOMPLETION pfnCallback = (PFNVBOXSHGSMICMDCOMPLETION)pCur->u64Info1;
     222            void *pvCallback = (void*)pCur->u64Info2;
     223            pfnCallback(pHeap, VBoxSHGSMIBufferData(pCur), pvCallback);
     224        }
     225        else
     226            vboxSHGSMIListPut(pPostProcessList, VBOXSHGSMI_CMD2LISTENTRY(pCur), VBOXSHGSMI_CMD2LISTENTRY(pCur));
     227    } while (0);
     228
    237229
    238230    return rc;

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoShgsmi.h

    r28800 r29742  
    102102void* VBoxSHGSMICommandAlloc(struct _HGSMIHEAP * pHeap, HGSMISIZE cbData, uint8_t u8Channel, uint16_t u16ChannelInfo);
    103103void VBoxSHGSMICommandFree(struct _HGSMIHEAP * pHeap, void *pvBuffer);
    104 int VBoxSHGSMICommandProcessCompletion(struct _HGSMIHEAP * pHeap, HGSMIOFFSET offCmd, bool bIrq, PVBOXSHGSMILIST pPostProcessList);
     104int VBoxSHGSMICommandProcessCompletion(struct _HGSMIHEAP * pHeap, VBOXSHGSMIHEADER* pCmd, bool bIrq, PVBOXSHGSMILIST pPostProcessList);
    105105int VBoxSHGSMICommandPostprocessCompletion(struct _HGSMIHEAP * pHeap, PVBOXSHGSMILIST pPostProcessList);
    106106

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp

    r29710 r29742  
    173173    vboxVhwaCommandFree(pDevExt, pCmd);
    174174}
     175
     176void vboxVhwaCompletionListProcess(PDEVICE_EXTENSION pDevExt, VBOXSHGSMILIST *pList)
     177{
     178    PVBOXSHGSMILIST_ENTRY pNext, pCur;
     179    for (pCur = pList->pFirst; pCur; pCur = pNext)
     180    {
     181        /* need to save next since the command may be released in a pfnCallback and thus its data might be invalid */
     182        pNext = pCur->pNext;
     183        VBOXVHWACMD *pCmd = VBOXVHWA_LISTENTRY2CMD(pCur);
     184        PFNVBOXVHWACMDCOMPLETION pfnCallback = (PFNVBOXVHWACMDCOMPLETION)pCmd->GuestVBVAReserved1;
     185        void *pvCallback = (void*)pCmd->GuestVBVAReserved2;
     186        pfnCallback(pDevExt, pCmd, pvCallback);
     187    }
     188}
     189
    175190#endif
    176191
    … …  
    216231    pInfo1->u.in.guestVersion.reserved = VBOXVHWA_VERSION_RSV;
    217232
    218     if(vboxVhwaCommandSubmit(pDevExt, pCmd))
     233    int rc = vboxVhwaCommandSubmit(pDevExt, pCmd);
     234    AssertRC(rc);
     235    if(RT_SUCCESS(rc))
    219236    {
    220237        if(RT_SUCCESS(pCmd->rc))
    … …  
    242259    pInfo2->numFourCC = numFourCC;
    243260
    244     if(vboxVhwaCommandSubmit(pDevExt, pCmd))
    245     {
     261    int rc = vboxVhwaCommandSubmit(pDevExt, pCmd);
     262    AssertRC(rc);
     263    if(RT_SUCCESS(rc))
     264    {
     265        AssertRC(pCmd->rc);
    246266        if(RT_SUCCESS(pCmd->rc))
    247267        {
    … …  
    270290    }
    271291
    272     if(vboxVhwaCommandSubmit(pDevExt, pCmd))
    273     {
     292    rc = vboxVhwaCommandSubmit(pDevExt, pCmd);
     293    AssertRC(rc);
     294    if(RT_SUCCESS(rc))
     295    {
     296        AssertRC(pCmd->rc);
    274297        if(RT_SUCCESS(pCmd->rc))
    275         {
    276298            rc = VINF_SUCCESS;
    277         }
     299        else
     300            rc = pCmd->rc;
    278301    }
    279302
    … …  
    295318    }
    296319
    297     if(vboxVhwaCommandSubmit(pDevExt, pCmd))
    298     {
     320    rc = vboxVhwaCommandSubmit(pDevExt, pCmd);
     321    AssertRC(rc);
     322    if(RT_SUCCESS(rc))
     323    {
     324        AssertRC(pCmd->rc);
    299325        if(RT_SUCCESS(pCmd->rc))
    300         {
    301326            rc = VINF_SUCCESS;
    302         }
     327        else
     328            rc = pCmd->rc;
    303329    }
    304330
    … …  
    345371
    346372                pSettings->aFormats[pSettings->cFormats] = D3DDDIFMT_X8R8G8B8;
    347                 ++pSettings->cFormats;
    348                 pSettings->aFormats[pSettings->cFormats] = D3DDDIFMT_A8R8G8B8;
    349373                ++pSettings->cFormats;
    350374

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.h

    r29710 r29742  
    1414
    1515#include <iprt/cdefs.h>
     16
     17#include "VBoxVideoShgsmi.h"
    1618
    1719VBOXVHWACMD* vboxVhwaCommandCreate(PDEVICE_EXTENSION pDevExt,
    … …  
    3133void vboxVhwaCommandSubmitAsynch(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext);
    3234void vboxVhwaCommandSubmitAsynchByEvent(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd, RTSEMEVENT hEvent);
     35
     36#define VBOXVHWA_CMD2LISTENTRY(_pCmd) ((PVBOXSHGSMILIST_ENTRY)&(_pCmd)->u.pNext)
     37#define VBOXVHWA_LISTENTRY2CMD(_pEntry) ( (VBOXVHWACMD*)((uint8_t *)(_pEntry) - RT_OFFSETOF(VBOXVHWACMD, u.pNext)) )
     38
     39DECLINLINE(void) vboxVhwaPutList(VBOXSHGSMILIST *pList, VBOXVHWACMD* pCmd)
     40{
     41    vboxSHGSMIListPut(pList, VBOXVHWA_CMD2LISTENTRY(pCmd), VBOXVHWA_CMD2LISTENTRY(pCmd));
     42}
     43
     44void vboxVhwaCompletionListProcess(PDEVICE_EXTENSION pDevExt, VBOXSHGSMILIST *pList);
    3345#endif
    3446
    … …  
    4153void vboxVHWAInit(PDEVICE_EXTENSION pDevExt);
    4254
    43 
    4455#endif /* #ifndef ___VBoxVideoVhwa_h___ */

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

    r29710 r29742  
    848848        vboxSHGSMIListInit(&DmaCmdList);
    849849
     850#ifdef VBOX_WITH_VIDEOHWACCEL
     851        VBOXSHGSMILIST VhwaCmdList;
     852        vboxSHGSMIListInit(&VhwaCmdList);
     853#endif
     854
    850855        uint32_t flags = pDevExt->u.primary.pHostFlags->u32HostFlags;
    851856        bOur = (flags & HGSMIHOSTFLAGS_IRQ);
    … …  
    878883                    if (pHeap)
    879884                    {
    880                         int rc = VBoxSHGSMICommandProcessCompletion (pHeap, offCmd, TRUE /*bool bIrq*/ , pList);
    881                         AssertRC(rc);
     885                        uint16_t chInfo;
     886                        uint8_t *pvCmd = HGSMIBufferDataAndChInfoFromOffset (&pHeap->area, offCmd, &chInfo);
     887                        Assert(pvCmd);
     888                        if (pvCmd)
     889                        {
     890                            switch (chInfo)
     891                            {
     892                                case VBVA_VDMA_CMD:
     893                                case VBVA_VDMA_CTL:
     894                                {
     895                                    int rc = VBoxSHGSMICommandProcessCompletion (pHeap, (VBOXSHGSMIHEADER*)pvCmd, TRUE /*bool bIrq*/ , pList);
     896                                    AssertRC(rc);
     897                                    break;
     898                                }
     899#ifdef VBOX_WITH_VIDEOHWACCEL
     900                                case VBVA_VHWA_CMD:
     901                                {
     902                                    vboxVhwaPutList(&VhwaCmdList, (VBOXVHWACMD*)pvCmd);
     903                                    break;
     904                                }
     905#endif /* # ifdef VBOX_WITH_VIDEOHWACCEL */
     906                                default:
     907                                    AssertBreakpoint();
     908                            }
     909                        }
    882910                    }
    883911                }
    … …  
    904932            vboxSHGSMIListCat(&pDevExt->DmaCmdList, &DmaCmdList);
    905933            bNeedDpc = TRUE;
     934        }
     935
     936        if (!vboxSHGSMIListIsEmpty(&VhwaCmdList))
     937        {
     938            vboxSHGSMIListCat(&pDevExt->VhwaCmdList, &VhwaCmdList);
    906939        }
    907940
    … …  
    939972    VBOXSHGSMILIST CtlList;
    940973    VBOXSHGSMILIST DmaCmdList;
     974#ifdef VBOX_WITH_VIDEOHWACCEL
     975    VBOXSHGSMILIST VhwaCmdList;
     976#endif
    941977    BOOL bNotifyDpc;
    942978} VBOXWDDM_DPCDATA, *PVBOXWDDM_DPCDATA;
    … …  
    954990    vboxSHGSMICmdListDetach2List(&pdc->pDevExt->CtlList, &pdc->data.CtlList);
    955991    vboxSHGSMICmdListDetach2List(&pdc->pDevExt->DmaCmdList, &pdc->data.DmaCmdList);
     992#ifdef VBOX_WITH_VIDEOHWACCEL
     993    vboxSHGSMICmdListDetach2List(&pdc->pDevExt->VhwaCmdList, &pdc->data.VhwaCmdList);
     994#endif
    956995    pdc->data.bNotifyDpc = pdc->pDevExt->bNotifyDxDpc;
    957996    pdc->pDevExt->bNotifyDxDpc = FALSE;
    … …  
    9941033        AssertRC(rc);
    9951034    }
     1035
     1036#ifdef VBOX_WITH_VIDEOHWACCEL
     1037    if (!vboxSHGSMIListIsEmpty(&context.data.VhwaCmdList))
     1038    {
     1039        vboxVhwaCompletionListProcess(pDevExt, &context.data.VhwaCmdList);
     1040    }
     1041#endif
    9961042
    9971043    if (context.data.bNotifyDpc)

  • trunk/src/VBox/Devices/Graphics/DevVGA.h

    r28800 r29742  
    408408    /** Base port in the assigned PCI I/O space. */
    409409    RTIOPORT                    IOPortBase;
     410#ifdef VBOXVDMA
     411    /* specifies guest driver caps, i.e. whether it can handle IRQs from the adapter,
     412     * the way it can handle assync HGSMI command completion, etc. */
     413    uint32_t                    fGuestCaps;
     414#endif
     415
    410416    uint8_t                     Padding7[6];
    411417#endif /* VBOX_WITH_HGSMI */

  • trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp

    r28800 r29742  
    12441244        PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface);
    12451245        PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
    1246         VBVAHOSTCMD *pHostCmd;
    1247     //    Assert(0);
    1248 
    1249         int32_t iDisplay = pCmd->iDisplay;
     1246
    12501247        Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
    1251         if(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT)
    1252         {
    1253             rc = HGSMIHostCommandAlloc (pIns,
    1254                                           (void**)&pHostCmd,
    1255                                           VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)),
    1256                                           HGSMI_CH_VBVA,
    1257                                           VBVAHG_EVENT);
     1248#ifdef VBOXVDMA
     1249        if (pVGAState->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD)
     1250        {
     1251            rc = HGSMICompleteGuestCommand(pIns, pCmd, !!(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
    12581252            AssertRC(rc);
    1259             if(RT_SUCCESS(rc))
    1260             {
    1261                 memset(pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)));
    1262                 pHostCmd->iDstID = pCmd->iDisplay;
    1263                 pHostCmd->customOpCode = 0;
    1264                 VBVAHOSTCMDEVENT *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDEVENT);
    1265                 pBody->pEvent = pCmd->GuestVBVAReserved1;
    1266             }
    12671253        }
    12681254        else
    1269         {
    1270             HGSMIOFFSET offCmd = HGSMIPointerToOffsetHost (pIns, pCmd);
    1271             Assert(offCmd != HGSMIOFFSET_VOID);
    1272             if(offCmd != HGSMIOFFSET_VOID)
     1255#endif
     1256        {
     1257            VBVAHOSTCMD *pHostCmd;
     1258            int32_t iDisplay = pCmd->iDisplay;
     1259
     1260            if(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT)
    12731261            {
    12741262                rc = HGSMIHostCommandAlloc (pIns,
    1275                                           (void**)&pHostCmd,
    1276                                           VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)),
    1277                                           HGSMI_CH_VBVA,
    1278                                           VBVAHG_DISPLAY_CUSTOM);
     1263                                              (void**)&pHostCmd,
     1264                                              VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)),
     1265                                              HGSMI_CH_VBVA,
     1266                                              VBVAHG_EVENT);
    12791267                AssertRC(rc);
    12801268                if(RT_SUCCESS(rc))
    12811269                {
    1282                     memset(pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)));
     1270                    memset(pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)));
    12831271                    pHostCmd->iDstID = pCmd->iDisplay;
    1284                     pHostCmd->customOpCode = VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE;
    1285                     VBVAHOSTCMDVHWACMDCOMPLETE *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE);
    1286                     pBody->offCmd = offCmd;
     1272                    pHostCmd->customOpCode = 0;
     1273                    VBVAHOSTCMDEVENT *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDEVENT);
     1274                    pBody->pEvent = pCmd->GuestVBVAReserved1;
    12871275                }
    12881276            }
    12891277            else
    12901278            {
    1291                 rc = VERR_INVALID_PARAMETER;
    1292             }
    1293         }
    1294 
    1295         if(RT_SUCCESS(rc))
    1296         {
    1297             rc = HGSMIHostCommandProcessAndFreeAsynch(pIns, pHostCmd, (pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ) != 0);
    1298             AssertRC(rc);
     1279                HGSMIOFFSET offCmd = HGSMIPointerToOffsetHost (pIns, pCmd);
     1280                Assert(offCmd != HGSMIOFFSET_VOID);
     1281                if(offCmd != HGSMIOFFSET_VOID)
     1282                {
     1283                    rc = HGSMIHostCommandAlloc (pIns,
     1284                                              (void**)&pHostCmd,
     1285                                              VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)),
     1286                                              HGSMI_CH_VBVA,
     1287                                              VBVAHG_DISPLAY_CUSTOM);
     1288                    AssertRC(rc);
     1289                    if(RT_SUCCESS(rc))
     1290                    {
     1291                        memset(pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)));
     1292                        pHostCmd->iDstID = pCmd->iDisplay;
     1293                        pHostCmd->customOpCode = VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE;
     1294                        VBVAHOSTCMDVHWACMDCOMPLETE *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE);
     1295                        pBody->offCmd = offCmd;
     1296                    }
     1297                }
     1298                else
     1299                {
     1300                    rc = VERR_INVALID_PARAMETER;
     1301                }
     1302            }
     1303
    12991304            if(RT_SUCCESS(rc))
    13001305            {
    1301                 return rc;
    1302             }
    1303             HGSMIHostCommandFree (pIns, pHostCmd);
     1306                rc = HGSMIHostCommandProcessAndFreeAsynch(pIns, pHostCmd, (pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ) != 0);
     1307                AssertRC(rc);
     1308                if(RT_SUCCESS(rc))
     1309                {
     1310                    return rc;
     1311                }
     1312                HGSMIHostCommandFree (pIns, pHostCmd);
     1313            }
    13041314        }
    13051315    }
    … …  
    16211631#endif
    16221632
     1633#ifdef VBOXVDMA
     1634        case VBVA_INFO_CAPS:
     1635        {
     1636            if (cbBuffer < sizeof (VBVACAPS))
     1637            {
     1638                rc = VERR_INVALID_PARAMETER;
     1639                break;
     1640            }
     1641
     1642            VBVACAPS *pCaps = (VBVACAPS*)pvBuffer;
     1643            pVGAState->fGuestCaps = pCaps->fCaps;
     1644            pCaps->rc = VINF_SUCCESS;
     1645        } break;
     1646#endif
    16231647        default:
    16241648            Log(("Unsupported VBVA guest command %d!!!\n",
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