VirtualBox

Changeset 53201 in vbox for trunk/src


Ignore:
Timestamp:
Nov 4, 2014 3:30:43 PM (10 years ago)
Author:
vboxsync
Message:

Devices/Main: vmsvga updates

Location:
trunk/src/VBox
Files:
704 added
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.cpp

    r50328 r53201  
    4646#endif
    4747
     48/** Converts a display port interface pointer to a vga state pointer. */
     49#define IDISPLAYPORT_2_VGASTATE(pInterface) ( (PVGASTATE)((uintptr_t)pInterface - RT_OFFSETOF(VGASTATE, IPort)) )
     50
    4851#include "DevVGA-SVGA.h"
    4952#include "vmsvga/svga_reg.h"
    … …  
    6972typedef struct
    7073{
     74    uint32_t                    cMaxPages;
    7175    uint32_t                    cbTotal;
    7276    uint32_t                    numDescriptors;
    … …  
    8488        SVGAGMRImageFormat  format;
    8589    } GMRFB;
     90    struct
     91    {
     92        bool                fActive;
     93        uint32_t            xHotspot;
     94        uint32_t            yHotspot;
     95        uint32_t            width;
     96        uint32_t            height;
     97        uint32_t            cbData;
     98        void               *pData;
     99    } Cursor;
    86100    SVGAColorBGRX           colorAnnotation;
    87101    STAMPROFILE             StatR3CmdPresent;
    … …  
    107121static SSMFIELD const g_aGMRFields[] =
    108122{
     123    SSMFIELD_ENTRY(             GMR, cMaxPages),
    109124    SSMFIELD_ENTRY(             GMR, cbTotal),
    110125    SSMFIELD_ENTRY(             GMR, numDescriptors),
    … …  
    120135    SSMFIELD_ENTRY_IGNORE(      VMSVGASTATE, aGMR),
    121136    SSMFIELD_ENTRY(             VMSVGASTATE, GMRFB),
     137    SSMFIELD_ENTRY(             VMSVGASTATE, Cursor.fActive),
     138    SSMFIELD_ENTRY(             VMSVGASTATE, Cursor.xHotspot),
     139    SSMFIELD_ENTRY(             VMSVGASTATE, Cursor.yHotspot),
     140    SSMFIELD_ENTRY(             VMSVGASTATE, Cursor.width),
     141    SSMFIELD_ENTRY(             VMSVGASTATE, Cursor.height),
     142    SSMFIELD_ENTRY(             VMSVGASTATE, Cursor.cbData),
     143    SSMFIELD_ENTRY_IGN_HCPTR(   VMSVGASTATE, Cursor.pData),
    122144    SSMFIELD_ENTRY(             VMSVGASTATE, colorAnnotation),
    123145    SSMFIELD_ENTRY_IGNORE(      VMSVGASTATE, StatR3CmdPresent),
    … …  
    132154static SSMFIELD const g_aVGAStateSVGAFields[] =
    133155{
    134     SSMFIELD_ENTRY_IGNORE(          VGAState, svga.u64HostWindowId),
    135     SSMFIELD_ENTRY_IGN_HCPTR(       VGAState, svga.pFIFOR3),
    136     SSMFIELD_ENTRY_IGN_HCPTR(       VGAState, svga.pFIFOR0),
    137     SSMFIELD_ENTRY_IGN_HCPTR(       VGAState, svga.pSVGAState),
    138     SSMFIELD_ENTRY_IGN_HCPTR(       VGAState, svga.p3dState),
    139     SSMFIELD_ENTRY_IGNORE(          VGAState, svga.pFrameBufferBackup),
    140     SSMFIELD_ENTRY_IGN_GCPHYS(      VGAState, svga.GCPhysFIFO),
    141     SSMFIELD_ENTRY_IGNORE(          VGAState, svga.cbFIFO),
    142     SSMFIELD_ENTRY(                 VGAState, svga.u32SVGAId),
    143     SSMFIELD_ENTRY(                 VGAState, svga.fEnabled),
    144     SSMFIELD_ENTRY(                 VGAState, svga.fConfigured),
    145     SSMFIELD_ENTRY(                 VGAState, svga.fBusy),
    146     SSMFIELD_ENTRY(                 VGAState, svga.fTraces),
    147     SSMFIELD_ENTRY(                 VGAState, svga.u32GuestId),
    148     SSMFIELD_ENTRY(                 VGAState, svga.cScratchRegion),
    149     SSMFIELD_ENTRY(                 VGAState, svga.au32ScratchRegion),
    150     SSMFIELD_ENTRY(                 VGAState, svga.u32IrqStatus),
    151     SSMFIELD_ENTRY(                 VGAState, svga.u32IrqMask),
    152     SSMFIELD_ENTRY(                 VGAState, svga.u32PitchLock),
    153     SSMFIELD_ENTRY(                 VGAState, svga.u32CurrentGMRId),
    154     SSMFIELD_ENTRY(                 VGAState, svga.u32RegCaps),
    155     SSMFIELD_ENTRY_IGNORE(          VGAState, svga.BasePort),
    156     SSMFIELD_ENTRY(                 VGAState, svga.u32IndexReg),
    157     SSMFIELD_ENTRY_IGNORE(          VGAState, svga.FIFORequestSem),
    158     SSMFIELD_ENTRY_IGN_HCPTR(       VGAState, svga.pFIFOIOThread),
    159     SSMFIELD_ENTRY(                 VGAState, svga.iWidth),
    160     SSMFIELD_ENTRY(                 VGAState, svga.iHeight),
    161     SSMFIELD_ENTRY(                 VGAState, svga.iBpp),
    162     SSMFIELD_ENTRY(                 VGAState, svga.cbScanline),
    163     SSMFIELD_ENTRY(                 VGAState, svga.u32MaxWidth),
    164     SSMFIELD_ENTRY(                 VGAState, svga.u32MaxHeight),
    165     SSMFIELD_ENTRY(                 VGAState, svga.u32ActionFlags),
    166     SSMFIELD_ENTRY(                 VGAState, svga.f3DEnabled),
    167     SSMFIELD_ENTRY(                 VGAState, svga.fVRAMTracking),
    168     SSMFIELD_ENTRY(                 VGAState, svga.Padding6),
     156    SSMFIELD_ENTRY_IGNORE(          VMSVGAState, u64HostWindowId),
     157    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pFIFOR3),
     158    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pFIFOR0),
     159    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pSVGAState),
     160    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, p3dState),
     161    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pFrameBufferBackup),
     162    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pFIFOExtCmdParam),   
     163    SSMFIELD_ENTRY_IGN_GCPHYS(      VMSVGAState, GCPhysFIFO),
     164    SSMFIELD_ENTRY_IGNORE(          VMSVGAState, cbFIFO),
     165    SSMFIELD_ENTRY(                 VMSVGAState, u32SVGAId),
     166    SSMFIELD_ENTRY(                 VMSVGAState, fEnabled),
     167    SSMFIELD_ENTRY(                 VMSVGAState, fConfigured),
     168    SSMFIELD_ENTRY(                 VMSVGAState, fBusy),
     169    SSMFIELD_ENTRY(                 VMSVGAState, fTraces),
     170    SSMFIELD_ENTRY(                 VMSVGAState, u32GuestId),
     171    SSMFIELD_ENTRY(                 VMSVGAState, cScratchRegion),
     172    SSMFIELD_ENTRY(                 VMSVGAState, au32ScratchRegion),
     173    SSMFIELD_ENTRY(                 VMSVGAState, u32IrqStatus),
     174    SSMFIELD_ENTRY(                 VMSVGAState, u32IrqMask),
     175    SSMFIELD_ENTRY(                 VMSVGAState, u32PitchLock),
     176    SSMFIELD_ENTRY(                 VMSVGAState, u32CurrentGMRId),
     177    SSMFIELD_ENTRY(                 VMSVGAState, u32RegCaps),
     178    SSMFIELD_ENTRY_IGNORE(          VMSVGAState, BasePort),
     179    SSMFIELD_ENTRY(                 VMSVGAState, u32IndexReg),
     180    SSMFIELD_ENTRY_IGNORE(          VMSVGAState, FIFORequestSem),
     181    SSMFIELD_ENTRY_IGNORE(          VMSVGAState, FIFOExtCmdSem),
     182    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pFIFOIOThread),
     183    SSMFIELD_ENTRY(                 VMSVGAState, uWidth),
     184    SSMFIELD_ENTRY(                 VMSVGAState, uHeight),
     185    SSMFIELD_ENTRY(                 VMSVGAState, uBpp),
     186    SSMFIELD_ENTRY(                 VMSVGAState, cbScanline),
     187    SSMFIELD_ENTRY(                 VMSVGAState, u32MaxWidth),
     188    SSMFIELD_ENTRY(                 VMSVGAState, u32MaxHeight),
     189    SSMFIELD_ENTRY(                 VMSVGAState, u32ActionFlags),
     190    SSMFIELD_ENTRY(                 VMSVGAState, f3DEnabled),
     191    SSMFIELD_ENTRY(                 VMSVGAState, fVRAMTracking),
     192    SSMFIELD_ENTRY_IGNORE(          VMSVGAState, u8FIFOExtCommand),
    169193    SSMFIELD_ENTRY_TERM()
    170194};
    … …  
    423447
    424448/**
     449 * Inform the VGA device of viewport changes (as a result of e.g. scrolling)
     450 *
     451 * @param   pInterface          Pointer to this interface.
     452 * @param   
     453 * @param   uScreenId           The screen updates are for.
     454 * @param   x                   The upper left corner x coordinate of the new viewport rectangle
     455 * @param   y                   The upper left corner y coordinate of the new viewport rectangle
     456 * @param   cx                  The width of the new viewport rectangle
     457 * @param   cy                  The height of the new viewport rectangle
     458 * @thread  The emulation thread.
     459 */
     460DECLCALLBACK(void) vmsvgaPortSetViewPort(PPDMIDISPLAYPORT pInterface, uint32_t uScreenId, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
     461{
     462    PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
     463
     464    Log(("vmsvgaPortSetViewPort: screen %d (%d,%d)(%d,%d)\n", uScreenId, x, y, cx, cy));
     465
     466    pThis->svga.viewport.x  = x;
     467    pThis->svga.viewport.y  = y;
     468    pThis->svga.viewport.cx = RT_MIN(cx, (uint32_t)pThis->svga.uWidth);
     469    pThis->svga.viewport.cy = RT_MIN(cy, (uint32_t)pThis->svga.uHeight);
     470    return;
     471}
     472
     473/**
    425474 * Read port register
    426475 *
    … …  
    447496    {
    448497        if (    pThis->svga.fEnabled
    449             &&  pThis->svga.iWidth != -1)
    450         {
    451             *pu32 = pThis->svga.iWidth;
     498            &&  pThis->svga.uWidth != VMSVGA_VAL_UNINITIALIZED)
     499        {
     500            *pu32 = pThis->svga.uWidth;
    452501        }
    453502        else
    … …  
    465514    {
    466515        if (    pThis->svga.fEnabled
    467             &&  pThis->svga.iHeight != -1)
    468         {
    469             *pu32 = pThis->svga.iHeight;
     516            &&  pThis->svga.uHeight != VMSVGA_VAL_UNINITIALIZED)
     517        {
     518            *pu32 = pThis->svga.uHeight;
    470519        }
    471520        else
    … …  
    490539    case SVGA_REG_DEPTH:
    491540        /* This returns the color depth of the current mode. */
    492         switch (pThis->svga.iBpp)
     541        switch (pThis->svga.uBpp)
    493542        {
    494543        case 15:
    495544        case 16:
    496545        case 24:
    497             *pu32 = pThis->svga.iBpp;
     546            *pu32 = pThis->svga.uBpp;
    498547            break;
    499548
    … …  
    507556    case SVGA_REG_HOST_BITS_PER_PIXEL: /* (Deprecated) */
    508557        if (    pThis->svga.fEnabled
    509             &&  pThis->svga.iBpp != (unsigned)-1)
    510         {
    511             *pu32 = pThis->svga.iBpp;
     558            &&  pThis->svga.uBpp != VMSVGA_VAL_UNINITIALIZED)
     559        {
     560            *pu32 = pThis->svga.uBpp;
    512561        }
    513562        else
    … …  
    523572    case SVGA_REG_BITS_PER_PIXEL:      /* Current bpp in the guest */
    524573        if (    pThis->svga.fEnabled
    525             &&  pThis->svga.iBpp != (unsigned)-1)
    526         {
    527             *pu32 = (pThis->svga.iBpp + 7) & ~7;
     574            &&  pThis->svga.uBpp != VMSVGA_VAL_UNINITIALIZED)
     575        {
     576            *pu32 = (pThis->svga.uBpp + 7) & ~7;
    528577        }
    529578        else
    … …  
    545594    case SVGA_REG_BLUE_MASK:
    546595    {
    547         uint32_t iBpp;
     596        uint32_t uBpp;
    548597
    549598        if (    pThis->svga.fEnabled
    550             &&  pThis->svga.iBpp != (unsigned)-1)
    551         {
    552             iBpp = pThis->svga.iBpp;
     599            &&  pThis->svga.uBpp != VMSVGA_VAL_UNINITIALIZED)
     600        {
     601            uBpp = pThis->svga.uBpp;
    553602        }
    554603        else
    … …  
    558607            break;
    559608#else
    560             iBpp = pThis->pDrv->cBits;
     609            uBpp = pThis->pDrv->cBits;
    561610#endif
    562611        }
    563612        uint32_t u32RedMask, u32GreenMask, u32BlueMask;
    564         switch (iBpp)
     613        switch (uBpp)
    565614        {
    566615        case 8:
    … …  
    646695        /* VMWare testcases want at least 4 MB in case the hardware is disabled. */
    647696        if (    pThis->svga.fEnabled
    648             &&  pThis->svga.iHeight != -1)
     697            &&  pThis->svga.uHeight != VMSVGA_VAL_UNINITIALIZED)
    649698        {
    650699            /* Hardware enabled; return real framebuffer size .*/
    651             *pu32 = (uint32_t)pThis->svga.iHeight * pThis->svga.cbScanline;
     700            *pu32 = (uint32_t)pThis->svga.uHeight * pThis->svga.cbScanline;
    652701        }
    653702        else
    … …  
    772821
    773822    case SVGA_REG_DISPLAY_WIDTH:     /* The display's width */
    774         *pu32 = pThis->svga.iWidth;
     823        *pu32 = pThis->svga.uWidth;
    775824        break;
    776825
    777826    case SVGA_REG_DISPLAY_HEIGHT:    /* The display's height */
    778         *pu32 = pThis->svga.iHeight;
     827        *pu32 = pThis->svga.uHeight;
    779828        break;
    780829
    … …  
    806855    int rc;
    807856
    808     if (    pThis->svga.iWidth == -1
    809         ||  pThis->svga.iHeight == -1
    810         ||  pThis->svga.iBpp == (unsigned)-1)
     857    if (    pThis->svga.uWidth  == VMSVGA_VAL_UNINITIALIZED
     858        ||  pThis->svga.uHeight == VMSVGA_VAL_UNINITIALIZED
     859        ||  pThis->svga.uBpp    == VMSVGA_VAL_UNINITIALIZED)
    811860    {
    812861        /* Mode change in progress; wait for all values to be set. */
    813         Log(("vmsvgaChangeMode: BOGUS sEnable LFB mode and resize to (%d,%d) bpp=%d\n", pThis->svga.iWidth, pThis->svga.iHeight, pThis->svga.iBpp));
     862        Log(("vmsvgaChangeMode: BOGUS sEnable LFB mode and resize to (%d,%d) bpp=%d\n", pThis->svga.uWidth, pThis->svga.uHeight, pThis->svga.uBpp));
    814863        return VINF_SUCCESS;
    815864    }
    816865
    817     if (    pThis->last_bpp         == (unsigned)pThis->svga.iBpp
    818         &&  pThis->last_scr_width   == (unsigned)pThis->svga.iWidth
    819         &&  pThis->last_scr_height  == (unsigned)pThis->svga.iHeight
    820         &&  pThis->last_width       == (unsigned)pThis->svga.iWidth
    821         &&  pThis->last_height      == (unsigned)pThis->svga.iHeight
     866    if (    pThis->svga.uWidth == 0
     867        ||  pThis->svga.uHeight == 0
     868        ||  pThis->svga.uBpp == 0)
     869    {
     870        /* Invalid mode change. */
     871        Log(("vmsvgaChangeMode: BOGUS sEnable LFB mode and resize to (%d,%d) bpp=%d\n", pThis->svga.uWidth, pThis->svga.uHeight, pThis->svga.uBpp));
     872        return VINF_SUCCESS;
     873    }
     874
     875    if (    pThis->last_bpp         == (unsigned)pThis->svga.uBpp
     876        &&  pThis->last_scr_width   == (unsigned)pThis->svga.uWidth
     877        &&  pThis->last_scr_height  == (unsigned)pThis->svga.uHeight
     878        &&  pThis->last_width       == (unsigned)pThis->svga.uWidth
     879        &&  pThis->last_height      == (unsigned)pThis->svga.uHeight
    822880        )
    823881    {
    … …  
    827885    }
    828886
    829     Log(("vmsvgaChangeMode: sEnable LFB mode and resize to (%d,%d) bpp=%d\n", pThis->svga.iWidth, pThis->svga.iHeight, pThis->svga.iBpp));
    830     pThis->svga.cbScanline = ((pThis->svga.iWidth * pThis->svga.iBpp + 7) & ~7) / 8;
     887    Log(("vmsvgaChangeMode: sEnable LFB mode and resize to (%d,%d) bpp=%d\n", pThis->svga.uWidth, pThis->svga.uHeight, pThis->svga.uBpp));
     888    pThis->svga.cbScanline = ((pThis->svga.uWidth * pThis->svga.uBpp + 7) & ~7) / 8;
    831889
    832890    pThis->pDrv->pfnLFBModeChange(pThis->pDrv, true);
    833     rc = pThis->pDrv->pfnResize(pThis->pDrv, pThis->svga.iBpp, pThis->CTX_SUFF(vram_ptr), pThis->svga.cbScanline, pThis->svga.iWidth, pThis->svga.iHeight);
     891    rc = pThis->pDrv->pfnResize(pThis->pDrv, pThis->svga.uBpp, pThis->CTX_SUFF(vram_ptr), pThis->svga.cbScanline, pThis->svga.uWidth, pThis->svga.uHeight);
    834892    AssertRC(rc);
    835893    AssertReturn(rc == VINF_SUCCESS || rc == VINF_VGA_RESIZE_IN_PROGRESS, rc);
    836894
    837895    /* last stuff */
    838     pThis->last_bpp         = pThis->svga.iBpp;
    839     pThis->last_scr_width   = pThis->svga.iWidth;
    840     pThis->last_scr_height  = pThis->svga.iHeight;
    841     pThis->last_width       = pThis->svga.iWidth;
    842     pThis->last_height      = pThis->svga.iHeight;
     896    pThis->last_bpp         = pThis->svga.uBpp;
     897    pThis->last_scr_width   = pThis->svga.uWidth;
     898    pThis->last_scr_height  = pThis->svga.uHeight;
     899    pThis->last_width       = pThis->svga.uWidth;
     900    pThis->last_height      = pThis->svga.uHeight;
    843901   
    844902    ASMAtomicOrU32(&pThis->svga.u32ActionFlags, VMSVGA_ACTION_CHANGEMODE);
    845903
     904    /* vmsvgaPortSetViewPort not called after state load; set sensible defaults. */
     905    if (    pThis->svga.viewport.cx == 0
     906        &&  pThis->svga.viewport.cy == 0)
     907    {
     908        pThis->svga.viewport.cx = pThis->svga.uWidth;
     909        pThis->svga.viewport.cy = pThis->svga.uHeight;
     910    }
    846911    return VINF_SUCCESS;
    847912}
    … …  
    872937    case SVGA_REG_ENABLE:
    873938        if (    pThis->svga.fEnabled    == u32
    874             &&  pThis->last_bpp         == (unsigned)pThis->svga.iBpp
    875             &&  pThis->last_scr_width   == (unsigned)pThis->svga.iWidth
    876             &&  pThis->last_scr_height  == (unsigned)pThis->svga.iHeight
    877             &&  pThis->last_width       == (unsigned)pThis->svga.iWidth
    878             &&  pThis->last_height      == (unsigned)pThis->svga.iHeight
     939            &&  pThis->last_bpp         == (unsigned)pThis->svga.uBpp
     940            &&  pThis->last_scr_width   == (unsigned)pThis->svga.uWidth
     941            &&  pThis->last_scr_height  == (unsigned)pThis->svga.uHeight
     942            &&  pThis->last_width       == (unsigned)pThis->svga.uWidth
     943            &&  pThis->last_height      == (unsigned)pThis->svga.uHeight
    879944            )
    880945            /* Nothing to do. */
    … …  
    892957        if (pThis->svga.fEnabled)
    893958        {
    894             if (    pThis->svga.iWidth == -1
    895                 &&  pThis->svga.iHeight == -1
    896                 &&  pThis->svga.iBpp == (unsigned)-1)
     959            if (    pThis->svga.uWidth  == VMSVGA_VAL_UNINITIALIZED
     960                &&  pThis->svga.uHeight == VMSVGA_VAL_UNINITIALIZED
     961                &&  pThis->svga.uBpp    == VMSVGA_VAL_UNINITIALIZED)
    897962            {
    898963                /* Keep the current mode. */
    899                 pThis->svga.iWidth  = pThis->pDrv->cx;
    900                 pThis->svga.iHeight = pThis->pDrv->cy;
    901                 pThis->svga.iBpp    = (pThis->pDrv->cBits + 7) & ~7;
     964                pThis->svga.uWidth  = pThis->pDrv->cx;
     965                pThis->svga.uHeight = pThis->pDrv->cy;
     966                pThis->svga.uBpp    = (pThis->pDrv->cBits + 7) & ~7;
    902967            }
    903968
    904             if (    pThis->svga.iWidth != -1
    905                 &&  pThis->svga.iHeight != -1
    906                 &&  pThis->svga.iBpp != (unsigned)-1)
     969            if (    pThis->svga.uWidth  != VMSVGA_VAL_UNINITIALIZED
     970                &&  pThis->svga.uHeight != VMSVGA_VAL_UNINITIALIZED
     971                &&  pThis->svga.uBpp    != VMSVGA_VAL_UNINITIALIZED)
    907972            {
    908973                rc = vmsvgaChangeMode(pThis);
    … …  
    921986            memcpy(pThis->vram_ptrR3, pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
    922987
    923 /*            pThis->svga.iHeight    = -1;
    924             pThis->svga.iWidth     = -1;
    925             pThis->svga.iBpp       = -1;
     988/*            pThis->svga.uHeight    = -1;
     989            pThis->svga.uWidth     = -1;
     990            pThis->svga.uBpp       = -1;
    926991            pThis->svga.cbScanline = 0; */
    927992            pThis->pDrv->pfnLFBModeChange(pThis->pDrv, false);
    … …  
    9361001
    9371002    case SVGA_REG_WIDTH:
    938         if (pThis->svga.iWidth == (int) u32)
     1003        if (pThis->svga.uWidth == u32)
    9391004            break; /* nop */
    9401005
    941         pThis->svga.iWidth = (int) u32;
     1006        pThis->svga.uWidth = u32;
    9421007        if (pThis->svga.fEnabled)
    9431008        {
    … …  
    9531018
    9541019    case SVGA_REG_HEIGHT:
    955         if (pThis->svga.iHeight == (int) u32)
     1020        if (pThis->svga.uHeight == u32)
    9561021            break; /* nop */
    9571022
    958         pThis->svga.iHeight = (int) u32;
     1023        pThis->svga.uHeight = u32;
    9591024        if (pThis->svga.fEnabled)
    9601025        {
    … …  
    9741039
    9751040    case SVGA_REG_BITS_PER_PIXEL:      /* Current bpp in the guest */
    976         if (pThis->svga.iBpp == u32)
     1041        if (pThis->svga.uBpp == u32)
    9771042            break; /* nop */
    9781043
    979         pThis->svga.iBpp = u32;
     1044        pThis->svga.uBpp = u32;
    9801045        if (pThis->svga.fEnabled)
    9811046        {
    … …  
    12531318
    12541319    case SVGA_IRQSTATUS_PORT:
    1255         Log(("vmsvgaIORead: SVGA_IRQSTATUS_PORT %x\n", pThis->svga.u32IrqStatus));
     1320        LogFlow(("vmsvgaIORead: SVGA_IRQSTATUS_PORT %x\n", pThis->svga.u32IrqStatus));
    12561321        *pu32 = pThis->svga.u32IrqStatus;
    12571322        break;
    … …  
    18031868
    18041869    Assert(ppfBounceBuffer);
     1870    /* Commands bigger than the fifo buffer are invalid. */
     1871    AssertReturn(cbCmd <= cbFIFOCmd, NULL);
    18051872
    18061873    *pSize          += cbCmd;
    … …  
    18811948        Log(("vmsvgaFIFOLoop: min  %x max  %x\n", pFIFO[SVGA_FIFO_MIN], pFIFO[SVGA_FIFO_MAX]));
    18821949        Log(("vmsvgaFIFOLoop: next %x stop %x\n", pFIFO[SVGA_FIFO_NEXT_CMD], pFIFO[SVGA_FIFO_STOP]));
     1950
     1951        if (pThis->svga.u8FIFOExtCommand != VMSVGA_FIFO_EXTCMD_NONE)
     1952        {
     1953            switch (pThis->svga.u8FIFOExtCommand)
     1954            {
     1955            case VMSVGA_FIFO_EXTCMD_RESET:
     1956                Log(("vmsvgaFIFOLoop: reset the fifo thread.\n"));
     1957#ifdef VBOX_WITH_VMSVGA3D
     1958                if (pThis->svga.f3DEnabled)
     1959                {
     1960                    /* The 3d subsystem must be reset from the fifo thread. */
     1961                    vmsvga3dReset(pThis);
     1962                }
     1963#endif
     1964                break;
     1965
     1966            case VMSVGA_FIFO_EXTCMD_TERMINATE:
     1967                Log(("vmsvgaFIFOLoop: terminate the fifo thread.\n"));
     1968#ifdef VBOX_WITH_VMSVGA3D
     1969                if (pThis->svga.f3DEnabled)
     1970                {
     1971                    /* The 3d subsystem must be shut down from the fifo thread. */
     1972                    vmsvga3dTerminate(pThis);
     1973                }
     1974#endif
     1975                break;
     1976
     1977            case VMSVGA_FIFO_EXTCMD_SAVESTATE:
     1978                Log(("vmsvgaFIFOLoop: VMSVGA_FIFO_EXTCMD_SAVESTATE.\n"));
     1979#ifdef VBOX_WITH_VMSVGA3D
     1980                vmsvga3dSaveExec(pThis, (PSSMHANDLE)pThis->svga.pFIFOExtCmdParam);
     1981#endif
     1982                break;
     1983
     1984            case VMSVGA_FIFO_EXTCMD_LOADSTATE:
     1985            {
     1986                Log(("vmsvgaFIFOLoop: VMSVGA_FIFO_EXTCMD_LOADSTATE.\n"));
     1987#ifdef VBOX_WITH_VMSVGA3D
     1988                PVMSVGA_STATE_LOAD pLoadState = (PVMSVGA_STATE_LOAD)pThis->svga.pFIFOExtCmdParam;
     1989                vmsvga3dLoadExec(pThis, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
     1990#endif
     1991                break;
     1992            }
     1993            }
     1994
     1995            pThis->svga.u8FIFOExtCommand = VMSVGA_FIFO_EXTCMD_NONE;
     1996
     1997            /* Signal the end of the external command. */
     1998            RTSemEventSignal(pThis->svga.FIFOExtCmdSem);
     1999            continue;
     2000        }
    18832001
    18842002        if (    !pThis->svga.fEnabled
    … …  
    19272045                {}
    19282046#endif
     2047            /* Check for pending external commands. */
     2048            if (pThis->svga.u8FIFOExtCommand != VMSVGA_FIFO_EXTCMD_NONE)
     2049                break;
     2050
    19292051            u32Current = pFIFO[SVGA_FIFO_STOP];
    19302052
    … …  
    19882110                Log(("vmsvgaFIFOLoop: ALPHA_CURSOR id=%d size (%d,%d) hotspot (%d,%d)\n", pCursor->id, pCursor->width, pCursor->height, pCursor->hotspotX, pCursor->hotspotY));
    19892111
     2112                /* Check against a reasonable upper limit to prevent integer overflows in the sanity checks below. */
     2113                AssertReturn(pCursor->height < 2048 && pCursor->width < 2048, VERR_INVALID_PARAMETER);
     2114
    19902115                /* Refetch the command buffer with the added bitmap data; undo size increase (ugly) */
    19912116                cbCmd = sizeof(SVGAFifoCmdDefineAlphaCursor) + pCursor->width * pCursor->height * sizeof(uint32_t) /* 32-bit BRGA format */;
    … …  
    20192144                                                            pCursorCopy);
    20202145                AssertRC(rc);
    2021                 RTMemFree(pCursorCopy);
    2022 
     2146
     2147                if (pSVGAState->Cursor.fActive)
     2148                    RTMemFree(pSVGAState->Cursor.pData);
     2149
     2150                pSVGAState->Cursor.fActive  = true;
     2151                pSVGAState->Cursor.xHotspot = pCursor->hotspotX;
     2152                pSVGAState->Cursor.yHotspot = pCursor->hotspotY;
     2153                pSVGAState->Cursor.width    = pCursor->width;
     2154                pSVGAState->Cursor.height   = pCursor->height;
     2155                pSVGAState->Cursor.cbData   = cbCursorShape;
     2156                pSVGAState->Cursor.pData    = pCursorCopy;
    20232157                break;
    20242158            }
    … …  
    20802214
    20812215                if (!pCmd->numPages)
     2216                {
    20822217                    vmsvgaGMRFree(pThis, pCmd->gmrId);
    2083                 /* else everything done in remap */
    2084 
     2218                }
     2219                else
     2220                {
     2221                    PGMR pGMR = &pSVGAState->aGMR[pCmd->gmrId];
     2222                    pGMR->cMaxPages = pCmd->numPages;
     2223                }
     2224                /* everything done in remap */
    20852225                break;
    20862226            }
    … …  
    20922232                uint32_t cbPageDesc = (pCmd->flags & SVGA_REMAP_GMR2_PPN64) ? sizeof(uint64_t) : sizeof(uint32_t);
    20932233                uint32_t cbCmd;
     2234                uint64_t *paNewPage64 = NULL;
    20942235
    20952236                Log(("vmsvgaFIFOLoop: SVGA_CMD_REMAP_GMR2 id=%x flags=%x offset=%x npages=%x\n", pCmd->gmrId, pCmd->flags, pCmd->offsetPages, pCmd->numPages));
    2096 
    2097                 /* @todo */
    2098                 AssertBreak(pCmd->offsetPages == 0);
    20992237
    21002238                /* Refetch the command buffer with the variable data; undo size increase (ugly) */
    … …  
    21212259                /* Validate current GMR id. */
    21222260                AssertBreak(pCmd->gmrId < VMSVGA_MAX_GMR_IDS);
    2123                 AssertBreak(pCmd->numPages <= VMSVGA_MAX_GMR_PAGES);
     2261                AssertBreak(pCmd->offsetPages + pCmd->numPages <= pGMR->cMaxPages);
     2262                AssertBreak(!pCmd->offsetPages || pGMR->paDesc); /* @todo */
     2263
     2264                /* Save the old page descriptors as an array of page addresses (>> PAGE_SHIFT) */
     2265                if (pGMR->paDesc)
     2266                {
     2267                    uint32_t idxPage = 0;
     2268                    paNewPage64 = (uint64_t *)RTMemAllocZ(pGMR->cMaxPages * sizeof(uint64_t));
     2269                    AssertBreak(paNewPage64);
     2270
     2271                    for (uint32_t i = 0; i < pGMR->numDescriptors; i++)
     2272                    {
     2273                        for (uint32_t j = 0; j < pGMR->paDesc[i].numPages; j++)
     2274                        {
     2275                            paNewPage64[idxPage++] = (pGMR->paDesc[i].GCPhys + j * PAGE_SIZE) >> PAGE_SHIFT;
     2276                        }
     2277                    }
     2278                    AssertBreak(idxPage == pGMR->cbTotal >> PAGE_SHIFT);
     2279                }
    21242280
    21252281                /* Free the old GMR if present. */
    2126                 vmsvgaGMRFree(pThis, pCmd->gmrId);
    2127 
    2128                 pGMR->paDesc = (PVMSVGAGMRDESCRIPTOR)RTMemAllocZ(pCmd->numPages * sizeof(VMSVGAGMRDESCRIPTOR));
     2282                if (pGMR->paDesc)
     2283                    RTMemFree(pGMR->paDesc);
     2284
     2285                /* Allocate the maximum amount possible (everything non-continuous) */
     2286                pGMR->paDesc = (PVMSVGAGMRDESCRIPTOR)RTMemAllocZ(pGMR->cMaxPages * sizeof(VMSVGAGMRDESCRIPTOR));
    21292287                AssertBreak(pGMR->paDesc);
    21302288
    … …  
    21362294                else
    21372295                {
    2138                     uint32_t *pPage32 = (uint32_t *)(pCmd + 1);
    2139                     uint64_t *pPage64 = (uint64_t *)(pCmd + 1);
    2140                     uint32_t iDescriptor = 0;
    2141                     RTGCPHYS GCPhys;
    2142 
    2143                     if (pCmd->flags & SVGA_REMAP_GMR2_PPN64)
     2296                    uint32_t            *pPage32 = (uint32_t *)(pCmd + 1);
     2297                    uint64_t            *pPage64 = (uint64_t *)(pCmd + 1);
     2298                    uint32_t             iDescriptor = 0;
     2299                    RTGCPHYS             GCPhys;
     2300                    PVMSVGAGMRDESCRIPTOR paDescOld = NULL;
     2301                    bool                 fGCPhys64 = !!(pCmd->flags & SVGA_REMAP_GMR2_PPN64);
     2302
     2303                    if (paNewPage64)
     2304                    {
     2305                        /* Overwrite the old page array with the new page values. */
     2306                        for (uint32_t i = pCmd->offsetPages; i < pCmd->offsetPages + pCmd->numPages; i++)
     2307                        {
     2308                            if (pCmd->flags & SVGA_REMAP_GMR2_PPN64)
     2309                                paNewPage64[i] = pPage64[i - pCmd->offsetPages];
     2310                            else
     2311                                paNewPage64[i] = pPage32[i - pCmd->offsetPages];
     2312                        }
     2313                        /* Use the updated page array instead of the command data. */
     2314                        fGCPhys64      = true;
     2315                        pPage64        = paNewPage64;
     2316                        pCmd->numPages = pGMR->cbTotal >> PAGE_SHIFT;
     2317                    }
     2318
     2319                    if (fGCPhys64)
    21442320                        GCPhys = (pPage64[0] << PAGE_SHIFT) & 0x00000FFFFFFFFFFFULL;    /* seeing rubbish in the top bits with certain linux guests*/
    21452321                    else
    … …  
    21782354                }
    21792355
     2356                if (paNewPage64)
     2357                    RTMemFree(paNewPage64);
     2358
    21802359#ifdef DEBUG_GMR_ACCESS
    21812360                VMR3ReqCallWait(PDMDevHlpGetVM(pThis->pDevInsR3), VMCPUID_ANY, (PFNRT)vmsvgaRegisterGMR, 2, pThis->pDevInsR3, pCmd->gmrId);
    … …  
    22022381                    Log(("vmsvgaFIFOLoop: SVGA_CMD_DEFINE_SCREEN flags SVGA_SCREEN_BLANKING\n"));
    22032382
    2204                 pThis->svga.iWidth  = pCmd->screen.size.width;
    2205                 pThis->svga.iHeight = pCmd->screen.size.height;
     2383                pThis->svga.uWidth  = pCmd->screen.size.width;
     2384                pThis->svga.uHeight = pCmd->screen.size.height;
    22062385                vmsvgaChangeMode(pThis);
    22072386                break;
    … …  
    22302409            {
    22312410                SVGAFifoCmdBlitGMRFBToScreen *pCmd = (SVGAFifoCmdBlitGMRFBToScreen *)vmsvgaFIFOGetCmdBuffer(pThread, pFIFO, sizeof(SVGAFifoCmdBlitGMRFBToScreen), &size, &pBounceBuffer);
    2232                 int32_t width, height;
     2411                uint32_t width, height;
    22332412
    22342413                Log(("vmsvgaFIFOLoop: SVGA_CMD_BLIT_GMRFB_TO_SCREEN src=(%d,%d) dest id=%d (%d,%d)(%d,%d)\n", pCmd->srcOrigin.x, pCmd->srcOrigin.y, pCmd->destScreenId, pCmd->destRect.left, pCmd->destRect.top, pCmd->destRect.right, pCmd->destRect.bottom));
    22352414
    22362415                /* @todo */
    2237                 AssertBreak(pSVGAState->GMRFB.format.s.bitsPerPixel == pThis->svga.iBpp);
     2416                AssertBreak(pSVGAState->GMRFB.format.s.bitsPerPixel == pThis->svga.uBpp);
    22382417                AssertBreak(pCmd->destScreenId == 0);
    22392418
    … …  
    22552434
    22562435                /* Clip to screen dimensions. */
    2257                 if (width > pThis->svga.iWidth)
    2258                     width = pThis->svga.iWidth;
    2259                 if (height > pThis->svga.iHeight)
    2260                     height = pThis->svga.iHeight;
     2436                if (width > pThis->svga.uWidth)
     2437                    width = pThis->svga.uWidth;
     2438                if (height > pThis->svga.uHeight)
     2439                    height = pThis->svga.uHeight;
    22612440
    22622441                unsigned offsetSource = (pCmd->srcOrigin.x * pSVGAState->GMRFB.format.s.bitsPerPixel) / 8 + pSVGAState->GMRFB.bytesPerLine * pCmd->srcOrigin.y;
    2263                 unsigned offsetDest   = (pCmd->destRect.left * RT_ALIGN(pThis->svga.iBpp, 8)) / 8 + pThis->svga.cbScanline * pCmd->destRect.top;
    2264                 unsigned cbCopyWidth  = (width * RT_ALIGN(pThis->svga.iBpp, 8)) / 8;
     2442                unsigned offsetDest   = (pCmd->destRect.left * RT_ALIGN(pThis->svga.uBpp, 8)) / 8 + pThis->svga.cbScanline * pCmd->destRect.top;
     2443                unsigned cbCopyWidth  = (width * RT_ALIGN(pThis->svga.uBpp, 8)) / 8;
     2444
     2445                AssertReturn(offsetDest < pThis->vram_size, VERR_INVALID_PARAMETER);
    22652446
    22662447                rc = vmsvgaGMRTransfer(pThis, SVGA3D_WRITE_HOST_VRAM, pThis->CTX_SUFF(vram_ptr) + offsetDest, pThis->svga.cbScanline, pSVGAState->GMRFB.ptr, offsetSource, pSVGAState->GMRFB.bytesPerLine, cbCopyWidth, height);
    22672448                AssertRC(rc);
    2268 
    22692449                vgaR3UpdateDisplay(pThis, pCmd->destRect.left, pCmd->destRect.top, pCmd->destRect.right - pCmd->destRect.left, pCmd->destRect.bottom - pCmd->destRect.top);
    22702450                break;
    … …  
    26632843    if (pSVGAState->aGMR[idGMR].numDescriptors)
    26642844    {
     2845        PGMR pGMR = &pSVGAState->aGMR[idGMR];
    26652846#ifdef DEBUG_GMR_ACCESS
    26662847        VMR3ReqCallWait(PDMDevHlpGetVM(pThis->pDevInsR3), VMCPUID_ANY, (PFNRT)vmsvgaUnregisterGMR, 2, pThis->pDevInsR3, idGMR);
    26672848#endif
    26682849
    2669         Assert(pSVGAState->aGMR[idGMR].paDesc);
    2670         RTMemFree(pSVGAState->aGMR[idGMR].paDesc);
    2671         pSVGAState->aGMR[idGMR].paDesc         = NULL;
    2672         pSVGAState->aGMR[idGMR].numDescriptors = 0;
    2673         pSVGAState->aGMR[idGMR].cbTotal        = 0;
     2850        Assert(pGMR->paDesc);
     2851        RTMemFree(pGMR->paDesc);
     2852        pGMR->paDesc         = NULL;
     2853        pGMR->numDescriptors = 0;
     2854        pGMR->cbTotal        = 0;
     2855        pGMR->cMaxPages      = 0;
    26742856    }
    26752857    Assert(!pSVGAState->aGMR[idGMR].cbTotal);
    … …  
    26902872 * @param   cHeight         Source height
    26912873 */
    2692 int vmsvgaGMRTransfer(PVGASTATE pThis, const SVGA3dTransferType transfer, uint8_t *pDest, uint32_t cbDestPitch, SVGAGuestPtr src, uint32_t cbSrcOffset, uint32_t cbSrcPitch, uint32_t cbWidth, uint32_t cHeight)
     2874int vmsvgaGMRTransfer(PVGASTATE pThis, const SVGA3dTransferType transfer, uint8_t *pDest, int32_t cbDestPitch, SVGAGuestPtr src, uint32_t cbSrcOffset, int32_t cbSrcPitch, uint32_t cbWidth, uint32_t cHeight)
    26932875{
    26942876    PVMSVGASTATE            pSVGAState = (PVMSVGASTATE)pThis->svga.pSVGAState;
    … …  
    27052887    {
    27062888        cbSrcOffset += src.offset;
     2889        AssertReturn(src.offset < pThis->vram_size, VERR_INVALID_PARAMETER);
    27072890        AssertReturn(cbSrcOffset + cbSrcPitch * (cHeight - 1) + cbWidth <= pThis->vram_size, VERR_INVALID_PARAMETER);
    27082891
    … …  
    27122895        {
    27132896            /* switch src & dest */
    2714             uint8_t *pTemp       = pDest;
    2715             uint32_t cbTempPitch = cbDestPitch;
     2897            uint8_t *pTemp      = pDest;
     2898            int32_t cbTempPitch = cbDestPitch;
    27162899
    27172900            pDest = pSrc;
    … …  
    27232906
    27242907        if (    pThis->svga.cbScanline == cbDestPitch
    2725             &&  cbWidth == cbDestPitch)
     2908            &&  cbWidth == cbDestPitch
     2909            &&  cbSrcPitch == cbDestPitch)
    27262910        {
    27272911            memcpy(pDest, pSrc, cbWidth * cHeight);
    … …  
    27452929
    27462930    cbSrcOffset += src.offset;
     2931    AssertReturn(src.offset < pGMR->cbTotal, VERR_INVALID_PARAMETER);
    27472932    AssertReturn(cbSrcOffset + cbSrcPitch * (cHeight - 1) + cbWidth <= pGMR->cbTotal, VERR_INVALID_PARAMETER);
    2748 
     2933   
    27492934    for (unsigned i = 0; i < cHeight; i++)
    27502935    {
    … …  
    27662951           
    27672952            if (uCurrentOffset + cbCurrentWidth <= uDescOffset + pDesc->numPages * PAGE_SIZE)
     2953            {
    27682954                cbToCopy = cbCurrentWidth;
     2955            }
    27692956            else
     2957            {
    27702958                cbToCopy = (uDescOffset + pDesc->numPages * PAGE_SIZE - uCurrentOffset);
     2959                AssertReturn(cbToCopy <= cbCurrentWidth, VERR_INVALID_PARAMETER);
     2960            }
    27712961
    27722962            LogFlow(("vmsvgaGMRTransfer: %s phys=%RGp\n", (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", pDesc->GCPhys + uCurrentOffset - uDescOffset));
    … …  
    28333023
    28343024        Log(("vmsvgaSetTraces: enable dirty page handling for the frame buffer only (%x bytes)\n", 0));
    2835         if (pThis->svga.iHeight != -1)
     3025        if (pThis->svga.uHeight != VMSVGA_VAL_UNINITIALIZED)
    28363026        {
    28373027            Assert(pThis->svga.cbScanline);
    28383028            /* Hardware enabled; return real framebuffer size .*/
    2839             cbFrameBuffer = (uint32_t)pThis->svga.iHeight * pThis->svga.cbScanline;
     3029            cbFrameBuffer = (uint32_t)pThis->svga.uHeight * pThis->svga.cbScanline;
    28403030            cbFrameBuffer = RT_ALIGN(cbFrameBuffer, PAGE_SIZE);
    28413031        }
    … …  
    28793069    PVGASTATE   pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
    28803070
     3071    Log(("vgasvgaR3IORegionMap: iRegion=%d GCPhysAddress=%RGp cb=%#x enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
    28813072    if (enmType == PCI_ADDRESS_SPACE_IO)
    28823073    {
    … …  
    29443135
    29453136    /* Load our part of the VGAState */
    2946     rc = SSMR3GetStruct(pSSM, &pThis->svga, g_aVGAStateSVGAFields);
    2947     AssertReturn(rc, rc);
     3137    rc = SSMR3GetStructEx(pSSM, &pThis->svga, sizeof(pThis->svga), 0, g_aVGAStateSVGAFields, NULL);
     3138    AssertRCReturn(rc, rc);
    29483139
    29493140    /* Load the framebuffer backup. */
    29503141    rc = SSMR3GetMem(pSSM, pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
    2951     AssertReturn(rc, rc);
     3142    AssertRCReturn(rc, rc);
    29523143
    29533144    /* Load the VMSVGA state. */
    2954     rc = SSMR3GetStruct(pSSM, pSVGAState, g_aVMSVGASTATEFields);
    2955     AssertReturn(rc, rc);
    2956 
    2957     /* Save the GMR state */
     3145    rc = SSMR3GetStructEx(pSSM, pSVGAState, sizeof(*pSVGAState), 0, g_aVMSVGASTATEFields, NULL);
     3146    AssertRCReturn(rc, rc);
     3147
     3148    /* Load the active cursor bitmaps. */
     3149    if (pSVGAState->Cursor.fActive)
     3150    {
     3151        pSVGAState->Cursor.pData = RTMemAlloc(pSVGAState->Cursor.cbData);
     3152        AssertReturn(pSVGAState->Cursor.pData, VERR_NO_MEMORY);
     3153
     3154        rc = SSMR3GetMem(pSSM, pSVGAState->Cursor.pData, pSVGAState->Cursor.cbData);
     3155        AssertRCReturn(rc, rc);
     3156    }
     3157
     3158    /* Load the GMR state */
    29583159    for (uint32_t i = 0; i < RT_ELEMENTS(pSVGAState->aGMR); i++)
    29593160    {
    2960         rc = SSMR3GetStruct(pSSM, &pSVGAState->aGMR[i], g_aGMRFields);
    2961         AssertReturn(rc, rc);
    2962 
    2963         for (uint32_t j = 0; j < pSVGAState->aGMR[i].numDescriptors; j++)
    2964         {
    2965             rc = SSMR3GetStruct(pSSM, &pSVGAState->aGMR[i].paDesc[j], g_aVMSVGAGMRDESCRIPTORFields);
    2966             AssertReturn(rc, rc);
     3161        PGMR pGMR = &pSVGAState->aGMR[i];
     3162
     3163        rc = SSMR3GetStructEx(pSSM, pGMR, sizeof(*pGMR), 0, g_aGMRFields, NULL);
     3164        AssertRCReturn(rc, rc);
     3165
     3166        if (pGMR->numDescriptors)
     3167        {
     3168            /* Allocate the maximum amount possible (everything non-continuous) */
     3169            Assert(pGMR->cMaxPages || pGMR->cbTotal);
     3170            pGMR->paDesc = (PVMSVGAGMRDESCRIPTOR)RTMemAllocZ((pGMR->cMaxPages) ? pGMR->cMaxPages : (pGMR->cbTotal >> PAGE_SHIFT) * sizeof(VMSVGAGMRDESCRIPTOR));
     3171            AssertReturn(pGMR->paDesc, VERR_NO_MEMORY);
     3172
     3173            for (uint32_t j = 0; j < pGMR->numDescriptors; j++)
     3174            {
     3175                rc = SSMR3GetStructEx(pSSM, &pGMR->paDesc[j], sizeof(pGMR->paDesc[j]), 0, g_aVMSVGAGMRDESCRIPTORFields, NULL);
     3176                AssertRCReturn(rc, rc);
     3177            }
    29673178        }
    29683179    }
    29693180
    29703181#ifdef VBOX_WITH_VMSVGA3D
    2971     if (    uVersion >= VGA_SAVEDSTATE_VERSION_VMSVGA
    2972         &&  pThis->svga.f3DEnabled)
    2973         vmsvga3dLoadExec(pThis, pSSM, uVersion, uPass);
     3182    if (pThis->svga.f3DEnabled)
     3183    {
     3184        VMSVGA_STATE_LOAD loadstate;
     3185
     3186        loadstate.pSSM     = pSSM;
     3187        loadstate.uVersion = uVersion;
     3188        loadstate.uPass    = uPass;
     3189
     3190        /* Save the 3d state in the FIFO thread. */
     3191        pThis->svga.u8FIFOExtCommand = VMSVGA_FIFO_EXTCMD_LOADSTATE;
     3192        pThis->svga.pFIFOExtCmdParam = (void *)&loadstate;
     3193        /* Hack alert: resume the IO thread as it has been suspended before the destruct callback.
     3194         * The PowerOff notification isn't working, so not an option in this case.
     3195         */
     3196        PDMR3ThreadResume(pThis->svga.pFIFOIOThread);
     3197        RTSemEventSignal(pThis->svga.FIFORequestSem);
     3198        /* Wait for the end of the command. */
     3199        rc = RTSemEventWait(pThis->svga.FIFOExtCmdSem, RT_INDEFINITE_WAIT);
     3200        AssertRC(rc);
     3201        PDMR3ThreadSuspend(pThis->svga.pFIFOIOThread);
     3202    }
    29743203#endif
    29753204
    … …  
    29773206}
    29783207
     3208/**
     3209 * Reinit the video mode after the state has been loaded.
     3210 */
     3211int vmsvgaLoadDone(PPDMDEVINS pDevIns)
     3212{
     3213    PVGASTATE    pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     3214    PVMSVGASTATE pSVGAState = (PVMSVGASTATE)pThis->svga.pSVGAState;
     3215
     3216    pThis->last_bpp = VMSVGA_VAL_UNINITIALIZED;   /* force mode reset */
     3217    vmsvgaChangeMode(pThis);
     3218
     3219    /* Set the active cursor. */
     3220    if (pSVGAState->Cursor.fActive)
     3221    {
     3222        int rc;
     3223
     3224        rc = pThis->pDrv->pfnVBVAMousePointerShape (pThis->pDrv,
     3225                                                    true,
     3226                                                    true,
     3227                                                    pSVGAState->Cursor.xHotspot,
     3228                                                    pSVGAState->Cursor.yHotspot,
     3229                                                    pSVGAState->Cursor.width,
     3230                                                    pSVGAState->Cursor.height,
     3231                                                    pSVGAState->Cursor.pData);
     3232        AssertRC(rc);
     3233    }
     3234    return VINF_SUCCESS;
     3235}
    29793236
    29803237/**
    … …  
    29883245
    29893246    /* Save our part of the VGAState */
    2990     rc = SSMR3PutStruct(pSSM, &pThis->svga, g_aVGAStateSVGAFields);
    2991     AssertReturn(rc, rc);
     3247    rc = SSMR3PutStructEx(pSSM, &pThis->svga, sizeof(pThis->svga), 0, g_aVGAStateSVGAFields, NULL);
     3248    AssertRCReturn(rc, rc);
    29923249
    29933250    /* Save the framebuffer backup. */
    29943251    rc = SSMR3PutMem(pSSM, pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
    2995     AssertReturn(rc, rc);
     3252    AssertRCReturn(rc, rc);
    29963253
    29973254    /* Save the VMSVGA state. */
    2998     rc = SSMR3PutStruct(pSSM, pSVGAState, g_aVMSVGASTATEFields);
    2999     AssertReturn(rc, rc);
     3255    rc = SSMR3PutStructEx(pSSM, pSVGAState, sizeof(*pSVGAState), 0, g_aVMSVGASTATEFields, NULL);
     3256    AssertRCReturn(rc, rc);
     3257
     3258    /* Save the active cursor bitmaps. */
     3259    if (pSVGAState->Cursor.fActive)
     3260    {
     3261        rc = SSMR3PutMem(pSSM, pSVGAState->Cursor.pData, pSVGAState->Cursor.cbData);
     3262        AssertRCReturn(rc, rc);
     3263    }
    30003264
    30013265    /* Save the GMR state */
    30023266    for (uint32_t i = 0; i < RT_ELEMENTS(pSVGAState->aGMR); i++)
    30033267    {
    3004         rc = SSMR3PutStruct(pSSM, &pSVGAState->aGMR[i], g_aGMRFields);
    3005         AssertReturn(rc, rc);
     3268        rc = SSMR3PutStructEx(pSSM, &pSVGAState->aGMR[i], sizeof(pSVGAState->aGMR[i]), 0, g_aGMRFields, NULL);
     3269        AssertRCReturn(rc, rc);
    30063270
    30073271        for (uint32_t j = 0; j < pSVGAState->aGMR[i].numDescriptors; j++)
    30083272        {
    3009             rc = SSMR3PutStruct(pSSM, &pSVGAState->aGMR[i].paDesc[j], g_aVMSVGAGMRDESCRIPTORFields);
    3010             AssertReturn(rc, rc);
     3273            rc = SSMR3PutStructEx(pSSM, &pSVGAState->aGMR[i].paDesc[j], sizeof(pSVGAState->aGMR[i].paDesc[j]), 0, g_aVMSVGAGMRDESCRIPTORFields, NULL);
     3274            AssertRCReturn(rc, rc);
    30113275        }
    30123276    }
    … …  
    30143278#ifdef VBOX_WITH_VMSVGA3D
    30153279    if (pThis->svga.f3DEnabled)
    3016         vmsvga3dSaveExec(pThis, pSSM);
     3280    {
     3281        /* Save the 3d state in the FIFO thread. */
     3282        pThis->svga.u8FIFOExtCommand = VMSVGA_FIFO_EXTCMD_SAVESTATE;
     3283        pThis->svga.pFIFOExtCmdParam = (void *)pSSM;
     3284        /* Hack alert: resume the IO thread as it has been suspended before the destruct callback.
     3285         * The PowerOff notification isn't working, so not an option in this case.
     3286         */
     3287        PDMR3ThreadResume(pThis->svga.pFIFOIOThread);
     3288        RTSemEventSignal(pThis->svga.FIFORequestSem);
     3289        /* Wait for the end of the external command. */
     3290        rc = RTSemEventWait(pThis->svga.FIFOExtCmdSem, RT_INDEFINITE_WAIT);
     3291        AssertRC(rc);
     3292        PDMR3ThreadSuspend(pThis->svga.pFIFOIOThread);
     3293    }
    30173294#endif
    30183295    return VINF_SUCCESS;
     3296}
     3297
     3298/**
     3299 * Resets the SVGA hardware state
     3300 *
     3301 * @returns VBox status code.
     3302 * @param   pDevIns     The device instance.
     3303 */
     3304int vmsvgaReset(PPDMDEVINS pDevIns)
     3305{
     3306    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     3307    PVMSVGASTATE pSVGAState = (PVMSVGASTATE)pThis->svga.pSVGAState;
     3308
     3309    /* Reset before init? */
     3310    if (!pSVGAState)
     3311        return VINF_SUCCESS;
     3312
     3313    Log(("vmsvgaReset\n"));
     3314
     3315    pThis->svga.pFIFOR3[SVGA_FIFO_NEXT_CMD]         = pThis->svga.pFIFOR3[SVGA_FIFO_STOP]                 = 0;
     3316
     3317    /* Reset the FIFO thread. */
     3318    pThis->svga.u8FIFOExtCommand = VMSVGA_FIFO_EXTCMD_RESET;
     3319    RTSemEventSignal(pThis->svga.FIFORequestSem);
     3320    /* Wait for the end of the termination sequence. */
     3321    int rc = RTSemEventWait(pThis->svga.FIFOExtCmdSem, 10000);
     3322    AssertRC(rc);
     3323
     3324    pThis->svga.cScratchRegion = VMSVGA_SCRATCH_SIZE;
     3325    memset(pThis->svga.au32ScratchRegion, 0, sizeof(pThis->svga.au32ScratchRegion));
     3326    memset(pThis->svga.pSVGAState, 0, sizeof(VMSVGASTATE));
     3327    memset(pThis->svga.pFrameBufferBackup, 0, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
     3328
     3329    /* Register caps. */
     3330    pThis->svga.u32RegCaps = SVGA_CAP_GMR | SVGA_CAP_GMR2 | SVGA_CAP_CURSOR | SVGA_CAP_CURSOR_BYPASS_2 | SVGA_CAP_EXTENDED_FIFO | SVGA_CAP_IRQMASK | SVGA_CAP_PITCHLOCK | SVGA_CAP_TRACES | SVGA_CAP_SCREEN_OBJECT_2 | SVGA_CAP_ALPHA_CURSOR;
     3331#ifdef VBOX_WITH_VMSVGA3D
     3332    pThis->svga.u32RegCaps |= SVGA_CAP_3D;
     3333#endif
     3334
     3335    /* Setup FIFO capabilities. */
     3336    pThis->svga.pFIFOR3[SVGA_FIFO_CAPABILITIES] = SVGA_FIFO_CAP_FENCE | SVGA_FIFO_CAP_CURSOR_BYPASS_3 | SVGA_FIFO_CAP_GMR2 | SVGA_FIFO_CAP_3D_HWVERSION_REVISED | SVGA_FIFO_CAP_SCREEN_OBJECT_2;
     3337
     3338    /* Valid with SVGA_FIFO_CAP_SCREEN_OBJECT_2 */
     3339    pThis->svga.pFIFOR3[SVGA_FIFO_CURSOR_SCREEN_ID] = SVGA_ID_INVALID;
     3340
     3341    /* VRAM tracking is enabled by default during bootup. */
     3342    pThis->svga.fVRAMTracking = true;
     3343    pThis->svga.fEnabled      = false;
     3344
     3345    /* Invalidate current settings. */
     3346    pThis->svga.uWidth     = VMSVGA_VAL_UNINITIALIZED;
     3347    pThis->svga.uHeight    = VMSVGA_VAL_UNINITIALIZED;
     3348    pThis->svga.uBpp       = VMSVGA_VAL_UNINITIALIZED;
     3349    pThis->svga.cbScanline = 0;
     3350
     3351    return rc;
    30193352}
    30203353
    … …  
    30293362    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
    30303363    PVMSVGASTATE pSVGAState = (PVMSVGASTATE)pThis->svga.pSVGAState;
     3364    int          rc;
     3365
     3366    /* Stop the FIFO thread. */
     3367    pThis->svga.u8FIFOExtCommand = VMSVGA_FIFO_EXTCMD_TERMINATE;
     3368    /* Hack alert: resume the IO thread as it has been suspended before the destruct callback.
     3369     * The PowerOff notification isn't working, so not an option in this case.
     3370     */
     3371    PDMR3ThreadResume(pThis->svga.pFIFOIOThread);
     3372    RTSemEventSignal(pThis->svga.FIFORequestSem);
     3373    /* Wait for the end of the termination sequence. */
     3374    rc = RTSemEventWait(pThis->svga.FIFOExtCmdSem, 10000);
     3375    AssertRC(rc);
     3376    PDMR3ThreadSuspend(pThis->svga.pFIFOIOThread);
    30313377
    30323378    if (pSVGAState)
    30333379    {
     3380        if (pSVGAState->Cursor.fActive)
     3381            RTMemFree(pSVGAState->Cursor.pData);
     3382
    30343383        for (unsigned i = 0; i < RT_ELEMENTS(pSVGAState->aGMR); i++)
    30353384        {
    … …  
    30393388        RTMemFree(pSVGAState);
    30403389    }
    3041 
    3042 #ifdef VBOX_WITH_VMSVGA3D
    3043     /** @todo */
    3044     if (pThis->svga.f3DEnabled)
    3045         vmsvga3dTerminate(pThis);
    3046 #endif
     3390    if (pThis->svga.pFrameBufferBackup)
     3391        RTMemFree(pThis->svga.pFrameBufferBackup);
     3392    if (pThis->svga.FIFOExtCmdSem)
     3393        RTSemEventDestroy(pThis->svga.FIFOExtCmdSem);
     3394    if (pThis->svga.FIFORequestSem)
     3395        RTSemEventDestroy(pThis->svga.FIFORequestSem);
     3396
    30473397    return VINF_SUCCESS;
    30483398}
    … …  
    30803430    }
    30813431
     3432    /* Create event semaphore. */
     3433    rc = RTSemEventCreate(&pThis->svga.FIFOExtCmdSem);
     3434    if (RT_FAILURE(rc))
     3435    {
     3436        Log(("%s: Failed to create event semaphore for external fifo cmd handling.\n", __FUNCTION__));
     3437        return rc;
     3438    }
     3439
    30823440    /* Register caps. */
    3083     pThis->svga.u32RegCaps = SVGA_CAP_GMR | SVGA_CAP_GMR2 | SVGA_CAP_CURSOR | SVGA_CAP_CURSOR_BYPASS_2 | SVGA_CAP_EXTENDED_FIFO | SVGA_CAP_IRQMASK | SVGA_CAP_PITCHLOCK | SVGA_CAP_TRACES | SVGA_CAP_SCREEN_OBJECT_2;
     3441    pThis->svga.u32RegCaps = SVGA_CAP_GMR | SVGA_CAP_GMR2 | SVGA_CAP_CURSOR | SVGA_CAP_CURSOR_BYPASS_2 | SVGA_CAP_EXTENDED_FIFO | SVGA_CAP_IRQMASK | SVGA_CAP_PITCHLOCK | SVGA_CAP_TRACES | SVGA_CAP_SCREEN_OBJECT_2 | SVGA_CAP_ALPHA_CURSOR;
    30843442#ifdef VBOX_WITH_VMSVGA3D
    30853443    pThis->svga.u32RegCaps |= SVGA_CAP_3D;
    … …  
    31053463
    31063464    /* Invalidate current settings. */
    3107     pThis->svga.iWidth     = -1;
    3108     pThis->svga.iHeight    = -1;
    3109     pThis->svga.iBpp       = -1;
     3465    pThis->svga.uWidth     = VMSVGA_VAL_UNINITIALIZED;
     3466    pThis->svga.uHeight    = VMSVGA_VAL_UNINITIALIZED;
     3467    pThis->svga.uBpp       = VMSVGA_VAL_UNINITIALIZED;
    31103468    pThis->svga.cbScanline = 0;
    31113469
    … …  
    31513509    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
    31523510    int       rc;
     3511
    31533512#ifdef VBOX_WITH_VMSVGA3D
    31543513    if (pThis->svga.f3DEnabled)

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

    r49985 r53201  
    1313 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1414 */
    15 
    1615#ifndef __DEVVGA_SVGA_H__
    1716#define __DEVVGA_SVGA_H__
    … …  
    2524#define VMSVGA_SURFACE_SIZE             (512*1024*1024)
    2625/** Maximum GMR pages. */
    27 #define VMSVGA_MAX_GMR_PAGES            0x2000
     26#define VMSVGA_MAX_GMR_PAGES            0x100000
    2827/** Maximum nr of GMR ids. */
    2928#define VMSVGA_MAX_GMR_IDS              0x100
    3029/** Size of the region to backup when switching into svga mode. */
    3130#define VMSVGA_FRAMEBUFFER_BACKUP_SIZE  (32*1024)
     31
     32#define VMSVGA_VAL_UNINITIALIZED        (unsigned)-1
    3233
    3334/* u32ActionFlags */
    … …  
    3738DECLCALLBACK(int) vmsvgaR3IORegionMap(PPCIDEVICE pPciDev, int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType);
    3839
     40DECLCALLBACK(void) vmsvgaPortSetViewPort(PPDMIDISPLAYPORT pInterface, uint32_t uScreenId, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy);
     41
    3942int vmsvgaInit(PPDMDEVINS pDevIns);
     43int vmsvgaReset(PPDMDEVINS pDevIns);
    4044int vmsvgaDestruct(PPDMDEVINS pDevIns);
    4145int vmsvgaLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
     46int vmsvgaLoadDone(PPDMDEVINS pDevIns);
    4247int vmsvgaSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM);
    4348DECLCALLBACK(void) vmsvgaR3PowerOn(PPDMDEVINS pDevIns);
     49DECLCALLBACK(void) vmsvgaR3PowerOff(PPDMDEVINS pDevIns);
    4450
    4551#endif  /* __DEVVGA_SVGA_H__ */
    46 

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

    r52885 r53201  
    21012101    /* @todo might crash if a blit follows a resolution change very quickly (seen this many times!) */
    21022102
    2103     if (    s->svga.iWidth == -1
    2104         ||  s->svga.iHeight == -1
    2105         ||  s->svga.iBpp == UINT32_MAX)
     2103    if (    s->svga.uWidth  == VMSVGA_VAL_UNINITIALIZED
     2104        ||  s->svga.uHeight == VMSVGA_VAL_UNINITIALIZED
     2105        ||  s->svga.uBpp    == VMSVGA_VAL_UNINITIALIZED)
    21062106    {
    21072107        /* Intermediate state; skip redraws. */
    … …  
    21102110    }
    21112111
    2112     switch(s->svga.iBpp) {
     2112    switch(s->svga.uBpp) {
    21132113    default:
    21142114    case 0:
    … …  
    21662166    vga_draw_line_func *vga_draw_line;
    21672167
    2168     if (    pThis->svga.iWidth == -1
    2169         ||  pThis->svga.iHeight == -1
    2170         ||  pThis->svga.iBpp == UINT32_MAX)
     2168    if (    pThis->svga.uWidth  == VMSVGA_VAL_UNINITIALIZED
     2169        ||  pThis->svga.uHeight == VMSVGA_VAL_UNINITIALIZED
     2170        ||  pThis->svga.uBpp    == VMSVGA_VAL_UNINITIALIZED)
    21712171    {
    21722172        /* Intermediate state; skip redraws. */
    … …  
    21742174    }
    21752175
    2176     width  = pThis->svga.iWidth;
    2177     height = pThis->svga.iHeight;
     2176    width  = pThis->svga.uWidth;
     2177    height = pThis->svga.uHeight;
    21782178
    21792179    disp_width = width;
    21802180
    2181     switch(pThis->svga.iBpp) {
     2181    switch(pThis->svga.uBpp) {
    21822182    default:
    21832183    case 0:
    … …  
    53295329    PPDMDEVINS  pDevIns = pPciDev->pDevIns;
    53305330    PVGASTATE   pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
    5331     LogFlow(("vgaR3IORegionMap: iRegion=%d GCPhysAddress=%RGp cb=%#x enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
     5331    Log(("vgaR3IORegionMap: iRegion=%d GCPhysAddress=%RGp cb=%#x enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
    53325332#ifdef VBOX_WITH_VMSVGA
    53335333    AssertReturn((iRegion == ((pThis->fVMSVGAEnabled) ? 1 : 0)) && (enmType == ((pThis->fVMSVGAEnabled) ? PCI_ADDRESS_SPACE_MEM : PCI_ADDRESS_SPACE_MEM_PREFETCH)), VERR_INTERNAL_ERROR);
    … …  
    53715371        Assert(pThis->GCPhysVRAM);
    53725372#ifdef VBOX_WITH_VMSVGA
    5373         Assert(!pThis->svga.fEnabled);
     5373        Assert(!pThis->svga.fEnabled || !pThis->svga.fVRAMTracking);
     5374        if (    !pThis->svga.fEnabled
     5375            ||  (   pThis->svga.fEnabled
     5376                 && pThis->svga.fVRAMTracking
     5377                )
     5378           )
     5379        {
    53745380#endif
    53755381        rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns), pThis->GCPhysVRAM);
    53765382        AssertRC(rc);
     5383#ifdef VBOX_WITH_VMSVGA
     5384        }
     5385        else
     5386            rc = VINF_SUCCESS;
     5387#endif
    53775388        pThis->GCPhysVRAM = 0;
    53785389        /* NB: VBE_DISPI_INDEX_FB_BASE_HI is left unchanged here. */
    … …  
    55475558
    55485559#ifdef VBOX_WITH_VMSVGA
    5549         if (    uVersion >= VGA_SAVEDSTATE_VERSION_VMSVGA_2D
    5550             &&  pThis->fVMSVGAEnabled)
     5560        if (pThis->fVMSVGAEnabled)
    55515561        {
    55525562            rc = vmsvgaLoadExec(pDevIns, pSSM, uVersion, uPass);
    … …  
    55645574static DECLCALLBACK(int) vgaR3LoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    55655575{
     5576    int rc = VINF_SUCCESS;
     5577
    55665578#ifdef VBOX_WITH_HGSMI
    55675579    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
    55685580    VBVAPause(pThis, (pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) == 0);
    5569     int rc = vboxVBVALoadStateDone(pDevIns, pSSM);
     5581    rc = vboxVBVALoadStateDone(pDevIns, pSSM);
    55705582    AssertRCReturn(rc, rc);
    55715583# ifdef VBOX_WITH_VDMA
    … …  
    55735585    AssertRCReturn(rc, rc);
    55745586# endif
    5575     return VINF_SUCCESS;
    5576 #else
    5577     return VINF_SUCCESS;
    5578 #endif
     5587#endif
     5588#ifdef VBOX_WITH_VMSVGA
     5589    rc = vmsvgaLoadDone(pDevIns);
     5590#endif
     5591    return rc;
    55795592}
    55805593
    … …  
    55945607    if (pThis->pVdma)
    55955608        vboxVDMAReset(pThis->pVdma);
     5609
     5610#ifdef VBOX_WITH_VMSVGA
     5611    if (pThis->fVMSVGAEnabled)
     5612        vmsvgaReset(pDevIns);
     5613#endif
    55965614
    55975615#ifdef VBOX_WITH_HGSMI
    … …  
    60356053    pThis->IPort.pfnCopyRect            = vgaPortCopyRect;
    60366054    pThis->IPort.pfnSetRenderVRAM       = vgaPortSetRenderVRAM;
     6055#ifdef VBOX_WITH_VMSVGA
     6056    pThis->IPort.pfnSetViewPort         = vmsvgaPortSetViewPort;
     6057#endif
    60376058
    60386059#if defined(VBOX_WITH_HGSMI)

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

    r52504 r53201  
    212212#endif
    213213
     214#ifdef VBOX_WITH_VMSVGA
     215
     216#define VMSVGA_FIFO_EXTCMD_NONE                 0
     217#define VMSVGA_FIFO_EXTCMD_TERMINATE            1
     218#define VMSVGA_FIFO_EXTCMD_SAVESTATE            2
     219#define VMSVGA_FIFO_EXTCMD_LOADSTATE            3
     220#define VMSVGA_FIFO_EXTCMD_RESET                4
     221
     222typedef struct
     223{
     224    PSSMHANDLE      pSSM;
     225    uint32_t        uVersion;
     226    uint32_t        uPass;
     227} VMSVGA_STATE_LOAD, *PVMSVGA_STATE_LOAD;
     228
     229typedef struct
     230{
     231    /** The host window handle */
     232    uint64_t                    u64HostWindowId;
     233    /** The R3 FIFO pointer. */
     234    R3PTRTYPE(uint32_t *)       pFIFOR3;
     235    /** The R0 FIFO pointer. */
     236    R0PTRTYPE(uint32_t *)       pFIFOR0;
     237    /** R3 Opaque pointer to svga state. */
     238    R3PTRTYPE(void *)           pSVGAState;
     239    /** R3 Opaque pointer to 3d state. */
     240    R3PTRTYPE(void *)           p3dState;
     241    /** R3 Opaque pointer to a copy of the first 32k of the framebuffer before switching into svga mode. */
     242    R3PTRTYPE(void *)           pFrameBufferBackup;
     243    /** R3 Opaque pointer to an external fifo cmd parameter. */
     244    R3PTRTYPE(void *)           pFIFOExtCmdParam;
     245
     246    /** Guest physical address of the FIFO memory range. */
     247    RTGCPHYS                    GCPhysFIFO;
     248    /** Size in bytes of the FIFO memory range. */
     249    uint32_t                    cbFIFO;
     250    /** SVGA id. */
     251    uint32_t                    u32SVGAId;
     252    /** SVGA extensions enabled or not. */
     253    uint32_t                    fEnabled;
     254    /** SVGA memory area configured status. */
     255    uint32_t                    fConfigured;
     256    /** Device is busy handling FIFO requests. */
     257    uint32_t                    fBusy;
     258    /** Traces (dirty page detection) enabled or not. */
     259    uint32_t                    fTraces;
     260    /** Guest OS identifier. */
     261    uint32_t                    u32GuestId;
     262    /** Scratch region size. */
     263    uint32_t                    cScratchRegion;
     264    /** Scratch array. */
     265    uint32_t                    au32ScratchRegion[VMSVGA_SCRATCH_SIZE];
     266    /** Irq status. */
     267    uint32_t                    u32IrqStatus;
     268    /** Irq mask. */
     269    uint32_t                    u32IrqMask;
     270    /** Pitch lock. */
     271    uint32_t                    u32PitchLock;
     272    /** Current GMR id. (SVGA_REG_GMR_ID) */
     273    uint32_t                    u32CurrentGMRId;
     274    /** Register caps. */
     275    uint32_t                    u32RegCaps;
     276    uint32_t                    Padding2;
     277    /** Physical address of command mmio range. */
     278    RTIOPORT                    BasePort;
     279    /** Port io index register. */
     280    uint32_t                    u32IndexReg;
     281    /** FIFO request semaphore. */
     282    RTSEMEVENT                  FIFORequestSem;
     283    /** FIFO external command semaphore. */
     284    RTSEMEVENT                  FIFOExtCmdSem;
     285    /** FIFO IO Thread. */
     286    R3PTRTYPE(PPDMTHREAD)       pFIFOIOThread;
     287    uint32_t                    uWidth;
     288    uint32_t                    uHeight;
     289    uint32_t                    uBpp;
     290    uint32_t                    cbScanline;
     291    /** Maximum width supported. */
     292    uint32_t                    u32MaxWidth;
     293    /** Maximum height supported. */
     294    uint32_t                    u32MaxHeight;
     295    /** Viewport rectangle */
     296    struct
     297    {
     298        uint32_t                x;
     299        uint32_t                y;
     300        uint32_t                cx;
     301        uint32_t                cy;
     302    } viewport;
     303    /** Action flags */
     304    uint32_t                    u32ActionFlags;
     305    /** SVGA 3d extensions enabled or not. */
     306    bool                        f3DEnabled;
     307    /** VRAM page monitoring enabled or not. */
     308    bool                        fVRAMTracking;
     309    /** External command to be executed in the FIFO thread. */
     310    uint8_t                     u8FIFOExtCommand;
     311    bool                        Padding6[1];
     312} VMSVGAState;
     313#endif /* VBOX_WITH_VMSVGA */
     314
     315
    214316typedef struct VGAState {
    215317#ifndef VBOX
    … …  
    320422
    321423#ifdef VBOX_WITH_VMSVGA
    322     struct
    323     {
    324         /** The host window handle */
    325         uint64_t                    u64HostWindowId;
    326         /** The R3 FIFO pointer. */
    327         R3PTRTYPE(uint32_t *)       pFIFOR3;
    328         /** The R0 FIFO pointer. */
    329         R0PTRTYPE(uint32_t *)       pFIFOR0;
    330         /** R3 Opaque pointer to svga state. */
    331         R3PTRTYPE(void *)           pSVGAState;
    332         /** R3 Opaque pointer to 3d state. */
    333         R3PTRTYPE(void *)           p3dState;
    334         /** R3 Opaque pointer to a copy of the first 32k of the framebuffer before switching into svga mode. */
    335         R3PTRTYPE(void *)           pFrameBufferBackup;
    336 #if HC_ARCH_BITS == 32
    337         uint32_t                    Padding3;
    338 #endif
    339         /** Guest physical address of the FIFO memory range. */
    340         RTGCPHYS                    GCPhysFIFO;
    341         /** Size in bytes of the FIFO memory range. */
    342         uint32_t                    cbFIFO;
    343         /** SVGA id. */
    344         uint32_t                    u32SVGAId;
    345         /** SVGA extensions enabled or not. */
    346         uint32_t                    fEnabled;
    347         /** SVGA memory area configured status. */
    348         uint32_t                    fConfigured;
    349         /** Device is busy handling FIFO requests. */
    350         uint32_t                    fBusy;
    351         /** Traces (dirty page detection) enabled or not. */
    352         uint32_t                    fTraces;
    353         /** Guest OS identifier. */
    354         uint32_t                    u32GuestId;
    355         /** Scratch region size. */
    356         uint32_t                    cScratchRegion;
    357         /** Scratch array. */
    358         uint32_t                    au32ScratchRegion[VMSVGA_SCRATCH_SIZE];
    359         /** Irq status. */
    360         uint32_t                    u32IrqStatus;
    361         /** Irq mask. */
    362         uint32_t                    u32IrqMask;
    363         /** Pitch lock. */
    364         uint32_t                    u32PitchLock;
    365         /** Current GMR id. (SVGA_REG_GMR_ID) */
    366         uint32_t                    u32CurrentGMRId;
    367         /** Register caps. */
    368         uint32_t                    u32RegCaps;
    369         /** Physical address of command mmio range. */
    370         uint32_t                    Padding2;
    371         RTIOPORT                    BasePort;
    372         /** Port io index register. */
    373         uint32_t                    u32IndexReg;
    374         /** FIFO request semaphore. */
    375         RTSEMEVENT                  FIFORequestSem;
    376         /** FIFO IO Thread. */
    377         R3PTRTYPE(PPDMTHREAD)       pFIFOIOThread;
    378         int32_t                     iWidth;
    379         int32_t                     iHeight;
    380         uint32_t                    iBpp;
    381         uint32_t                    cbScanline;
    382         /** Maximum width supported. */
    383         uint32_t                    u32MaxWidth;
    384         /** Maximum height supported. */
    385         uint32_t                    u32MaxHeight;
    386         /** Action flags */
    387         uint32_t                    u32ActionFlags;
    388         /** SVGA 3d extensions enabled or not. */
    389         bool                        f3DEnabled;
    390         /** VRAM page monitoring enabled or not. */
    391         bool                        fVRAMTracking;
    392         bool                        Padding6[2];
    393     } svga;
     424    VMSVGAState                 svga;
    394425#endif
    395426

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

    r51631 r53201  
    2727#define VGA_SAVEDSTATE_VERSION_3D           13
    2828#define VGA_SAVEDSTATE_VERSION_HGSMIMA      12 /* HGSMI memory allocator. */
    29 #define VGA_SAVEDSTATE_VERSION_VMSVGA       11
    3029#define VGA_SAVEDSTATE_VERSION_VMSVGA_2D    10 /* <- internal build with 2d state only */
    3130#define VGA_SAVEDSTATE_VERSION_WITH_PENDVHWA 10

  • trunk/src/VBox/Devices/Makefile.kmk

    r53062 r53201  
    246246  else
    247247    VBoxDD_SOURCES += Graphics/DevVGA-SVGA3d-ogl.cpp
    248     VBoxDD_LIBS    += $(PATH_STAGE_BIN)/vmsvgashader$(VBOX_SUFF_DLL)
     248    VBoxDD_LIBS    += $(PATH_STAGE_BIN)/VBoxSVGA3D$(VBOX_SUFF_DLL)
    249249  endif
    250250  VBoxDD_LIBS.win      += d3d9.lib
    251251  VBoxDD_LIBS.linux    += GL X11
     252  VBoxDD_LDFLAGS.darwin += -framework OpenGL
    252253 endif
    253254
    … …  
    928929   VBoxDDGC_DEFS         += VBOX_WITH_VMSVGA
    929930   VBoxDDGC_SOURCES      += \
    930     Graphics/DevVGA-SVGA.cpp
     931        Graphics/DevVGA-SVGA.cpp
    931932  endif
    932933  ifdef VBOX_WITH_VMSVGA3D
    … …  
    10821083  VBoxDDR0_DEFS         += VBOX_WITH_VMSVGA
    10831084  VBoxDDR0_SOURCES      += \
    1084     Graphics/DevVGA-SVGA.cpp
     1085        Graphics/DevVGA-SVGA.cpp
    10851086 endif
    10861087 ifdef VBOX_WITH_VMSVGA3D
    … …  
    13451346endif # VBOX_WITH_EXTPACK_PUEL
    13461347
     1348
     1349TEMPLATE_VBoxSVGA3D         = VBoxSVGA3D
     1350TEMPLATE_VBoxSVGA3D_EXTENDS = VBOXR3
     1351TEMPLATE_VBoxSVGA3D_CFLAGS  = \
     1352        $(filter-out -pedantic -fno-common,$(TEMPLATE_VBOXR3_CFLAGS))
     1353TEMPLATE_VBoxSVGA3D_CXXFLAG = \
     1354        $(filter-out -pedantic -fno-common,$(TEMPLATE_VBOXR3_CXXFLAGS))
     1355TEMPLATE_VBoxSVGA3D_CFLAGS.darwin  = \
     1356        $(filter-out -fno-common,$(TEMPLATE_VBOXR3_CFLAGS.darwin))
     1357TEMPLATE_VBoxSVGA3D_LDFLAGS.darwin += \
     1358        -framework AppKit -framework OpenGL
     1359
     1360if defined(VBOX_WITH_VMSVGA3D)
     1361DLLS += VBoxSVGA3D
     1362endif
     1363
     1364VBoxSVGA3D_TEMPLATE = VBoxSVGA3D
     1365VBoxSVGA3D_SDKS         = ReorderCompilerIncs
     1366VBoxSVGA3D_DEFS         = \
     1367        __WINESRC__ \
     1368        WINE_UNICODE_API="" \
     1369        _REENTRANT \
     1370        WINE_NOWINSOCK \
     1371        IN_RING3 \
     1372        VBOX_WITH_VMSVGA \
     1373        VBOX_WITH_VMSVGA3D \
     1374        DLLDIR=\"\" \
     1375        BINDIR=\"\" \
     1376        LIB_TO_BINDIR=\"\" \
     1377        LIB_TO_DLLDIR=\"\" \
     1378        BIN_TO_DLLDIR=\"\" \
     1379        LIB_TO_DATADIR=\"\" \
     1380        BIN_TO_DATADIR=\"\" \
     1381        _USE_MATH_DEFINES \
     1382        VBOX_USING_WINDDK_W7_OR_LATER \
     1383        VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT \
     1384        IN_vmsvgashader_STATIC \
     1385        VBOX_WINE_WITH_IPRT
     1386if "$(KBUILD_TYPE)" != "debug" || defined(VBOX_WINE_NO_DEBUG_MSGS)
     1387 VBoxSVGA3D_DEFS       += WINE_NO_DEBUG_MSGS
     1388endif
     1389VBoxSVGA3D_DEFS.x86    += __i386__
     1390VBoxSVGA3D_DEFS.amd64  += __x86_64__
     1391VBoxSVGA3D_DEFS.win    += USE_WIN32_OPENGL
     1392# WINE relies on a gcc 4.4 feature but we have 4.2 on Darwin
     1393VBoxSVGA3D_DEFS.darwin += \
     1394        __builtin_ms_va_list=va_list \
     1395        __stdcall=
     1396VBoxSVGA3D_CFLAGS = \
     1397    $(filter-out -pedantic -Wattributes,$(VBoxR3DllWarnNoPic_CFLAGS))
     1398VBoxSVGA3D_INCS.win    += \
     1399        VBOX_WINE_WITHOUT_LIBWINE
     1400VBoxSVGA3D_INCS.win    := \
     1401        Graphics/shaderlib/libWineStub/include
     1402VBoxSVGA3D_INCS.linux  := \
     1403        Graphics/shaderlib/wine/include
     1404VBoxSVGA3D_INCS.darwin := \
     1405        Graphics/shaderlib/wine/include
     1406VBoxSVGA3D_SOURCES     := \
     1407        Graphics/shaderlib/glsl_shader.c \
     1408        Graphics/shaderlib/shader.c \
     1409        Graphics/shaderlib/shader_sm1.c \
     1410        Graphics/shaderlib/shader_sm4.c \
     1411        Graphics/shaderlib/shaderapi.c \
     1412        Graphics/shaderlib/utils.c \
     1413        Graphics/shaderlib/stateblock.c \
     1414        Graphics/shaderlib/directx.c \
     1415        Graphics/shaderlib/libWineStub/debug.c
     1416VBoxSVGA3D_SOURCES.darwin  += \
     1417        Graphics/DevVGA-SVGA3d-cocoa.m
     1418VBoxSVGA3D_LIBS        = \
     1419        $(LIB_RUNTIME)
     1420VBoxSVGA3D_LIBS.win       += $(PATH_SDK_$(VBOX_WINPSDK)_LIB)/Opengl32.lib
     1421if1of ($(KBUILD_TARGET), solaris linux freebsd)
     1422 VBoxSVGA3D_LIBS += GL
     1423endif
     1424VBoxSVGA3D_LDFLAGS.darwin += \
     1425        -install_name $(VBOX_DYLD_EXECUTABLE_PATH)/VBoxSVGA3D.dylib
     1426
    13471427include $(FILE_KBUILD_SUB_FOOTER)
    13481428

  • trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp

    r52817 r53201  
    339339    GEN_CHECK_OFF(VGASTATE, svga.BasePort);
    340340    GEN_CHECK_OFF(VGASTATE, svga.pFIFOIOThread);
    341     GEN_CHECK_OFF(VGASTATE, svga.iWidth);
     341    GEN_CHECK_OFF(VGASTATE, svga.uWidth);
    342342    GEN_CHECK_OFF(VGASTATE, svga.u32ActionFlags);
    343343    GEN_CHECK_OFF(VGASTATE, svga.f3DEnabled);

  • trunk/src/VBox/Main/src-client/DisplayImpl.cpp

    r53053 r53201  
    25602560    }
    25612561#endif /* VBOX_WITH_CROGL && VBOX_WITH_HGCM */
     2562
     2563#ifdef VBOX_WITH_VMSVGA
     2564    /* The driver might not have been constructed yet */
     2565    if (mpDrv)
     2566    {
     2567        mpDrv->pUpPort->pfnSetViewPort(mpDrv->pUpPort, aScreenId, aX, aY, aWidth, aHeight);
     2568    }
     2569#endif
     2570
    25622571    return S_OK;
    25632572}
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