VirtualBox

Changeset 65294 in vbox


Ignore:
Timestamp:
Jan 14, 2017 5:15:41 PM (8 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
112864
Message:

VMSVGA: Updates.

  • Moved VMSVGA specific structures and defines from DevVGA.h to DevVGA-SVGA.h.
  • Corrected SVGA_REG_PSUDOCOLOR value for 8-bit mode.
  • Increased the VGA framebuffer backup from 32KB to 512KB (same as VGA_MAPPING_SIZE).
  • Increased the VGA saved state version to deal with this.
  • Don't allow the VGA MMIO access to anything but the backup FB in SVGA mode.
  • Don't assert in the 3d code on mode switch when the 3d support is disabled.
  • Let the SVGA_PALETTE_BASE registers accesses go to last_palette.
  • Implemented SVGA_CMD_DEFINE_CURSOR. (Just wanted to fix FIFO messup caused by the incomplete stub code, but did a more complete implementation just for fun.)
  • A coupld of cleanups.
Location:
trunk/src/VBox/Devices
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r65271 r65294  
    362362    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pSvgaR3State),
    363363    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, p3dState),
    364     SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pFrameBufferBackup),
     364    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pbVgaFrameBufferR3),
    365365    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pvFIFOExtCmdParam),
    366366    SSMFIELD_ENTRY_IGN_GCPHYS(      VMSVGAState, GCPhysFIFO),
    … …  
    834834    case SVGA_REG_PSEUDOCOLOR:
    835835        STAM_REL_COUNTER_INC(&pThis->svga.StatRegPsuedoColorRd);
    836         *pu32 = 0;
     836        *pu32 = pThis->svga.uBpp == 8; /* See section 6 "Pseudocolor" in svga_interface.txt. */
    837837        break;
    838838
    … …  
    11751175        else if ((offReg = idxReg - SVGA_PALETTE_BASE) < (uint32_t)SVGA_NUM_PALETTE_REGS)
    11761176        {
     1177            /* Note! Using last_palette rather than palette here to preserve the VGA one. */
    11771178            STAM_REL_COUNTER_INC(&pThis->svga.StatRegPaletteRd);
    1178             /* Next 768 (== 256*3) registers exist for colormap */
     1179            *pu32 = pThis->last_palette[offReg];
    11791180        }
    11801181        else
    … …  
    13181319    case SVGA_REG_ID:
    13191320        STAM_REL_COUNTER_INC(&pThis->svga.StatRegIdWr);
    1320         if (    u32 == SVGA_ID_0
    1321             ||  u32 == SVGA_ID_1
    1322             ||  u32 == SVGA_ID_2)
     1321        if (   u32 == SVGA_ID_0
     1322            || u32 == SVGA_ID_1
     1323            || u32 == SVGA_ID_2)
    13231324            pThis->svga.u32SVGAId = u32;
    13241325        else
    1325             AssertMsgFailed(("%#x\n", u32));
     1326            PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS, "Trying to set SVGA_REG_ID to %#x (%d)\n", u32, u32);
    13261327        break;
    13271328
    … …  
    13421343            &&  pThis->svga.fEnabled == false)
    13431344        {
    1344             /* Make a backup copy of the first 32k in order to save font data etc. */
    1345             memcpy(pThis->svga.pFrameBufferBackup, pThis->vram_ptrR3, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
     1345            /* Make a backup copy of the first 512kb in order to save font data etc. */
     1346            /** @todo should probably swap here, rather than copy + zero */
     1347            memcpy(pThis->svga.pbVgaFrameBufferR3, pThis->vram_ptrR3, VMSVGA_VGA_FB_BACKUP_SIZE);
     1348            memset(pThis->vram_ptrR3, 0, VMSVGA_VGA_FB_BACKUP_SIZE);
    13461349        }
    13471350
    … …  
    13781381        {
    13791382            /* Restore the text mode backup. */
    1380             memcpy(pThis->vram_ptrR3, pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
     1383            memcpy(pThis->vram_ptrR3, pThis->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
    13811384
    13821385/*            pThis->svga.uHeight    = -1;
    … …  
    13891392            vmsvgaSetTraces(pThis, true);
    13901393        }
    1391 #else
     1394#else  /* !IN_RING3 */
    13921395        rc = VINF_IOM_R3_IOPORT_WRITE;
    1393 #endif
     1396#endif /* !IN_RING3 */
    13941397        break;
    13951398
    … …  
    17101713        else if ((offReg = idxReg - SVGA_PALETTE_BASE) < (uint32_t)SVGA_NUM_PALETTE_REGS)
    17111714        {
     1715            /* Note! Using last_palette rather than palette here to preserve the VGA one. */
    17121716            STAM_REL_COUNTER_INC(&pThis->svga.StatRegPaletteWr);
    1713             /* Next 768 (== 256*3) registers exist for colormap */
     1717            pThis->last_palette[offReg] = (uint8_t)u32;
    17141718        }
    17151719        else
    … …  
    23192323
    23202324#ifdef IN_RING3
     2325
     2326
     2327/**
     2328 * Common worker for changing the pointer shape.
     2329 *
     2330 * @param   pThis               The VGA instance data.
     2331 * @param   pSVGAState          The VMSVGA ring-3 instance data.
     2332 * @param   fAlpha              Whether there is alpha or not.
     2333 * @param   xHot                Hotspot x coordinate.
     2334 * @param   yHot                Hotspot y coordinate.
     2335 * @param   cx                  Width.
     2336 * @param   cy                  Height.
     2337 * @param   pbData              Heap copy of the cursor data.  Consumed.
     2338 * @param   cbData              The size of the data.
     2339 */
     2340static void vmsvgaR3InstallNewCursor(PVGASTATE pThis, PVMSVGAR3STATE pSVGAState, bool fAlpha,
     2341                                     uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy, uint8_t *pbData, uint32_t cbData)
     2342{
     2343    Log(("vmsvgaR3InstallNewCursor: cx=%d cy=%d xHot=%d yHot=%d fAlpha=%d cbData=%#x\n", cx, cy, xHot, yHot, fAlpha, cbData));
     2344    if (LogIs2Enabled())
     2345    {
     2346        uint32_t cbAndLine = RT_ALIGN(cx, 8) / 8;
     2347        if (!fAlpha)
     2348        {
     2349            Log2(("VMSVGA Cursor AND mask (%d,%d):\n", cx, cy));
     2350            for (uint32_t y = 0; y < cy; y++)
     2351            {
     2352                Log2(("%3u:", y));
     2353                uint8_t const *pbLine = &pbData[y * cbAndLine];
     2354                for (uint32_t x = 0; x < cx; x += 8)
     2355                {
     2356                    uint8_t   b = pbLine[x / 8];
     2357                    char      szByte[12];
     2358                    szByte[0] = b & 0x80 ? '*' : ' '; /* most significant bit first */
     2359                    szByte[1] = b & 0x40 ? '*' : ' ';
     2360                    szByte[2] = b & 0x20 ? '*' : ' ';
     2361                    szByte[3] = b & 0x10 ? '*' : ' ';
     2362                    szByte[4] = b & 0x08 ? '*' : ' ';
     2363                    szByte[5] = b & 0x04 ? '*' : ' ';
     2364                    szByte[6] = b & 0x02 ? '*' : ' ';
     2365                    szByte[7] = b & 0x01 ? '*' : ' ';
     2366                    szByte[8] = '\0';
     2367                    Log2(("%s", szByte));
     2368                }
     2369                Log2(("\n"));
     2370            }
     2371        }
     2372
     2373        Log2(("VMSVGA Cursor XOR mask (%d,%d):\n", cx, cy));
     2374        uint32_t const *pu32Xor = (uint32_t const *)&pbData[RT_ALIGN_32(cbAndLine * cy, 4)];
     2375        for (uint32_t y = 0; y < cy; y++)
     2376        {
     2377            Log2(("%3u:", y));
     2378            uint32_t const *pu32Line = &pu32Xor[y * cx];
     2379            for (uint32_t x = 0; x < cx; x++)
     2380                Log2((" %08x", pu32Line[x]));
     2381            Log2(("\n"));
     2382        }
     2383    }
     2384
     2385    int rc = pThis->pDrv->pfnVBVAMousePointerShape(pThis->pDrv, true /*fVisible*/, fAlpha, xHot, yHot, cx, cy, pbData);
     2386    AssertRC(rc);
     2387
     2388    if (pSVGAState->Cursor.fActive)
     2389        RTMemFree(pSVGAState->Cursor.pData);
     2390
     2391    pSVGAState->Cursor.fActive  = true;
     2392    pSVGAState->Cursor.xHotspot = xHot;
     2393    pSVGAState->Cursor.yHotspot = yHot;
     2394    pSVGAState->Cursor.width    = cx;
     2395    pSVGAState->Cursor.height   = cy;
     2396    pSVGAState->Cursor.cbData   = cbData;
     2397    pSVGAState->Cursor.pData    = pbData;
     2398}
     2399
     2400
     2401/**
     2402 * Handles the SVGA_CMD_DEFINE_CURSOR command.
     2403 *
     2404 * @param   pThis               The VGA instance data.
     2405 * @param   pSVGAState          The VMSVGA ring-3 instance data.
     2406 * @param   pCursor             The cursor.
     2407 * @param   pbSrcAndMask        The AND mask.
     2408 * @param   cbSrcAndLine        The scanline length of the AND mask.
     2409 * @param   pbSrcXorMask        The XOR mask.
     2410 * @param   cbSrcXorLine        The scanline length of the XOR mask.
     2411 */
     2412static void vmsvgaR3CmdDefineCursor(PVGASTATE pThis, PVMSVGAR3STATE pSVGAState, SVGAFifoCmdDefineCursor const *pCursor,
     2413                                    uint8_t const *pbSrcAndMask, uint32_t cbSrcAndLine,
     2414                                    uint8_t const *pbSrcXorMask, uint32_t cbSrcXorLine)
     2415{
     2416    uint32_t const cx = pCursor->width;
     2417    uint32_t const cy = pCursor->height;
     2418
     2419    /*
     2420     * Convert the input to 1-bit AND mask and a 32-bit BRGA XOR mask.
     2421     * The AND data uses 8-bit aligned scanlines.
     2422     * The XOR data must be starting on a 32-bit boundrary.
     2423     */
     2424    uint32_t cbDstAndLine = RT_ALIGN_32(cx, 8) / 8;
     2425    uint32_t cbDstAndMask = cbDstAndLine          * cy;
     2426    uint32_t cbDstXorMask = cx * sizeof(uint32_t) * cy;
     2427    uint32_t cbCopy = RT_ALIGN_32(cbDstAndMask, 4) + cbDstXorMask;
     2428
     2429    uint8_t *pbCopy = (uint8_t *)RTMemAlloc(cbCopy);
     2430    AssertReturnVoid(pbCopy);
     2431
     2432    /* Convert the AND mask. */
     2433    uint8_t       *pbDst     = pbCopy;
     2434    uint8_t const *pbSrc     = pbSrcAndMask;
     2435    switch (pCursor->andMaskDepth)
     2436    {
     2437        case 1:
     2438            if (cbSrcAndLine == cbDstAndLine)
     2439                memcpy(pbDst, pbSrc, cbSrcAndLine * cy);
     2440            else
     2441            {
     2442                Assert(cbSrcAndLine > cbDstAndLine); /* lines are dword alined in source, but only byte in destination. */
     2443                for (uint32_t y = 0; y < cy; y++)
     2444                {
     2445                    memcpy(pbDst, pbSrc, cbDstAndLine);
     2446                    pbDst += cbDstAndLine;
     2447                    pbSrc += cbSrcAndLine;
     2448                }
     2449            }
     2450            break;
     2451        case 8:
     2452            for (uint32_t y = 0; y < cy; y++)
     2453            {
     2454                for (uint32_t x = 0; x < cx; )
     2455                {
     2456                    uint8_t bDst = 0;
     2457                    uint8_t fBit = 1;
     2458                    do
     2459                    {
     2460                        if (pbSrc[x])
     2461                            bDst |= fBit;
     2462                        fBit <<= 1;
     2463                        x++;
     2464                    } while (x < cx && (x & 7));
     2465                    pbDst[(x - 1) / 8] = bDst;
     2466                }
     2467                pbDst += cbDstAndLine;
     2468                pbSrc += cbSrcAndLine;
     2469            }
     2470            break;
     2471        case 15:
     2472            for (uint32_t y = 0; y < cy; y++)
     2473            {
     2474                for (uint32_t x = 0; x < cx; )
     2475                {
     2476                    uint8_t bDst = 0;
     2477                    uint8_t fBit = 1;
     2478                    do
     2479                    {
     2480                        if (pbSrc[x * 2] || (pbSrc[x * 2 + 1] & 0x7f))
     2481                            bDst |= fBit;
     2482                        fBit <<= 1;
     2483                        x++;
     2484                    } while (x < cx && (x & 7));
     2485                    pbDst[(x - 1) / 8] = bDst;
     2486                }
     2487                pbDst += cbDstAndLine;
     2488                pbSrc += cbSrcAndLine;
     2489            }
     2490            break;
     2491        case 16:
     2492            for (uint32_t y = 0; y < cy; y++)
     2493            {
     2494                for (uint32_t x = 0; x < cx; )
     2495                {
     2496                    uint8_t bDst = 0;
     2497                    uint8_t fBit = 1;
     2498                    do
     2499                    {
     2500                        if (pbSrc[x * 2] || pbSrc[x * 2 + 1])
     2501                            bDst |= fBit;
     2502                        fBit <<= 1;
     2503                        x++;
     2504                    } while (x < cx && (x & 7));
     2505                    pbDst[(x - 1) / 8] = bDst;
     2506                }
     2507                pbDst += cbDstAndLine;
     2508                pbSrc += cbSrcAndLine;
     2509            }
     2510            break;
     2511        case 24:
     2512            for (uint32_t y = 0; y < cy; y++)
     2513            {
     2514                for (uint32_t x = 0; x < cx; )
     2515                {
     2516                    uint8_t bDst = 0;
     2517                    uint8_t fBit = 1;
     2518                    do
     2519                    {
     2520                        if (pbSrc[x * 3] || pbSrc[x * 3 + 1] || pbSrc[x * 3 + 2])
     2521                            bDst |= fBit;
     2522                        fBit <<= 1;
     2523                        x++;
     2524                    } while (x < cx && (x & 7));
     2525                    pbDst[(x - 1) / 8] = bDst;
     2526                }
     2527                pbDst += cbDstAndLine;
     2528                pbSrc += cbSrcAndLine;
     2529            }
     2530        case 32:
     2531            for (uint32_t y = 0; y < cy; y++)
     2532            {
     2533                for (uint32_t x = 0; x < cx; )
     2534                {
     2535                    uint8_t bDst = 0;
     2536                    uint8_t fBit = 1;
     2537                    do
     2538                    {
     2539                        if (pbSrc[x * 4] || pbSrc[x * 4 + 1] || pbSrc[x * 4 + 2] || pbSrc[x * 4 + 3])
     2540                            bDst |= fBit;
     2541                        fBit <<= 1;
     2542                        x++;
     2543                    } while (x < cx && (x & 7));
     2544                    pbDst[(x - 1) / 8] = bDst;
     2545                }
     2546                pbDst += cbDstAndLine;
     2547                pbSrc += cbSrcAndLine;
     2548            }
     2549            break;
     2550        default:
     2551            RTMemFree(pbCopy);
     2552            AssertFailedReturnVoid();
     2553    }
     2554
     2555    /* Convert the XOR mask. */
     2556    uint32_t *pu32Dst = (uint32_t *)(pbCopy + cbDstAndMask);
     2557    pbSrc  = pbSrcXorMask;
     2558    switch (pCursor->xorMaskDepth)
     2559    {
     2560        case 1:
     2561            for (uint32_t y = 0; y < cy; y++)
     2562            {
     2563                for (uint32_t x = 0; x < cx; x++)
     2564                    *pu32Dst++ = ASMBitTest(pbSrc, x) ? UINT32_C(0x00ffffff) : 0;
     2565                pbSrc += cbSrcXorLine;
     2566            }
     2567            break;
     2568        case 8:
     2569            for (uint32_t y = 0; y < cy; y++)
     2570            {
     2571                for (uint32_t x = 0; x < cx; x++)
     2572                {
     2573                    uintptr_t const idxPal = pbSrc[x] * 3;
     2574                    *pu32Dst++ = RT_MAKE_U32_FROM_U8(pThis->last_palette[idxPal + 2],
     2575                                                     pThis->last_palette[idxPal + 1],
     2576                                                     pThis->last_palette[idxPal + 0], 0);
     2577                }
     2578                pbSrc += cbSrcXorLine;
     2579            }
     2580            break;
     2581        case 15: /* Src: RGB-5-5-5 */
     2582            for (uint32_t y = 0; y < cy; y++)
     2583            {
     2584                for (uint32_t x = 0; x < cx; x++)
     2585                {
     2586                    uint32_t const uValue = RT_MAKE_U16(pbSrc[x * 2], pbSrc[x * 2 + 1]);
     2587                    *pu32Dst++ = RT_MAKE_U32_FROM_U8(( uValue        & 0x1f) << 3,
     2588                                                     ((uValue >>  5) & 0x1f) << 3,
     2589                                                     ((uValue >> 10) & 0x1f) << 3, 0);
     2590                }
     2591                pbSrc += cbSrcXorLine;
     2592            }
     2593            break;
     2594        case 16: /* Src: RGB-5-6-5 */
     2595            for (uint32_t y = 0; y < cy; y++)
     2596            {
     2597                for (uint32_t x = 0; x < cx; x++)
     2598                {
     2599                    uint32_t const uValue = RT_MAKE_U16(pbSrc[x * 2], pbSrc[x * 2 + 1]);
     2600                    *pu32Dst++ = RT_MAKE_U32_FROM_U8(( uValue        & 0x1f) << 3,
     2601                                                     ((uValue >>  5) & 0x3f) << 2,
     2602                                                     ((uValue >> 11) & 0x1f) << 3, 0);
     2603                }
     2604                pbSrc += cbSrcXorLine;
     2605            }
     2606            break;
     2607        case 24:
     2608            for (uint32_t y = 0; y < cy; y++)
     2609            {
     2610                for (uint32_t x = 0; x < cx; x++)
     2611                    *pu32Dst++ = RT_MAKE_U32_FROM_U8(pbSrc[x*3], pbSrc[x*3 + 1], pbSrc[x*3 + 2], 0);
     2612                pbSrc += cbSrcXorLine;
     2613            }
     2614        case 32:
     2615            for (uint32_t y = 0; y < cy; y++)
     2616            {
     2617                for (uint32_t x = 0; x < cx; x++)
     2618                    *pu32Dst++ = RT_MAKE_U32_FROM_U8(pbSrc[x*4], pbSrc[x*4 + 1], pbSrc[x*4 + 2], 0);
     2619                pbSrc += cbSrcXorLine;
     2620            }
     2621            break;
     2622        default:
     2623            RTMemFree(pbCopy);
     2624            AssertFailedReturnVoid();
     2625    }
     2626
     2627    /*
     2628     * Pass it to the frontend/whatever.
     2629     */
     2630    vmsvgaR3InstallNewCursor(pThis, pSVGAState, false /*fAlpha*/, pCursor->hotspotX, pCursor->hotspotY, cx, cy, pbCopy, cbCopy);
     2631}
     2632
    23212633
    23222634/**
    … …  
    28953207
    28963208            /* First check any pending actions. */
    2897             if (ASMBitTestAndClear(&pThis->svga.u32ActionFlags, VMSVGA_ACTION_CHANGEMODE_BIT))
     3209            if (   ASMBitTestAndClear(&pThis->svga.u32ActionFlags, VMSVGA_ACTION_CHANGEMODE_BIT)
     3210                && pThis->svga.p3dState != NULL)
    28983211# ifdef VBOX_WITH_VMSVGA3D
    28993212                vmsvga3dChangeMode(pThis);
    … …  
    29663279                VMSVGAFIFO_GET_CMD_BUFFER_BREAK(pCursor, SVGAFifoCmdDefineCursor, sizeof(*pCursor));
    29673280                STAM_REL_COUNTER_INC(&pSVGAState->StatR3CmdDefineCursor);
    2968                 AssertFailed(); /** @todo implement when necessary. */
     3281
     3282                Log(("vmsvgaFIFOLoop: CURSOR id=%d size (%d,%d) hotspot (%d,%d) andMaskDepth=%d xorMaskDepth=%d\n",
     3283                     pCursor->id, pCursor->width, pCursor->height, pCursor->hotspotX, pCursor->hotspotY,
     3284                     pCursor->andMaskDepth, pCursor->xorMaskDepth));
     3285                AssertBreak(pCursor->height < 2048 && pCursor->width < 2048);
     3286
     3287                uint32_t cbAndLine = RT_ALIGN_32(pCursor->width * (pCursor->andMaskDepth + (pCursor->andMaskDepth == 15)), 32) / 8;
     3288                uint32_t cbAndMask = cbAndLine * pCursor->height;
     3289                uint32_t cbXorLine = RT_ALIGN_32(pCursor->width * (pCursor->xorMaskDepth + (pCursor->xorMaskDepth == 15)), 32) / 8;
     3290                uint32_t cbXorMask = cbXorLine * pCursor->height;
     3291                VMSVGAFIFO_GET_MORE_CMD_BUFFER_BREAK(pCursor, SVGAFifoCmdDefineCursor, sizeof(*pCursor) + cbAndMask + cbXorMask);
     3292
     3293                vmsvgaR3CmdDefineCursor(pThis, pSVGAState, pCursor, (uint8_t const *)(pCursor + 1), cbAndLine,
     3294                                        (uint8_t const *)(pCursor + 1) + cbAndMask, cbXorLine);
    29693295                break;
    29703296            }
    … …  
    29993325                AssertBreak(pCursorCopy);
    30003326
    3001                 Log2(("Cursor data:\n%.*Rhxd\n", pCursor->width * pCursor->height * sizeof(uint32_t), pCursor+1));
    3002 
    30033327                /* Transparency is defined by the alpha bytes, so make the whole bitmap visible. */
    30043328                memset(pCursorCopy, 0xff, cbAndMask);
    … …  
    30063330                memcpy(pCursorCopy + cbAndMask, (pCursor + 1), pCursor->width * pCursor->height * sizeof(uint32_t));
    30073331
    3008                 rc = pThis->pDrv->pfnVBVAMousePointerShape (pThis->pDrv,
    3009                                                             true,
    3010                                                             true,
    3011                                                             pCursor->hotspotX,
    3012                                                             pCursor->hotspotY,
    3013                                                             pCursor->width,
    3014                                                             pCursor->height,
    3015                                                             pCursorCopy);
    3016                 AssertRC(rc);
    3017 
    3018                 if (pSVGAState->Cursor.fActive)
    3019                     RTMemFree(pSVGAState->Cursor.pData);
    3020 
    3021                 pSVGAState->Cursor.fActive  = true;
    3022                 pSVGAState->Cursor.xHotspot = pCursor->hotspotX;
    3023                 pSVGAState->Cursor.yHotspot = pCursor->hotspotY;
    3024                 pSVGAState->Cursor.width    = pCursor->width;
    3025                 pSVGAState->Cursor.height   = pCursor->height;
    3026                 pSVGAState->Cursor.cbData   = cbCursorShape;
    3027                 pSVGAState->Cursor.pData    = pCursorCopy;
     3332                vmsvgaR3InstallNewCursor(pThis, pSVGAState, true /*fAlpha*/, pCursor->hotspotX, pCursor->hotspotY,
     3333                                         pCursor->width, pCursor->height, pCursorCopy, cbCursorShape);
    30283334                break;
    30293335            }
    … …  
    43144620    AssertRCReturn(rc, rc);
    43154621
    4316     /* Load the framebuffer backup. */
    4317     rc = SSMR3GetMem(pSSM, pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
     4622    /* Load the VGA framebuffer. */
     4623    AssertCompile(VMSVGA_VGA_FB_BACKUP_SIZE >= _32K);
     4624    uint32_t cbVgaFramebuffer = _32K;
     4625    if (uVersion >= VGA_SAVEDSTATE_VERSION_VMSVGA_VGA_FB_FIX)
     4626    {
     4627        rc = SSMR3GetU32(pSSM, &cbVgaFramebuffer);
     4628        AssertRCReturn(rc, rc);
     4629        AssertLogRelMsgReturn(cbVgaFramebuffer <= _4M && cbVgaFramebuffer >= _32K && RT_IS_POWER_OF_TWO(cbVgaFramebuffer),
     4630                              ("cbVgaFramebuffer=%#x - expected 32KB..4MB, power of two\n", cbVgaFramebuffer),
     4631                              VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
     4632        AssertCompile(VMSVGA_VGA_FB_BACKUP_SIZE <= _4M);
     4633        AssertCompile(RT_IS_POWER_OF_TWO(VMSVGA_VGA_FB_BACKUP_SIZE));
     4634    }
     4635    rc = SSMR3GetMem(pSSM, pThis->svga.pbVgaFrameBufferR3, RT_MIN(cbVgaFramebuffer, VMSVGA_VGA_FB_BACKUP_SIZE));
    43184636    AssertRCReturn(rc, rc);
     4637    if (cbVgaFramebuffer > VMSVGA_VGA_FB_BACKUP_SIZE)
     4638        SSMR3Skip(pSSM, cbVgaFramebuffer - VMSVGA_VGA_FB_BACKUP_SIZE);
     4639    else if (cbVgaFramebuffer < VMSVGA_VGA_FB_BACKUP_SIZE)
     4640        RT_BZERO(&pThis->svga.pbVgaFrameBufferR3[cbVgaFramebuffer], VMSVGA_VGA_FB_BACKUP_SIZE - cbVgaFramebuffer);
    43194641
    43204642    /* Load the VMSVGA state. */
    … …  
    44164738
    44174739    /* Save the framebuffer backup. */
    4418     rc = SSMR3PutMem(pSSM, pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
     4740    rc = SSMR3PutU32(pSSM, VMSVGA_VGA_FB_BACKUP_SIZE);
     4741    rc = SSMR3PutMem(pSSM, pThis->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
    44194742    AssertLogRelRCReturn(rc, rc);
    44204743
    … …  
    44824805    RT_ZERO(pThis->svga.au32ScratchRegion);
    44834806    RT_ZERO(*pThis->svga.pSvgaR3State);
    4484     RT_BZERO(pThis->svga.pFrameBufferBackup, VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
     4807    RT_BZERO(pThis->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
    44854808
    44864809    /* Register caps. */
    … …  
    45594882     * Free our resources residing in the VGA state.
    45604883     */
    4561     if (pThis->svga.pFrameBufferBackup)
    4562         RTMemFree(pThis->svga.pFrameBufferBackup);
     4884    if (pThis->svga.pbVgaFrameBufferR3)
     4885    {
     4886        RTMemFree(pThis->svga.pbVgaFrameBufferR3);
     4887        pThis->svga.pbVgaFrameBufferR3 = NULL;
     4888    }
    45634889    if (pThis->svga.FIFOExtCmdSem != NIL_RTSEMEVENT)
    45644890    {
    … …  
    45964922
    45974923    /* Necessary for creating a backup of the text mode frame buffer when switching into svga mode. */
    4598     pThis->svga.pFrameBufferBackup = RTMemAllocZ(VMSVGA_FRAMEBUFFER_BACKUP_SIZE);
    4599     AssertReturn(pThis->svga.pFrameBufferBackup, VERR_NO_MEMORY);
     4924    pThis->svga.pbVgaFrameBufferR3 = (uint8_t *)RTMemAllocZ(VMSVGA_VGA_FB_BACKUP_SIZE);
     4925    AssertReturn(pThis->svga.pbVgaFrameBufferR3, VERR_NO_MEMORY);
    46004926
    46014927    /* Create event semaphore. */

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

    r65271 r65294  
    1818#define ___DevVGA_SVGA_h___
    1919
     20#ifndef VBOX_WITH_VMSVGA
     21# error "VBOX_WITH_VMSVGA is not defined"
     22#endif
     23
     24#include <VBox/vmm/pdmthread.h>
     25
    2026
    2127/** Default FIFO size. */
    … …  
    4551#define VMSVGA_ACTION_CHANGEMODE        RT_BIT(VMSVGA_ACTION_CHANGEMODE_BIT)
    4652
     53
     54#ifdef DEBUG
     55/* Enable to log FIFO register accesses. */
     56//# define DEBUG_FIFO_ACCESS
     57/* Enable to log GMR page accesses. */
     58//# define DEBUG_GMR_ACCESS
     59#endif
     60
     61#define VMSVGA_FIFO_EXTCMD_NONE                         0
     62#define VMSVGA_FIFO_EXTCMD_TERMINATE                    1
     63#define VMSVGA_FIFO_EXTCMD_SAVESTATE                    2
     64#define VMSVGA_FIFO_EXTCMD_LOADSTATE                    3
     65#define VMSVGA_FIFO_EXTCMD_RESET                        4
     66#define VMSVGA_FIFO_EXTCMD_UPDATE_SURFACE_HEAP_BUFFERS  5
     67
     68/** Size of the region to backup when switching into svga mode. */
     69#define VMSVGA_VGA_FB_BACKUP_SIZE                       _512K
     70
     71/** @def VMSVGA_WITH_BACKUP_VGA_FB
     72 * Enables correct VGA MMIO read/write handling when VMSVGA is enabled.  It
     73 * is SLOW and probably not entirely right, but it helps with getting 3dmark
     74 * output and other stuff. */
     75#define VMSVGA_WITH_VGA_FB_BACKUP                       1
     76
     77/** @def VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
     78 * defined(VMSVGA_WITH_VGA_FB_BACKUP) && defined(IN_RING3)  */
     79#if defined(VMSVGA_WITH_VGA_FB_BACKUP) && defined(IN_RING3)
     80# define VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3         1
     81#else
     82# undef  VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
     83#endif
     84
     85/** @def VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RZ
     86 * defined(VMSVGA_WITH_VGA_FB_BACKUP) && !defined(IN_RING3)  */
     87#if defined(VMSVGA_WITH_VGA_FB_BACKUP) && !defined(IN_RING3)
     88# define VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RZ            1
     89#else
     90# undef  VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RZ
     91#endif
     92
     93
     94typedef struct
     95{
     96    PSSMHANDLE      pSSM;
     97    uint32_t        uVersion;
     98    uint32_t        uPass;
     99} VMSVGA_STATE_LOAD;
     100typedef VMSVGA_STATE_LOAD *PVMSVGA_STATE_LOAD;
     101
     102/** Host screen viewport.
     103 * (4th quadrant with negated Y values - usual Windows and X11 world view.) */
     104typedef struct VMSVGAVIEWPORT
     105{
     106    uint32_t        x;                  /**< x coordinate (left). */
     107    uint32_t        y;                  /**< y coordinate (top). */
     108    uint32_t        cx;                 /**< width. */
     109    uint32_t        cy;                 /**< height. */
     110    /** Right side coordinate (exclusive). Same as x + cx. */
     111    uint32_t        xRight;
     112    /** First quadrant low y coordinate.
     113     * Same as y + cy - 1 in window coordinates. */
     114    uint32_t        yLowWC;
     115    /** First quadrant high y coordinate (exclusive) - yLowWC + cy.
     116     * Same as y - 1 in window coordinates. */
     117    uint32_t        yHighWC;
     118    /** Alignment padding. */
     119    uint32_t        uAlignment;
     120} VMSVGAVIEWPORT;
     121
     122/** Pointer to the private VMSVGA ring-3 state structure.
     123 * @todo Still not entirely satisfired with the type name, but better than
     124 *       the previous lower/upper case only distinction. */
     125typedef struct VMSVGAR3STATE *PVMSVGAR3STATE;
     126/** Pointer to the private (implementation specific) VMSVGA3d state. */
     127typedef struct VMSVGA3DSTATE *PVMSVGA3DSTATE;
     128
     129
     130/**
     131 * The VMSVGA device state.
     132 *
     133 * This instantatiated as VGASTATE::svga.
     134 */
     135typedef struct VMSVGAState
     136{
     137    /** The host window handle */
     138    uint64_t                    u64HostWindowId;
     139    /** The R3 FIFO pointer. */
     140    R3PTRTYPE(uint32_t *)       pFIFOR3;
     141    /** The R0 FIFO pointer. */
     142    R0PTRTYPE(uint32_t *)       pFIFOR0;
     143    /** R3 Opaque pointer to svga state. */
     144    R3PTRTYPE(PVMSVGAR3STATE)   pSvgaR3State;
     145    /** R3 Opaque pointer to 3d state. */
     146    R3PTRTYPE(PVMSVGA3DSTATE)   p3dState;
     147    /** The separate VGA frame buffer in svga mode.
     148     * Unlike the the boch-based VGA device implementation, VMSVGA seems to have a
     149     * separate frame buffer for VGA and allows concurrent use of both.  The SVGA
     150     * SDK is making use of this to do VGA text output while testing other things in
     151     * SVGA mode, displaying the result by switching back to VGA text mode.  So,
     152     * when entering SVGA mode we copy the first part of the frame buffer here and
     153     * direct VGA accesses here instead.  It is copied back when leaving SVGA mode. */
     154    R3PTRTYPE(uint8_t *)        pbVgaFrameBufferR3;
     155    /** R3 Opaque pointer to an external fifo cmd parameter. */
     156    R3PTRTYPE(void * volatile)  pvFIFOExtCmdParam;
     157
     158    /** Guest physical address of the FIFO memory range. */
     159    RTGCPHYS                    GCPhysFIFO;
     160    /** Size in bytes of the FIFO memory range. */
     161    uint32_t                    cbFIFO;
     162    /** SVGA id. */
     163    uint32_t                    u32SVGAId;
     164    /** SVGA extensions enabled or not. */
     165    uint32_t                    fEnabled;
     166    /** SVGA memory area configured status. */
     167    uint32_t                    fConfigured;
     168    /** Device is busy handling FIFO requests (VMSVGA_BUSY_F_FIFO,
     169     *  VMSVGA_BUSY_F_EMT_FORCE). */
     170    uint32_t volatile           fBusy;
     171#define VMSVGA_BUSY_F_FIFO          RT_BIT_32(0) /**< The normal true/false busy FIFO bit. */
     172#define VMSVGA_BUSY_F_EMT_FORCE     RT_BIT_32(1) /**< Bit preventing race status flickering when EMT kicks the FIFO thread. */
     173    /** Traces (dirty page detection) enabled or not. */
     174    uint32_t                    fTraces;
     175    /** Guest OS identifier. */
     176    uint32_t                    u32GuestId;
     177    /** Scratch region size. */
     178    uint32_t                    cScratchRegion;
     179    /** Scratch array. */
     180    uint32_t                    au32ScratchRegion[VMSVGA_SCRATCH_SIZE];
     181    /** Irq status. */
     182    uint32_t                    u32IrqStatus;
     183    /** Irq mask. */
     184    uint32_t                    u32IrqMask;
     185    /** Pitch lock. */
     186    uint32_t                    u32PitchLock;
     187    /** Current GMR id. (SVGA_REG_GMR_ID) */
     188    uint32_t                    u32CurrentGMRId;
     189    /** Register caps. */
     190    uint32_t                    u32RegCaps;
     191    uint32_t                    Padding2;
     192    /** Physical address of command mmio range. */
     193    RTIOPORT                    BasePort;
     194    /** Port io index register. */
     195    uint32_t                    u32IndexReg;
     196    /** The support driver session handle for use with FIFORequestSem. */
     197    R3R0PTRTYPE(PSUPDRVSESSION) pSupDrvSession;
     198    /** FIFO request semaphore. */
     199    SUPSEMEVENT                 FIFORequestSem;
     200    /** FIFO external command semaphore. */
     201    R3PTRTYPE(RTSEMEVENT)       FIFOExtCmdSem;
     202    /** FIFO IO Thread. */
     203    R3PTRTYPE(PPDMTHREAD)       pFIFOIOThread;
     204    uint32_t                    uWidth;
     205    uint32_t                    uHeight;
     206    uint32_t                    uBpp;
     207    uint32_t                    cbScanline;
     208    /** Maximum width supported. */
     209    uint32_t                    u32MaxWidth;
     210    /** Maximum height supported. */
     211    uint32_t                    u32MaxHeight;
     212    /** Viewport rectangle, i.e. what's currently visible of the target host
     213     *  window.  This is usually (0,0)(uWidth,uHeight), but if the window is
     214     *  shrunk and scrolling applied, both the origin and size may differ.  */
     215    VMSVGAVIEWPORT              viewport;
     216    /** Action flags */
     217    uint32_t                    u32ActionFlags;
     218    /** SVGA 3d extensions enabled or not. */
     219    bool                        f3DEnabled;
     220    /** VRAM page monitoring enabled or not. */
     221    bool                        fVRAMTracking;
     222    /** External command to be executed in the FIFO thread. */
     223    uint8_t volatile            u8FIFOExtCommand;
     224    /** Set by vmsvgaR3RunExtCmdOnFifoThread when it temporarily resumes the FIFO
     225     * thread and does not want it do anything but the command. */
     226    bool volatile               fFifoExtCommandWakeup;
     227#if defined(DEBUG_GMR_ACCESS) || defined(DEBUG_FIFO_ACCESS)
     228    /** GMR debug access handler type handle. */
     229    PGMPHYSHANDLERTYPE          hGmrAccessHandlerType;
     230    /** FIFO debug access handler type handle. */
     231    PGMPHYSHANDLERTYPE          hFifoAccessHandlerType;
     232#endif
     233
     234    STAMCOUNTER                 StatRegBitsPerPixelWr;
     235    STAMCOUNTER                 StatRegBusyWr;
     236    STAMCOUNTER                 StatRegCursorXxxxWr;
     237    STAMCOUNTER                 StatRegDepthWr;
     238    STAMCOUNTER                 StatRegDisplayHeightWr;
     239    STAMCOUNTER                 StatRegDisplayIdWr;
     240    STAMCOUNTER                 StatRegDisplayIsPrimaryWr;
     241    STAMCOUNTER                 StatRegDisplayPositionXWr;
     242    STAMCOUNTER                 StatRegDisplayPositionYWr;
     243    STAMCOUNTER                 StatRegDisplayWidthWr;
     244    STAMCOUNTER                 StatRegEnableWr;
     245    STAMCOUNTER                 StatRegGmrIdWr;
     246    STAMCOUNTER                 StatRegGuestIdWr;
     247    STAMCOUNTER                 StatRegHeightWr;
     248    STAMCOUNTER                 StatRegIdWr;
     249    STAMCOUNTER                 StatRegIrqMaskWr;
     250    STAMCOUNTER                 StatRegNumDisplaysWr;
     251    STAMCOUNTER                 StatRegNumGuestDisplaysWr;
     252    STAMCOUNTER                 StatRegPaletteWr;
     253    STAMCOUNTER                 StatRegPitchLockWr;
     254    STAMCOUNTER                 StatRegPseudoColorWr;
     255    STAMCOUNTER                 StatRegReadOnlyWr;
     256    STAMCOUNTER                 StatRegScratchWr;
     257    STAMCOUNTER                 StatRegSyncWr;
     258    STAMCOUNTER                 StatRegTopWr;
     259    STAMCOUNTER                 StatRegTracesWr;
     260    STAMCOUNTER                 StatRegUnknownWr;
     261    STAMCOUNTER                 StatRegWidthWr;
     262
     263    STAMCOUNTER                 StatRegBitsPerPixelRd;
     264    STAMCOUNTER                 StatRegBlueMaskRd;
     265    STAMCOUNTER                 StatRegBusyRd;
     266    STAMCOUNTER                 StatRegBytesPerLineRd;
     267    STAMCOUNTER                 StatRegCapabilitesRd;
     268    STAMCOUNTER                 StatRegConfigDoneRd;
     269    STAMCOUNTER                 StatRegCursorXxxxRd;
     270    STAMCOUNTER                 StatRegDepthRd;
     271    STAMCOUNTER                 StatRegDisplayHeightRd;
     272    STAMCOUNTER                 StatRegDisplayIdRd;
     273    STAMCOUNTER                 StatRegDisplayIsPrimaryRd;
     274    STAMCOUNTER                 StatRegDisplayPositionXRd;
     275    STAMCOUNTER                 StatRegDisplayPositionYRd;
     276    STAMCOUNTER                 StatRegDisplayWidthRd;
     277    STAMCOUNTER                 StatRegEnableRd;
     278    STAMCOUNTER                 StatRegFbOffsetRd;
     279    STAMCOUNTER                 StatRegFbSizeRd;
     280    STAMCOUNTER                 StatRegFbStartRd;
     281    STAMCOUNTER                 StatRegGmrIdRd;
     282    STAMCOUNTER                 StatRegGmrMaxDescriptorLengthRd;
     283    STAMCOUNTER                 StatRegGmrMaxIdsRd;
     284    STAMCOUNTER                 StatRegGmrsMaxPagesRd;
     285    STAMCOUNTER                 StatRegGreenMaskRd;
     286    STAMCOUNTER                 StatRegGuestIdRd;
     287    STAMCOUNTER                 StatRegHeightRd;
     288    STAMCOUNTER                 StatRegHostBitsPerPixelRd;
     289    STAMCOUNTER                 StatRegIdRd;
     290    STAMCOUNTER                 StatRegIrqMaskRd;
     291    STAMCOUNTER                 StatRegMaxHeightRd;
     292    STAMCOUNTER                 StatRegMaxWidthRd;
     293    STAMCOUNTER                 StatRegMemorySizeRd;
     294    STAMCOUNTER                 StatRegMemRegsRd;
     295    STAMCOUNTER                 StatRegMemSizeRd;
     296    STAMCOUNTER                 StatRegMemStartRd;
     297    STAMCOUNTER                 StatRegNumDisplaysRd;
     298    STAMCOUNTER                 StatRegNumGuestDisplaysRd;
     299    STAMCOUNTER                 StatRegPaletteRd;
     300    STAMCOUNTER                 StatRegPitchLockRd;
     301    STAMCOUNTER                 StatRegPsuedoColorRd;
     302    STAMCOUNTER                 StatRegRedMaskRd;
     303    STAMCOUNTER                 StatRegScratchRd;
     304    STAMCOUNTER                 StatRegScratchSizeRd;
     305    STAMCOUNTER                 StatRegSyncRd;
     306    STAMCOUNTER                 StatRegTopRd;
     307    STAMCOUNTER                 StatRegTracesRd;
     308    STAMCOUNTER                 StatRegUnknownRd;
     309    STAMCOUNTER                 StatRegVramSizeRd;
     310    STAMCOUNTER                 StatRegWidthRd;
     311    STAMCOUNTER                 StatRegWriteOnlyRd;
     312} VMSVGAState;
     313
     314
    47315DECLCALLBACK(int) vmsvgaR3IORegionMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
    48316                                      RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType);

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

    r65218 r65294  
    104104    } while (0)
    105105#endif
    106 
    107 /** @def VBOX_WITH_VMSVGA_BACKUP_VGA_FB
    108  * Enables correct VGA MMIO read/write handling when VMSVGA is enabled.  It
    109  * is SLOW and probably not entirely right, but it helps with getting 3dmark
    110  * output and other stuff. */
    111 #define VBOX_WITH_VMSVGA_BACKUP_VGA_FB 1
    112106
    113107
    … …  
    12161210#endif
    12171211
    1218 #if !defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
    1219     /* Ugly hack to get result from 2dmark and other vmsvga examples. */
    1220     if (pThis->svga.fEnabled)
    1221         return VINF_IOM_R3_MMIO_READ;
     1212#ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RZ
     1213    /* VMSVGA keeps the VGA and SVGA framebuffers separate unlike this boch-based
     1214       VGA implementation, so we fake it by going to ring-3 and using a heap buffer.  */
     1215    if (!pThis->svga.fEnabled) { /*likely*/ }
     1216    else                       return VINF_IOM_R3_MMIO_READ;
    12221217#endif
    12231218
    … …  
    12461241    if (pThis->sr[4] & 0x08) {
    12471242        /* chain 4 mode : simplest access */
    1248 # ifndef IN_RC
     1243#ifndef IN_RC
    12491244        /* If all planes are accessible, then map the page to the frame buffer and make it writable. */
    12501245        if (   (pThis->sr[2] & 3) == 3
    … …  
    12591254            pThis->fRemappedVGA = true;
    12601255        }
    1261 # endif /* IN_RC */
     1256#endif /* !IN_RC */
    12621257        VERIFY_VRAM_READ_OFF_RETURN(pThis, addr, *prc);
    1263 #if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
    1264         if (pThis->svga.fEnabled && addr < _32K)
    1265             ret = ((uint8_t *)pThis->svga.pFrameBufferBackup)[addr];
    1266         else
    1267 #endif
    1268             ret = pThis->CTX_SUFF(vram_ptr)[addr];
     1258#ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
     1259        ret = !pThis->svga.fEnabled            ? pThis->CTX_SUFF(vram_ptr)[addr]
     1260            : addr < VMSVGA_VGA_FB_BACKUP_SIZE ? pThis->svga.pbVgaFrameBufferR3[addr] : 0xff;
     1261#else
     1262        ret = pThis->CTX_SUFF(vram_ptr)[addr];
     1263#endif
    12691264    } else if (!(pThis->sr[4] & 0x04)) {    /* Host access is controlled by SR4, not GR5! */
    12701265        /* odd/even mode (aka text mode mapping) */
    … …  
    12731268        RTGCPHYS off = ((addr & ~1) << 2) | plane;
    12741269        VERIFY_VRAM_READ_OFF_RETURN(pThis, off, *prc);
    1275 #if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
    1276         if (pThis->svga.fEnabled && off < _32K)
    1277             ret = ((uint8_t *)pThis->svga.pFrameBufferBackup)[off];
    1278         else
    1279 #endif
    1280             ret = pThis->CTX_SUFF(vram_ptr)[off];
     1270#ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
     1271        ret = !pThis->svga.fEnabled           ? pThis->CTX_SUFF(vram_ptr)[off]
     1272            : off < VMSVGA_VGA_FB_BACKUP_SIZE ? pThis->svga.pbVgaFrameBufferR3[off] : 0xff;
     1273#else
     1274        ret = pThis->CTX_SUFF(vram_ptr)[off];
     1275#endif
    12811276    } else {
    12821277        /* standard VGA latched access */
    12831278        VERIFY_VRAM_READ_OFF_RETURN(pThis, addr * 4 + 3, *prc);
    1284 #if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
    1285         if (pThis->svga.fEnabled && addr * 4 + 3 < _32K)
    1286             pThis->latch = ((uint32_t *)pThis->svga.pFrameBufferBackup)[addr];
    1287         else
    1288 #endif
    1289             pThis->latch = ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr];
    1290 
     1279#ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
     1280        pThis->latch = !pThis->svga.fEnabled            ? ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr]
     1281                     : addr < VMSVGA_VGA_FB_BACKUP_SIZE ? ((uint32_t *)pThis->svga.pbVgaFrameBufferR3)[addr] : UINT32_MAX;
     1282#else
     1283        pThis->latch = ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr];
     1284#endif
    12911285        if (!(pThis->gr[5] & 0x08)) {
    12921286            /* read mode 0 */
    … …  
    13181312#endif
    13191313
    1320 #if !defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
    1321     /* Ugly hack to get result from 2dmark and other vmsvga examples. */
    1322     if (pThis->svga.fEnabled)
    1323         return VINF_IOM_R3_MMIO_WRITE;
     1314#ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RZ
     1315    /* VMSVGA keeps the VGA and SVGA framebuffers separate unlike this boch-based
     1316       VGA implementation, so we fake it by going to ring-3 and using a heap buffer.  */
     1317    if (!pThis->svga.fEnabled) { /*likely*/ }
     1318    else                       return VINF_IOM_R3_MMIO_READ;
    13241319#endif
    13251320
    … …  
    13511346        mask = (1 << plane);
    13521347        if (pThis->sr[2] & mask) {
    1353 # ifndef IN_RC
     1348#ifndef IN_RC
    13541349            /* If all planes are accessible, then map the page to the frame buffer and make it writable. */
    13551350            if (   (pThis->sr[2] & 3) == 3
    … …  
    13611356                pThis->fRemappedVGA = true;
    13621357            }
    1363 # endif /* IN_RC */
     1358#endif /* !IN_RC */
    13641359
    13651360            VERIFY_VRAM_WRITE_OFF_RETURN(pThis, addr);
    1366 #if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
    1367             if (pThis->svga.fEnabled && addr < _32K)
    1368                 ((uint8_t *)pThis->svga.pFrameBufferBackup)[addr] = val;
     1361#ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
     1362            if (!pThis->svga.fEnabled)
     1363                pThis->CTX_SUFF(vram_ptr)[addr]      = val;
     1364            else if (addr < VMSVGA_VGA_FB_BACKUP_SIZE)
     1365                pThis->svga.pbVgaFrameBufferR3[addr] = val;
    13691366            else
    1370 #endif
    1371                 pThis->CTX_SUFF(vram_ptr)[addr] = val;
     1367            {
     1368                Log(("vga: chain4: out of vmsvga VGA framebuffer bounds! addr=%#x\n", addr));
     1369                return VINF_SUCCESS;
     1370            }
     1371#else
     1372            pThis->CTX_SUFF(vram_ptr)[addr] = val;
     1373#endif
    13721374            Log3(("vga: chain4: [0x%x]\n", addr));
    13731375            pThis->plane_updated |= mask; /* only used to detect font change */
    … …  
    13861388            addr = ((addr & ~1) << 2) | plane;
    13871389            VERIFY_VRAM_WRITE_OFF_RETURN(pThis, addr);
    1388 #if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
    1389             if (pThis->svga.fEnabled && addr < _32K)
    1390                 ((uint8_t *)pThis->svga.pFrameBufferBackup)[addr] = val;
     1390#ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
     1391            if (!pThis->svga.fEnabled)
     1392                pThis->CTX_SUFF(vram_ptr)[addr]      = val;
     1393            else if (addr < VMSVGA_VGA_FB_BACKUP_SIZE)
     1394                pThis->svga.pbVgaFrameBufferR3[addr] = val;
    13911395            else
    1392 #endif
    1393                 pThis->CTX_SUFF(vram_ptr)[addr] = val;
     1396            {
     1397                Log(("vga: odd/even: out of vmsvga VGA framebuffer bounds! addr=%#x\n", addr));
     1398                return VINF_SUCCESS;
     1399            }
     1400#else
     1401            pThis->CTX_SUFF(vram_ptr)[addr] = val;
     1402#endif
    13941403            Log3(("vga: odd/even: [0x%x]\n", addr));
    13951404            pThis->plane_updated |= mask; /* only used to detect font change */
    … …  
    15051514        pThis->plane_updated |= mask; /* only used to detect font change */
    15061515        write_mask = mask16[mask];
    1507 #if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
    1508         if (pThis->svga.fEnabled && addr * 4 + 3U < _32K)
    1509             ((uint32_t *)pThis->svga.pFrameBufferBackup)[addr] =
    1510                 (((uint32_t *)pThis->svga.pFrameBufferBackup)[addr] & ~write_mask) | (val & write_mask);
     1516#ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
     1517        uint32_t *pu32Dst;
     1518        if (!pThis->svga.fEnabled)
     1519            pu32Dst = &((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr];
     1520        else if (addr * 4 + 3 < VMSVGA_VGA_FB_BACKUP_SIZE)
     1521            pu32Dst = &((uint32_t *)pThis->svga.pbVgaFrameBufferR3)[addr];
    15111522        else
    1512 #endif
    1513             ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr] =
    1514                 (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr] & ~write_mask) |
    1515             (val & write_mask);
    1516             Log3(("vga: latch: [0x%x] mask=0x%08x val=0x%08x\n",
    1517                    addr * 4, write_mask, val));
    1518             vga_set_dirty(pThis, (addr << 2));
     1523        {
     1524            Log(("vga: latch: out of vmsvga VGA framebuffer bounds! addr=%#x\n", addr));
     1525            return VINF_SUCCESS;
     1526        }
     1527        *pu32Dst = (*pu32Dst & ~write_mask) | (val & write_mask);
     1528#else
     1529        ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr] = (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr] & ~write_mask)
     1530                                                      | (val & write_mask);
     1531#endif
     1532        Log3(("vga: latch: [0x%x] mask=0x%08x val=0x%08x\n", addr * 4, write_mask, val));
     1533        vga_set_dirty(pThis, (addr << 2));
    15191534    }
    15201535
    … …  
    22282243 * graphic modes
    22292244 */
    2230 static int vmsvga_draw_graphic(PVGASTATE pThis, bool full_update, bool fFailOnResize, bool reset_dirty,
     2245static int vmsvga_draw_graphic(PVGASTATE pThis, bool fFullUpdate, bool fFailOnResize, bool reset_dirty,
    22312246                               PDMIDISPLAYCONNECTOR *pDrv)
    22322247{
    22332248    RT_NOREF1(fFailOnResize);
    2234     int y, page_min, page_max, linesize, y_start;
    2235     int width, height, page0, page1, bwidth, bits;
    2236     int disp_width;
    2237     uint8_t *d;
    2238     uint32_t v, addr1, addr;
    2239     vga_draw_line_func *vga_draw_line;
    2240 
    2241     if (    pThis->svga.uWidth  == VMSVGA_VAL_UNINITIALIZED
    2242         ||  pThis->svga.uWidth  == 0
    2243         ||  pThis->svga.uHeight == VMSVGA_VAL_UNINITIALIZED
    2244         ||  pThis->svga.uHeight == 0
    2245         ||  pThis->svga.uBpp    == VMSVGA_VAL_UNINITIALIZED
    2246         ||  pThis->svga.uBpp    == 0)
     2249
     2250    uint32_t const cx        = pThis->svga.uWidth;
     2251    uint32_t const cxDisplay = cx;
     2252    uint32_t const cy        = pThis->svga.uHeight;
     2253    uint32_t       cBits     = pThis->svga.uBpp;
     2254
     2255    if (   cx    == VMSVGA_VAL_UNINITIALIZED
     2256        || cx    == 0
     2257        || cy    == VMSVGA_VAL_UNINITIALIZED
     2258        || cy    == 0
     2259        || cBits == VMSVGA_VAL_UNINITIALIZED
     2260        || cBits == 0)
    22472261    {
    22482262        /* Intermediate state; skip redraws. */
    … …  
    22502264    }
    22512265
    2252     width  = pThis->svga.uWidth;
    2253     height = pThis->svga.uHeight;
    2254 
    2255     disp_width = width;
    2256 
    2257     switch(pThis->svga.uBpp) {
    2258     default:
    2259     case 0:
    2260     case 8:
    2261         AssertFailed();
    2262         return VERR_NOT_IMPLEMENTED;
    2263     case 15:
    2264         v = VGA_DRAW_LINE15;
    2265         bits = 16;
    2266         break;
    2267     case 16:
    2268         v = VGA_DRAW_LINE16;
    2269         bits = 16;
    2270         break;
    2271     case 24:
    2272         v = VGA_DRAW_LINE24;
    2273         bits = 24;
    2274         break;
    2275     case 32:
    2276         v = VGA_DRAW_LINE32;
    2277         bits = 32;
    2278         break;
    2279     }
    2280     vga_draw_line = vga_draw_line_table[v * 4 + get_depth_index(pDrv->cBits)];
    2281 
    2282     if (pThis->cursor_invalidate)
    2283         pThis->cursor_invalidate(pThis);
    2284 
    2285     addr1 = 0;  /* always start at the beginning of the framebuffer */
    2286     bwidth = (width * bits + 7) / 8;    /* The visible width of a scanline. */
    2287     y_start = -1;
    2288     page_min = 0x7fffffff;
    2289     page_max = -1;
    2290     d = pDrv->pbData;
    2291     linesize = pDrv->cbScanline;
    2292 
    2293     for(y = 0; y < height; y++)
    2294     {
    2295         addr = addr1 + y * bwidth;
    2296 
    2297         page0 = addr & ~PAGE_OFFSET_MASK;
    2298         page1 = (addr + bwidth - 1) & ~PAGE_OFFSET_MASK;
    2299         bool update = full_update | vga_is_dirty(pThis, page0) | vga_is_dirty(pThis, page1);
    2300         if (page1 - page0 > PAGE_SIZE)
     2266    unsigned v;
     2267    switch (cBits)
     2268    {
     2269        case 8:
     2270            /* Note! experimental, not sure if this really works... */
     2271            /** @todo fFullUpdate |= update_palette256(pThis); - need fFullUpdate but not
     2272             *        copying anything to last_palette. */
     2273            v = VGA_DRAW_LINE8;
     2274            break;
     2275        case 15:
     2276            v = VGA_DRAW_LINE15;
     2277            cBits = 16;
     2278            break;
     2279        case 16:
     2280            v = VGA_DRAW_LINE16;
     2281            break;
     2282        case 24:
     2283            v = VGA_DRAW_LINE24;
     2284            break;
     2285        case 32:
     2286            v = VGA_DRAW_LINE32;
     2287            break;
     2288        default:
     2289        case 0:
     2290            AssertFailed();
     2291            return VERR_NOT_IMPLEMENTED;
     2292    }
     2293    vga_draw_line_func *pfnVgaDrawLine = vga_draw_line_table[v * 4 + get_depth_index(pDrv->cBits)];
     2294
     2295    Assert(!pThis->cursor_invalidate);
     2296    Assert(!pThis->cursor_draw_line);
     2297    //not used// if (pThis->cursor_invalidate)
     2298    //not used//     pThis->cursor_invalidate(pThis);
     2299
     2300    uint8_t    *pbDst          = pDrv->pbData;
     2301    uint32_t    cbDstScanline  = pDrv->cbScanline;
     2302    uint32_t    offSrcStart    = 0;  /* always start at the beginning of the framebuffer */
     2303    uint32_t    cbScanline     = (cx * cBits + 7) / 8;   /* The visible width of a scanline. */
     2304    uint32_t    yUpdateRectTop = UINT32_MAX;
     2305    uint32_t    offPageMin     = UINT32_MAX;
     2306    int32_t     offPageMax     = -1;
     2307    uint32_t    y;
     2308    for (y = 0; y < cy; y++)
     2309    {
     2310        uint32_t offSrcLine = offSrcStart + y * cbScanline;
     2311        uint32_t offPage0   = offSrcLine & ~PAGE_OFFSET_MASK;
     2312        uint32_t offPage1   = (offSrcLine + cbScanline - 1) & ~PAGE_OFFSET_MASK;
     2313        bool     fUpdate    = fFullUpdate | vga_is_dirty(pThis, offPage0) | vga_is_dirty(pThis, offPage1);
     2314        if (offPage1 - offPage0 > PAGE_SIZE)
    23012315            /* if wide line, can use another page */
    2302             update |= vga_is_dirty(pThis, page0 + PAGE_SIZE);
     2316            fUpdate |= vga_is_dirty(pThis, offPage0 + PAGE_SIZE);
    23032317        /* explicit invalidation for the hardware cursor */
    2304         update |= (pThis->invalidated_y_table[y >> 5] >> (y & 0x1f)) & 1;
    2305         if (update)
     2318        fUpdate |= (pThis->invalidated_y_table[y >> 5] >> (y & 0x1f)) & 1;
     2319        if (fUpdate)
    23062320        {
    2307             if (y_start < 0)
    2308                 y_start = y;
    2309             if (page0 < page_min)
    2310                 page_min = page0;
    2311             if (page1 > page_max)
    2312                 page_max = page1;
     2321            if (yUpdateRectTop == UINT32_MAX)
     2322                yUpdateRectTop = y;
     2323            if (offPage0 < offPageMin)
     2324                offPageMin = offPage0;
     2325            if ((int32_t)offPage1 > offPageMax)
     2326                offPageMax = offPage1;
    23132327            if (pThis->fRenderVRAM)
    2314                 vga_draw_line(pThis, d, pThis->CTX_SUFF(vram_ptr) + addr, width);
    2315             if (pThis->cursor_draw_line)
    2316                 pThis->cursor_draw_line(pThis, d, y);
    2317         } else
     2328                pfnVgaDrawLine(pThis, pbDst, pThis->CTX_SUFF(vram_ptr) + offSrcLine, cx);
     2329            //not used// if (pThis->cursor_draw_line)
     2330            //not used//     pThis->cursor_draw_line(pThis, pbDst, y);
     2331        }
     2332        else if (yUpdateRectTop != UINT32_MAX)
    23182333        {
    2319             if (y_start >= 0)
    2320             {
    2321                 /* flush to display */
    2322                 Log(("Flush to display (%d,%d)(%d,%d)\n", 0, y_start, disp_width, y - y_start));
    2323                 pDrv->pfnUpdateRect(pDrv, 0, y_start, disp_width, y - y_start);
    2324                 y_start = -1;
    2325             }
    2326         }
    2327         d += linesize;
    2328     }
    2329     if (y_start >= 0)
     2334            /* flush to display */
     2335            Log(("Flush to display (%d,%d)(%d,%d)\n", 0, yUpdateRectTop, cxDisplay, y - yUpdateRectTop));
     2336            pDrv->pfnUpdateRect(pDrv, 0, yUpdateRectTop, cxDisplay, y - yUpdateRectTop);
     2337            yUpdateRectTop = UINT32_MAX;
     2338        }
     2339        pbDst += cbDstScanline;
     2340    }
     2341    if (yUpdateRectTop != UINT32_MAX)
    23302342    {
    23312343        /* flush to display */
    2332         Log(("Flush to display (%d,%d)(%d,%d)\n", 0, y_start, disp_width, y - y_start));
    2333         pDrv->pfnUpdateRect(pDrv, 0, y_start, disp_width, y - y_start);
    2334     }
     2344        Log(("Flush to display (%d,%d)(%d,%d)\n", 0, yUpdateRectTop, cxDisplay, y - yUpdateRectTop));
     2345        pDrv->pfnUpdateRect(pDrv, 0, yUpdateRectTop, cxDisplay, y - yUpdateRectTop);
     2346    }
     2347
    23352348    /* reset modified pages */
    2336     if (page_max != -1 && reset_dirty)
    2337         vga_reset_dirty(pThis, page_min, page_max + PAGE_SIZE);
    2338     memset(pThis->invalidated_y_table, 0, ((height + 31) >> 5) * 4);
     2349    if (offPageMax != -1 && reset_dirty)
     2350        vga_reset_dirty(pThis, offPageMin, offPageMax + PAGE_SIZE);
     2351    memset(pThis->invalidated_y_table, 0, ((cy + 31) >> 5) * 4);
     2352
    23392353    return VINF_SUCCESS;
    23402354}

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

    r65265 r65294  
    6969#endif
    7070
    71 # include <iprt/list.h>
     71#include <iprt/list.h>
    7272
    7373#define MSR_COLOR_EMULATION 0x01
    … …  
    212212#endif
    213213
    214 #ifdef VBOX_WITH_VMSVGA
    215 
    216 #ifdef DEBUG
    217 /* Enable to log FIFO register accesses. */
    218 //# define DEBUG_FIFO_ACCESS
    219 /* Enable to log GMR page accesses. */
    220 //# define DEBUG_GMR_ACCESS
    221 #endif
    222 
    223 #define VMSVGA_FIFO_EXTCMD_NONE                         0
    224 #define VMSVGA_FIFO_EXTCMD_TERMINATE                    1
    225 #define VMSVGA_FIFO_EXTCMD_SAVESTATE                    2
    226 #define VMSVGA_FIFO_EXTCMD_LOADSTATE                    3
    227 #define VMSVGA_FIFO_EXTCMD_RESET                        4
    228 #define VMSVGA_FIFO_EXTCMD_UPDATE_SURFACE_HEAP_BUFFERS  5
    229 
    230 /** Size of the region to backup when switching into svga mode. */
    231 #define VMSVGA_FRAMEBUFFER_BACKUP_SIZE  (32*1024)
    232 
    233 typedef struct
    234 {
    235     PSSMHANDLE      pSSM;
    236     uint32_t        uVersion;
    237     uint32_t        uPass;
    238 } VMSVGA_STATE_LOAD, *PVMSVGA_STATE_LOAD;
    239 
    240 /** Host screen viewport.
    241  * (4th quadrant with negated Y values - usual Windows and X11 world view.) */
    242 typedef struct VMSVGAVIEWPORT
    243 {
    244     uint32_t        x;                  /**< x coordinate (left). */
    245     uint32_t        y;                  /**< y coordinate (top). */
    246     uint32_t        cx;                 /**< width. */
    247     uint32_t        cy;                 /**< height. */
    248     /** Right side coordinate (exclusive). Same as x + cx. */
    249     uint32_t        xRight;
    250     /** First quadrant low y coordinate.
    251      * Same as y + cy - 1 in window coordinates. */
    252     uint32_t        yLowWC;
    253     /** First quadrant high y coordinate (exclusive) - yLowWC + cy.
    254      * Same as y - 1 in window coordinates. */
    255     uint32_t        yHighWC;
    256     /** Alignment padding. */
    257     uint32_t        uAlignment;
    258 } VMSVGAVIEWPORT;
    259 
    260 /** Pointer to the private VMSVGA ring-3 state structure.
    261  * @todo Still not entirely satisfired with the type name, but better than
    262  *       the previous lower/upper case only distinction. */
    263 typedef struct VMSVGAR3STATE *PVMSVGAR3STATE;
    264 /** Pointer to the private (implementation specific) VMSVGA3d state. */
    265 typedef struct VMSVGA3DSTATE *PVMSVGA3DSTATE;
    266 
    267 typedef struct VMSVGAState
    268 {
    269     /** The host window handle */
    270     uint64_t                    u64HostWindowId;
    271     /** The R3 FIFO pointer. */
    272     R3PTRTYPE(uint32_t *)       pFIFOR3;
    273     /** The R0 FIFO pointer. */
    274     R0PTRTYPE(uint32_t *)       pFIFOR0;
    275     /** R3 Opaque pointer to svga state. */
    276     R3PTRTYPE(PVMSVGAR3STATE)   pSvgaR3State;
    277     /** R3 Opaque pointer to 3d state. */
    278     R3PTRTYPE(PVMSVGA3DSTATE)   p3dState;
    279     /** R3 Opaque pointer to a copy of the first 32k of the framebuffer before switching into svga mode. */
    280     R3PTRTYPE(void *)           pFrameBufferBackup;
    281     /** R3 Opaque pointer to an external fifo cmd parameter. */
    282     R3PTRTYPE(void * volatile)  pvFIFOExtCmdParam;
    283 
    284     /** Guest physical address of the FIFO memory range. */
    285     RTGCPHYS                    GCPhysFIFO;
    286     /** Size in bytes of the FIFO memory range. */
    287     uint32_t                    cbFIFO;
    288     /** SVGA id. */
    289     uint32_t                    u32SVGAId;
    290     /** SVGA extensions enabled or not. */
    291     uint32_t                    fEnabled;
    292     /** SVGA memory area configured status. */
    293     uint32_t                    fConfigured;
    294     /** Device is busy handling FIFO requests (VMSVGA_BUSY_F_FIFO,
    295      *  VMSVGA_BUSY_F_EMT_FORCE). */
    296     uint32_t volatile           fBusy;
    297 #define VMSVGA_BUSY_F_FIFO          RT_BIT_32(0) /**< The normal true/false busy FIFO bit. */
    298 #define VMSVGA_BUSY_F_EMT_FORCE     RT_BIT_32(1) /**< Bit preventing race status flickering when EMT kicks the FIFO thread. */
    299     /** Traces (dirty page detection) enabled or not. */
    300     uint32_t                    fTraces;
    301     /** Guest OS identifier. */
    302     uint32_t                    u32GuestId;
    303     /** Scratch region size. */
    304     uint32_t                    cScratchRegion;
    305     /** Scratch array. */
    306     uint32_t                    au32ScratchRegion[VMSVGA_SCRATCH_SIZE];
    307     /** Irq status. */
    308     uint32_t                    u32IrqStatus;
    309     /** Irq mask. */
    310     uint32_t                    u32IrqMask;
    311     /** Pitch lock. */
    312     uint32_t                    u32PitchLock;
    313     /** Current GMR id. (SVGA_REG_GMR_ID) */
    314     uint32_t                    u32CurrentGMRId;
    315     /** Register caps. */
    316     uint32_t                    u32RegCaps;
    317     uint32_t                    Padding2;
    318     /** Physical address of command mmio range. */
    319     RTIOPORT                    BasePort;
    320     /** Port io index register. */
    321     uint32_t                    u32IndexReg;
    322     /** The support driver session handle for use with FIFORequestSem. */
    323     R3R0PTRTYPE(PSUPDRVSESSION) pSupDrvSession;
    324     /** FIFO request semaphore. */
    325     SUPSEMEVENT                 FIFORequestSem;
    326     /** FIFO external command semaphore. */
    327     R3PTRTYPE(RTSEMEVENT)       FIFOExtCmdSem;
    328     /** FIFO IO Thread. */
    329     R3PTRTYPE(PPDMTHREAD)       pFIFOIOThread;
    330     uint32_t                    uWidth;
    331     uint32_t                    uHeight;
    332     uint32_t                    uBpp;
    333     uint32_t                    cbScanline;
    334     /** Maximum width supported. */
    335     uint32_t                    u32MaxWidth;
    336     /** Maximum height supported. */
    337     uint32_t                    u32MaxHeight;
    338     /** Viewport rectangle, i.e. what's currently visible of the target host
    339      *  window.  This is usually (0,0)(uWidth,uHeight), but if the window is
    340      *  shrunk and scrolling applied, both the origin and size may differ.  */
    341     VMSVGAVIEWPORT              viewport;
    342     /** Action flags */
    343     uint32_t                    u32ActionFlags;
    344     /** SVGA 3d extensions enabled or not. */
    345     bool                        f3DEnabled;
    346     /** VRAM page monitoring enabled or not. */
    347     bool                        fVRAMTracking;
    348     /** External command to be executed in the FIFO thread. */
    349     uint8_t volatile            u8FIFOExtCommand;
    350     /** Set by vmsvgaR3RunExtCmdOnFifoThread when it temporarily resumes the FIFO
    351      * thread and does not want it do anything but the command. */
    352     bool volatile               fFifoExtCommandWakeup;
    353 # if defined(DEBUG_GMR_ACCESS) || defined(DEBUG_FIFO_ACCESS)
    354     /** GMR debug access handler type handle. */
    355     PGMPHYSHANDLERTYPE          hGmrAccessHandlerType;
    356     /** FIFO debug access handler type handle. */
    357     PGMPHYSHANDLERTYPE          hFifoAccessHandlerType;
    358 # endif
    359 
    360     STAMCOUNTER                 StatRegBitsPerPixelWr;
    361     STAMCOUNTER                 StatRegBusyWr;
    362     STAMCOUNTER                 StatRegCursorXxxxWr;
    363     STAMCOUNTER                 StatRegDepthWr;
    364     STAMCOUNTER                 StatRegDisplayHeightWr;
    365     STAMCOUNTER                 StatRegDisplayIdWr;
    366     STAMCOUNTER                 StatRegDisplayIsPrimaryWr;
    367     STAMCOUNTER                 StatRegDisplayPositionXWr;
    368     STAMCOUNTER                 StatRegDisplayPositionYWr;
    369     STAMCOUNTER                 StatRegDisplayWidthWr;
    370     STAMCOUNTER                 StatRegEnableWr;
    371     STAMCOUNTER                 StatRegGmrIdWr;
    372     STAMCOUNTER                 StatRegGuestIdWr;
    373     STAMCOUNTER                 StatRegHeightWr;
    374     STAMCOUNTER                 StatRegIdWr;
    375     STAMCOUNTER                 StatRegIrqMaskWr;
    376     STAMCOUNTER                 StatRegNumDisplaysWr;
    377     STAMCOUNTER                 StatRegNumGuestDisplaysWr;
    378     STAMCOUNTER                 StatRegPaletteWr;
    379     STAMCOUNTER                 StatRegPitchLockWr;
    380     STAMCOUNTER                 StatRegPseudoColorWr;
    381     STAMCOUNTER                 StatRegReadOnlyWr;
    382     STAMCOUNTER                 StatRegScratchWr;
    383     STAMCOUNTER                 StatRegSyncWr;
    384     STAMCOUNTER                 StatRegTopWr;
    385     STAMCOUNTER                 StatRegTracesWr;
    386     STAMCOUNTER                 StatRegUnknownWr;
    387     STAMCOUNTER                 StatRegWidthWr;
    388 
    389     STAMCOUNTER                 StatRegBitsPerPixelRd;
    390     STAMCOUNTER                 StatRegBlueMaskRd;
    391     STAMCOUNTER                 StatRegBusyRd;
    392     STAMCOUNTER                 StatRegBytesPerLineRd;
    393     STAMCOUNTER                 StatRegCapabilitesRd;
    394     STAMCOUNTER                 StatRegConfigDoneRd;
    395     STAMCOUNTER                 StatRegCursorXxxxRd;
    396     STAMCOUNTER                 StatRegDepthRd;
    397     STAMCOUNTER                 StatRegDisplayHeightRd;
    398     STAMCOUNTER                 StatRegDisplayIdRd;
    399     STAMCOUNTER                 StatRegDisplayIsPrimaryRd;
    400     STAMCOUNTER                 StatRegDisplayPositionXRd;
    401     STAMCOUNTER                 StatRegDisplayPositionYRd;
    402     STAMCOUNTER                 StatRegDisplayWidthRd;
    403     STAMCOUNTER                 StatRegEnableRd;
    404     STAMCOUNTER                 StatRegFbOffsetRd;
    405     STAMCOUNTER                 StatRegFbSizeRd;
    406     STAMCOUNTER                 StatRegFbStartRd;
    407     STAMCOUNTER                 StatRegGmrIdRd;
    408     STAMCOUNTER                 StatRegGmrMaxDescriptorLengthRd;
    409     STAMCOUNTER                 StatRegGmrMaxIdsRd;
    410     STAMCOUNTER                 StatRegGmrsMaxPagesRd;
    411     STAMCOUNTER                 StatRegGreenMaskRd;
    412     STAMCOUNTER                 StatRegGuestIdRd;
    413     STAMCOUNTER                 StatRegHeightRd;
    414     STAMCOUNTER                 StatRegHostBitsPerPixelRd;
    415     STAMCOUNTER                 StatRegIdRd;
    416     STAMCOUNTER                 StatRegIrqMaskRd;
    417     STAMCOUNTER                 StatRegMaxHeightRd;
    418     STAMCOUNTER                 StatRegMaxWidthRd;
    419     STAMCOUNTER                 StatRegMemorySizeRd;
    420     STAMCOUNTER                 StatRegMemRegsRd;
    421     STAMCOUNTER                 StatRegMemSizeRd;
    422     STAMCOUNTER                 StatRegMemStartRd;
    423     STAMCOUNTER                 StatRegNumDisplaysRd;
    424     STAMCOUNTER                 StatRegNumGuestDisplaysRd;
    425     STAMCOUNTER                 StatRegPaletteRd;
    426     STAMCOUNTER                 StatRegPitchLockRd;
    427     STAMCOUNTER                 StatRegPsuedoColorRd;
    428     STAMCOUNTER                 StatRegRedMaskRd;
    429     STAMCOUNTER                 StatRegScratchRd;
    430     STAMCOUNTER                 StatRegScratchSizeRd;
    431     STAMCOUNTER                 StatRegSyncRd;
    432     STAMCOUNTER                 StatRegTopRd;
    433     STAMCOUNTER                 StatRegTracesRd;
    434     STAMCOUNTER                 StatRegUnknownRd;
    435     STAMCOUNTER                 StatRegVramSizeRd;
    436     STAMCOUNTER                 StatRegWidthRd;
    437     STAMCOUNTER                 StatRegWriteOnlyRd;
    438 } VMSVGAState;
    439 #endif /* VBOX_WITH_VMSVGA */
    440 
    441214
    442215typedef struct VGAState {

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

    r62885 r65294  
    4545    } while (0)
    4646
    47 #define VGA_SAVEDSTATE_VERSION              16
     47#define VGA_SAVEDSTATE_VERSION              17
     48#define VGA_SAVEDSTATE_VERSION_VMSVGA_VGA_FB_FIX 17
    4849#define VGA_SAVEDSTATE_VERSION_MARKERS      16
    4950#define VGA_SAVEDSTATE_VERSION_MODE_HINTS   15

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

    r65069 r65294  
    320320    GEN_CHECK_OFF(VGASTATE, svga.pSvgaR3State);
    321321    GEN_CHECK_OFF(VGASTATE, svga.p3dState);
    322     GEN_CHECK_OFF(VGASTATE, svga.pFrameBufferBackup);
     322    GEN_CHECK_OFF(VGASTATE, svga.pbVgaFrameBufferR3);
    323323    GEN_CHECK_OFF(VGASTATE, svga.GCPhysFIFO);
    324324    GEN_CHECK_OFF(VGASTATE, svga.cbFIFO);
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