Changeset 82109 in vbox for trunk/src/VBox/Devices

Timestamp:

Nov 22, 2019 8:24:21 PM (5 years ago)

Author:

vboxsync

Message:

DevVGA: Splitting up the VGASTATE structure. bugref:9218

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA.cpp (modified) (105 diffs)
• DevVGA-SVGA.h (modified) (2 diffs)
• DevVGA-SVGA3d-info.cpp (modified) (1 diff)
• DevVGA-SVGA3d-internal.h (modified) (1 diff)
• DevVGA-SVGA3d-ogl.cpp (modified) (14 diffs)
• DevVGA-SVGA3d-savedstate.cpp (modified) (2 diffs)
• DevVGA-SVGA3d-win.cpp (modified) (9 diffs)
• DevVGA-SVGA3d.cpp (modified) (16 diffs)
• DevVGA-SVGA3d.h (modified) (4 diffs)
• DevVGA.cpp (modified) (203 diffs)
• DevVGA.h (modified) (15 diffs)
• DevVGATmpl.h (modified) (13 diffs)
• DevVGA_VBVA.cpp (modified) (108 diffs)
• DevVGA_VDMA.cpp (modified) (3 diffs)

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

@@ -548 +548 @@
 *********************************************************************************************************************************/
 #ifdef IN_RING3
-static void vmsvgaR3SetTraces(PVGASTATE pThis, bool fTraces);
+static void vmsvgaR3SetTraces(PPDMDEVINS pDevIns, PVGASTATE pThis, bool fTraces);
 static int vmsvgaR3LoadExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
 static int vmsvgaR3SaveExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PSSMHANDLE pSSM);
@@ -575 +575 @@
  *
  * @returns Index register string or "UNKNOWN"
- * @param   pThis       VMSVGA State
+ * @param   pThis       The shared VGA/VMSVGA state.
  * @param   idxReg      The index register.
  */
@@ -718 +718 @@
 DECLCALLBACK(void) vmsvgaR3PortSetViewport(PPDMIDISPLAYPORT pInterface, uint32_t idScreen, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
 {
-    PVGASTATE pThis = RT_FROM_MEMBER(pInterface, VGASTATE, IPort);
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVGASTATE);
 
     Log(("vmsvgaPortSetViewPort: screen %d (%d,%d)(%d,%d)\n", idScreen, x, y, cx, cy));
@@ -772 +773 @@
  * @returns VBox status code.
  * @param   pDevIns     The device instance.
- * @param   pThis       VMSVGA State
+ * @param   pThis       The shared VGA/VMSVGA state.
  * @param   pu32        Where to store the read value
  */
 static int vmsvgaReadPort(PPDMDEVINS pDevIns, PVGASTATE pThis, uint32_t *pu32)
 {
+#ifdef IN_RING3
+    PVGASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+#endif
     int rc = VINF_SUCCESS;
     *pu32 = 0;
@@ -823 +827 @@
                 rc = VINF_IOM_R3_IOPORT_READ;
 #else
-                *pu32 = pThis->pDrv->cx;
+                *pu32 = pThisCC->pDrv->cx;
 #endif
             }
@@ -840 +844 @@
                 rc = VINF_IOM_R3_IOPORT_READ;
 #else
-                *pu32 = pThis->pDrv->cy;
+                *pu32 = pThisCC->pDrv->cy;
 #endif
             }
@@ -884 +888 @@
                 rc = VINF_IOM_R3_IOPORT_READ;
 #else
-                *pu32 = pThis->pDrv->cBits;
+                *pu32 = pThisCC->pDrv->cBits;
 #endif
             }
@@ -899 +903 @@
                 rc = VINF_IOM_R3_IOPORT_READ;
 #else
-                *pu32 = (pThis->pDrv->cBits + 7) & ~7;
+                *pu32 = (pThisCC->pDrv->cBits + 7) & ~7;
 #endif
             }
@@ -926 +930 @@
                 break;
 #else
-                uBpp = pThis->pDrv->cBits;
+                uBpp = pThisCC->pDrv->cBits;
 #endif
             }
@@ -989 +993 @@
                 rc = VINF_IOM_R3_IOPORT_READ;
 #else
-                *pu32 = pThis->pDrv->cbScanline;
+                *pu32 = pThisCC->pDrv->cbScanline;
 #endif
             }
@@ -1027 +1031 @@
             }
             else
-                *pu32 = RT_MAX(0x100000, (uint32_t)pThis->pDrv->cy * pThis->pDrv->cbScanline);
+                *pu32 = RT_MAX(0x100000, (uint32_t)pThisCC->pDrv->cy * pThisCC->pDrv->cbScanline);
 
             *pu32 = RT_MIN(pThis->vram_size, *pu32);
-            Log(("h=%d w=%d bpp=%d\n", pThis->pDrv->cy, pThis->pDrv->cx, pThis->pDrv->cBits));
+            Log(("h=%d w=%d bpp=%d\n", pThisCC->pDrv->cy, pThisCC->pDrv->cx, pThisCC->pDrv->cBits));
 #endif
             break;
@@ -1076 +1080 @@
                 PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
                 STAM_REL_PROFILE_START(&pSVGAState->StatBusyDelayEmts, EmtDelay);
-                PVM         pVM   = PDMDevHlpGetVM(pThis->pDevInsR3);
-                VMCPUID     idCpu = PDMDevHlpGetCurrentCpuId(pThis->pDevInsR3);
+                PVM         pVM   = PDMDevHlpGetVM(pDevIns);
+                VMCPUID     idCpu = PDMDevHlpGetCurrentCpuId(pDevIns);
                 VMCPUSET_ATOMIC_ADD(&pSVGAState->BusyDelayedEmts, idCpu);
                 ASMAtomicIncU32(&pSVGAState->cBusyDelayedEmts);
@@ -1107 +1111 @@
                          *        code in VMEmt.cpp here, otherwise all kind of EMT interaction will
                          *        suffer when the guest is polling on a busy FIFO. */
-                        uint64_t cNsMaxWait = TMVirtualSyncGetNsToDeadline(PDMDevHlpGetVM(pThis->pDevInsR3));
+                        uint64_t cNsMaxWait = TMVirtualSyncGetNsToDeadline(PDMDevHlpGetVM(pDevIns));
                         if (cNsMaxWait >= RT_NS_100US)
                             RTSemEventMultiWaitEx(pSVGAState->hBusyDelayedEmts,
@@ -1288 +1292 @@
  *
  * @returns VBox status code.
- * @param   pThis       VMSVGA State
+ * @param   pThis       The shared VGA state.
+ * @param   pThisCC     The ring-3 VGA state.
  */
-static int vmsvgaR3ChangeMode(PVGASTATE pThis)
+static int vmsvgaR3ChangeMode(PVGASTATE pThis, PVGASTATECC pThisCC)
 {
     int rc;
@@ -1299 +1304 @@
     PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
 
-    pThis->pDrv->pfnLFBModeChange(pThis->pDrv, true);
+    pThisCC->pDrv->pfnLFBModeChange(pThisCC->pDrv, true);
 
     if (pThis->svga.fGFBRegisters)
@@ -1392 +1397 @@
         }
 
-        rc = pThis->pDrv->pfnVBVAResize(pThis->pDrv, &view, &screen, pThis->CTX_SUFF(vram_ptr), /*fResetInputMapping=*/ true);
+        rc = pThisCC->pDrv->pfnVBVAResize(pThisCC->pDrv, &view, &screen, pThisCC->pbVRam, /*fResetInputMapping=*/ true);
         AssertRC(rc);
     }
@@ -1417 +1422 @@
 }
 
-int vmsvgaR3UpdateScreen(PVGASTATE pThis, VMSVGASCREENOBJECT *pScreen, int x, int y, int w, int h)
+int vmsvgaR3UpdateScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen, int x, int y, int w, int h)
 {
     VBVACMDHDR cmd;
@@ -1425 +1430 @@
     cmd.h = (uint16_t)h;
 
-    pThis->pDrv->pfnVBVAUpdateBegin(pThis->pDrv, pScreen->idScreen);
-    pThis->pDrv->pfnVBVAUpdateProcess(pThis->pDrv, pScreen->idScreen, &cmd, sizeof(cmd));
-    pThis->pDrv->pfnVBVAUpdateEnd(pThis->pDrv, pScreen->idScreen,
-                                  pScreen->xOrigin + x, pScreen->yOrigin + y, w, h);
+    pThisCC->pDrv->pfnVBVAUpdateBegin(pThisCC->pDrv, pScreen->idScreen);
+    pThisCC->pDrv->pfnVBVAUpdateProcess(pThisCC->pDrv, pScreen->idScreen, &cmd, sizeof(cmd));
+    pThisCC->pDrv->pfnVBVAUpdateEnd(pThisCC->pDrv, pScreen->idScreen,
+                                    pScreen->xOrigin + x, pScreen->yOrigin + y, w, h);
 
     return VINF_SUCCESS;
@@ -1464 +1469 @@
  * width/bpp.
  *
- * @param   pThis       VMSVGA State
+ * @param   pThis       The shared VGA/VMSVGA state.
  */
 DECLINLINE(void) vmsvgaHCUpdatePitch(PVGASTATE pThis)
@@ -1505 +1510 @@
  *
  * @returns Strict VBox status code.
- * @param   pThis       VMSVGA State
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The shared VGA/VMSVGA state.
+ * @param   pThisC      The VGA/VMSVGA state for the current context.
  * @param   u32         Value to write
  */
-static VBOXSTRICTRC vmsvgaWritePort(PPDMDEVINS pDevIns, PVGASTATE pThis, uint32_t u32)
+static VBOXSTRICTRC vmsvgaWritePort(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t u32)
 {
 #ifdef IN_RING3
@@ -1514 +1521 @@
 #endif
     VBOXSTRICTRC rc = VINF_SUCCESS;
+    RT_NOREF(pThisCC);
 
     /* Rough index register validation. */
@@ -1557 +1565 @@
                 pThis->svga.u32SVGAId = u32;
             else
-                PDMDevHlpDBGFStop(pThis->CTX_SUFF(pDevIns), RT_SRC_POS, "Trying to set SVGA_REG_ID to %#x (%d)\n", u32, u32);
+                PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "Trying to set SVGA_REG_ID to %#x (%d)\n", u32, u32);
             break;
 
@@ -1568 +1576 @@
                 /* Make a backup copy of the first 512kb in order to save font data etc. */
                 /** @todo should probably swap here, rather than copy + zero */
-                memcpy(pThis->svga.pbVgaFrameBufferR3, pThis->vram_ptrR3, VMSVGA_VGA_FB_BACKUP_SIZE);
-                memset(pThis->vram_ptrR3, 0, VMSVGA_VGA_FB_BACKUP_SIZE);
+                memcpy(pThis->svga.pbVgaFrameBufferR3, pThisCC->pbVRam, VMSVGA_VGA_FB_BACKUP_SIZE);
+                memset(pThisCC->pbVRam, 0, VMSVGA_VGA_FB_BACKUP_SIZE);
             }
 
@@ -1580 +1588 @@
                 {
                     /* Keep the current mode. */
-                    pThis->svga.uWidth  = pThis->pDrv->cx;
-                    pThis->svga.uHeight = pThis->pDrv->cy;
-                    pThis->svga.uBpp    = (pThis->pDrv->cBits + 7) & ~7;
+                    pThis->svga.uWidth  = pThisCC->pDrv->cx;
+                    pThis->svga.uHeight = pThisCC->pDrv->cy;
+                    pThis->svga.uBpp    = (pThisCC->pDrv->cBits + 7) & ~7;
                 }
 
@@ -1596 +1604 @@
 
                 /* Disable or enable dirty page tracking according to the current fTraces value. */
-                vmsvgaR3SetTraces(pThis, !!pThis->svga.fTraces);
+                vmsvgaR3SetTraces(pDevIns, pThis, !!pThis->svga.fTraces);
 
                 /* bird: Whatever this is was added to make screenshot work, ask sunlover should explain... */
                 for (uint32_t idScreen = 0; idScreen < pThis->cMonitors; ++idScreen)
-                    pThis->pDrv->pfnVBVAEnable(pThis->pDrv, idScreen, NULL /*pHostFlags*/);
+                    pThisCC->pDrv->pfnVBVAEnable(pThisCC->pDrv, idScreen, NULL /*pHostFlags*/);
             }
             else
             {
                 /* Restore the text mode backup. */
-                memcpy(pThis->vram_ptrR3, pThis->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
-
-                pThis->pDrv->pfnLFBModeChange(pThis->pDrv, false);
+                memcpy(pThisCC->pbVRam, pThis->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
+
+                pThisCC->pDrv->pfnLFBModeChange(pThisCC->pDrv, false);
 
                 /* Enable dirty page tracking again when going into legacy mode. */
-                vmsvgaR3SetTraces(pThis, true);
+                vmsvgaR3SetTraces(pDevIns, pThis, true);
 
                 /* bird: Whatever this is was added to make screenshot work, ask sunlover should explain... */
                 for (uint32_t idScreen = 0; idScreen < pThis->cMonitors; ++idScreen)
-                    pThis->pDrv->pfnVBVADisable(pThis->pDrv, idScreen);
+                    pThisCC->pDrv->pfnVBVADisable(pThisCC->pDrv, idScreen);
 
                 /* Clear the pitch lock. */
@@ -1683 +1691 @@
             if (!pThis->svga.fConfigured)
                 pThis->svga.fTraces = true;
-            vmsvgaR3SetTraces(pThis, !!pThis->svga.fTraces);
+            vmsvgaR3SetTraces(pDevIns, pThis, !!pThis->svga.fTraces);
 #else
             rc = VINF_IOM_R3_IOPORT_WRITE;
@@ -1735 +1743 @@
             {
                 Log(("SVGA_REG_IRQMASK: Trigger interrupt with status %x\n", pThis->svga.u32IrqStatus));
-                PDMDevHlpPCISetIrqNoWait(pThis->CTX_SUFF(pDevIns), 0, 1);
+                PDMDevHlpPCISetIrqNoWait(pDevIns, 0, 1);
             }
             else
-                PDMDevHlpPCISetIrqNoWait(pThis->CTX_SUFF(pDevIns), 0, 0);
+                PDMDevHlpPCISetIrqNoWait(pDevIns, 0, 0);
             break;
 
@@ -1814 +1822 @@
                 /* Read descriptor. */
                 SVGAGuestMemDescriptor desc;
-                rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhys, &desc, sizeof(desc));
+                rc = PDMDevHlpPhysRead(pDevIns, GCPhys, &desc, sizeof(desc));
                 AssertRCBreak(VBOXSTRICTRC_VAL(rc));
 
@@ -1873 +1881 @@
 
 #ifdef IN_RING3
-            vmsvgaR3SetTraces(pThis, !!u32);
+            vmsvgaR3SetTraces(pDevIns, pThis, !!u32);
 #else
             rc = VINF_IOM_R3_IOPORT_WRITE;
@@ -1958 +1966 @@
 DECLCALLBACK(VBOXSTRICTRC) vmsvgaIORead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
 {
-    PVGASTATE   pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     RT_NOREF_PV(pvUser);
 
@@ -2002 +2010 @@
 DECLCALLBACK(VBOXSTRICTRC) vmsvgaIOWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
 {
-    PVGASTATE   pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     RT_NOREF_PV(pvUser);
 
@@ -2014 +2023 @@
 
             case SVGA_VALUE_PORT:
-                return vmsvgaWritePort(pDevIns, pThis, u32);
+                return vmsvgaWritePort(pDevIns, pThis, pThisCC, u32);
 
             case SVGA_BIOS_PORT:
@@ -2048 +2057 @@
  * @returns VBox status code.
  * @param   pVM             VM handle.
- * @param   pThis           VGA device instance data.
+ * @param   pThis           The shared VGA/VMSVGA instance data.
  * @param   GCPhys          The access physical address.
  * @param   fWriteAccess    Read or write access
@@ -2497 +2506 @@
 static DECLCALLBACK(int) vmsvgaR3RegisterGmr(PPDMDEVINS pDevIns, uint32_t gmrId)
 {
-    PVGASTATE       pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
     PGMR pGMR = &pSVGAState->paGMR[gmrId];
@@ -2504 +2513 @@
     for (uint32_t i = 0; i < pGMR->numDescriptors; i++)
     {
-        rc = PGMHandlerPhysicalRegister(PDMDevHlpGetVM(pThis->pDevInsR3),
+        rc = PGMHandlerPhysicalRegister(PDMDevHlpGetVM(pDevIns),
                                         pGMR->paDesc[i].GCPhys, pGMR->paDesc[i].GCPhys + pGMR->paDesc[i].numPages * PAGE_SIZE - 1,
                                         pThis->svga.hGmrAccessHandlerType, pThis, NIL_RTR0PTR, NIL_RTRCPTR, "VMSVGA GMR");
@@ -2515 +2524 @@
 static DECLCALLBACK(int) vmsvgaR3DeregisterGmr(PPDMDEVINS pDevIns, uint32_t gmrId)
 {
-    PVGASTATE       pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
     PGMR pGMR = &pSVGAState->paGMR[gmrId];
@@ -2521 +2530 @@
     for (uint32_t i = 0; i < pGMR->numDescriptors; i++)
     {
-        int rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pThis->pDevInsR3), pGMR->paDesc[i].GCPhys);
+        int rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns), pGMR->paDesc[i].GCPhys);
         AssertRC(rc);
     }
@@ -2540 +2549 @@
             for (uint32_t j = 0; j < pGMR->numDescriptors; j++)
             {
-                int rc = PGMHandlerPhysicalReset(PDMDevHlpGetVM(pThis->pDevInsR3), pGMR->paDesc[j].GCPhys);
+                int rc = PGMHandlerPhysicalReset(PDMDevHlpGetVM(pDevIns), pGMR->paDesc[j].GCPhys);
                 AssertRC(rc);
             }
@@ -2559 +2568 @@
  * Common worker for changing the pointer shape.
  *
- * @param   pThis               The VGA instance data.
+ * @param   pThisCC             The VGA/VMSVGA state for ring-3.
  * @param   pSVGAState          The VMSVGA ring-3 instance data.
  * @param   fAlpha              Whether there is alpha or not.
@@ -2569 +2578 @@
  * @param   cbData              The size of the data.
  */
-static void vmsvgaR3InstallNewCursor(PVGASTATE pThis, PVMSVGAR3STATE pSVGAState, bool fAlpha,
+static void vmsvgaR3InstallNewCursor(PVGASTATECC pThisCC, PVMSVGAR3STATE pSVGAState, bool fAlpha,
                                      uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy, uint8_t *pbData, uint32_t cbData)
 {
@@ -2616 +2625 @@
 # endif
 
-    int rc = pThis->pDrv->pfnVBVAMousePointerShape(pThis->pDrv, true /*fVisible*/, fAlpha, xHot, yHot, cx, cy, pbData);
+    int rc = pThisCC->pDrv->pfnVBVAMousePointerShape(pThisCC->pDrv, true /*fVisible*/, fAlpha, xHot, yHot, cx, cy, pbData);
     AssertRC(rc);
 
@@ -2635 +2644 @@
  * Handles the SVGA_CMD_DEFINE_CURSOR command.
  *
- * @param   pThis               The VGA instance data.
+ * @param   pThis               The shared VGA/VMSVGA state.
+ * @param   pThisCC             The VGA/VMSVGA state for ring-3.
  * @param   pSVGAState          The VMSVGA ring-3 instance data.
  * @param   pCursor             The cursor.
@@ -2643 +2653 @@
  * @param   cbSrcXorLine        The scanline length of the XOR mask.
  */
-static void vmsvgaR3CmdDefineCursor(PVGASTATE pThis, PVMSVGAR3STATE pSVGAState, SVGAFifoCmdDefineCursor const *pCursor,
+static void vmsvgaR3CmdDefineCursor(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGAR3STATE pSVGAState,
+                                    SVGAFifoCmdDefineCursor const *pCursor,
                                     uint8_t const *pbSrcAndMask, uint32_t cbSrcAndLine,
                                     uint8_t const *pbSrcXorMask, uint32_t cbSrcXorLine)
@@ -2874 +2885 @@
      * Pass it to the frontend/whatever.
      */
-    vmsvgaR3InstallNewCursor(pThis, pSVGAState, false /*fAlpha*/, pCursor->hotspotX, pCursor->hotspotY, cx, cy, pbCopy, cbCopy);
+    vmsvgaR3InstallNewCursor(pThisCC, pSVGAState, false /*fAlpha*/, pCursor->hotspotX, pCursor->hotspotY, cx, cy, pbCopy, cbCopy);
 }
 
@@ -2881 +2892 @@
  * Worker for vmsvgaR3FifoThread that handles an external command.
  *
- * @param   pThis           VGA device instance data.
+ * @param   pDevIns         The device instance.
+ * @param   pThis           The shared VGA/VMSVGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  */
-static void vmsvgaR3FifoHandleExtCmd(PVGASTATE pThis)
+static void vmsvgaR3FifoHandleExtCmd(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
 {
     uint8_t uExtCmd = pThis->svga.u8FIFOExtCommand;
@@ -2917 +2930 @@
             PSSMHANDLE pSSM = (PSSMHANDLE)pThis->svga.pvFIFOExtCmdParam;
             AssertLogRelMsgBreak(RT_VALID_PTR(pSSM), ("pSSM=%p\n", pSSM));
-            vmsvgaR3SaveExecFifo(pThis->pDevInsR3->pHlpR3, pThis, pSSM);
+            vmsvgaR3SaveExecFifo(pDevIns->pHlpR3, pThis, pSSM);
 # ifdef VBOX_WITH_VMSVGA3D
             if (pThis->svga.f3DEnabled)
-                vmsvga3dSaveExec(pThis->pDevInsR3, pThis, pSSM);
+                vmsvga3dSaveExec(pDevIns, pThis, pSSM);
 # endif
             break;
@@ -2930 +2943 @@
             PVMSVGA_STATE_LOAD pLoadState = (PVMSVGA_STATE_LOAD)pThis->svga.pvFIFOExtCmdParam;
             AssertLogRelMsgBreak(RT_VALID_PTR(pLoadState), ("pLoadState=%p\n", pLoadState));
-            vmsvgaR3LoadExecFifo(pThis->pDevInsR3->pHlpR3, pThis, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
+            vmsvgaR3LoadExecFifo(pDevIns->pHlpR3, pThis, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
 # ifdef VBOX_WITH_VMSVGA3D
             if (pThis->svga.f3DEnabled)
-                vmsvga3dLoadExec(pThis->pDevInsR3, pThis, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
+                vmsvga3dLoadExec(pDevIns, pThis, pThisCC, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
 # endif
             break;
@@ -2970 +2983 @@
  * @returns VBox status code (fully asserted).
  * @param   pDevIns         The device instance.
- * @param   pThis           VGA device instance data.
+ * @param   pThis           The shared VGA/VMSVGA instance data.
  * @param   uExtCmd         The command to execute on the FIFO thread.
  * @param   pvParam         Pointer to command parameters.
@@ -3064 +3077 @@
  * Marks the FIFO non-busy, notifying any waiting EMTs.
  *
- * @param   pThis           The VGA state.
+ * @param   pDevIns         The device instance.
+ * @param   pThis           The shared VGA/VMSVGA instance data.
  * @param   pSVGAState      Pointer to the ring-3 only SVGA state data.
  * @param   offFifoMin      The start byte offset of the command FIFO.
  */
-static void vmsvgaR3FifoSetNotBusy(PVGASTATE pThis, PVMSVGAR3STATE pSVGAState, uint32_t offFifoMin)
+static void vmsvgaR3FifoSetNotBusy(PPDMDEVINS pDevIns, PVGASTATE pThis, PVMSVGAR3STATE pSVGAState, uint32_t offFifoMin)
 {
     ASMAtomicAndU32(&pThis->svga.fBusy, ~VMSVGA_BUSY_F_FIFO);
@@ -3078 +3092 @@
     {
 # ifdef VMSVGA_USE_EMT_HALT_CODE
-        PVM pVM = PDMDevHlpGetVM(pThis->pDevInsR3);
+        PVM pVM = PDMDevHlpGetVM(pDevIns);
         VMCPUID idCpu = VMCpuSetFindLastPresentInternal(&pSVGAState->BusyDelayedEmts);
         if (idCpu != NIL_VMCPUID)
@@ -3111 +3125 @@
  *                          buffer. (We will NEVER re-read anything.)
  * @param   pThread         The calling PDM thread handle.
- * @param   pThis           The VGA state.
+ * @param   pThis           The shared VGA/VMSVGA instance data.
  * @param   pSVGAState      Pointer to the ring-3 only SVGA state data. For
  *                          statistics collection.
@@ -3258 +3272 @@
  */
 static uint32_t
-vmsvgaR3FifoUpdateCursor(PVGASTATE pVGAState, PVMSVGAR3STATE  pSVGAState, uint32_t RT_UNTRUSTED_VOLATILE_GUEST *pFIFO,
+vmsvgaR3FifoUpdateCursor(PVGASTATECC pThisCC, PVMSVGAR3STATE  pSVGAState, uint32_t RT_UNTRUSTED_VOLATILE_GUEST *pFIFO,
                          uint32_t offFifoMin,  uint32_t uCursorUpdateCount,
                          uint32_t *pxLast, uint32_t *pyLast, uint32_t *pfLastVisible)
@@ -3308 +3322 @@
             LogRel2(("vmsvgaR3FifoUpdateCursor: fVisible %d fLastVisible %d (%d,%d)\n", fVisible, *pfLastVisible, x, y));
             *pfLastVisible = fVisible;
-            pVGAState->pDrv->pfnVBVAMousePointerShape(pVGAState->pDrv, RT_BOOL(fVisible), false, 0, 0, 0, 0, NULL);
+            pThisCC->pDrv->pfnVBVAMousePointerShape(pThisCC->pDrv, RT_BOOL(fVisible), false, 0, 0, 0, 0, NULL);
             STAM_REL_COUNTER_INC(&pSVGAState->StatFifoCursorVisiblity);
         }
-        pVGAState->pDrv->pfnVBVAReportCursorPosition(pVGAState->pDrv, fFlags, idScreen, x, y);
+        pThisCC->pDrv->pfnVBVAReportCursorPosition(pThisCC->pDrv, fFlags, idScreen, x, y);
         STAM_REL_COUNTER_INC(&pSVGAState->StatFifoCursorPosition);
     }
@@ -3347 +3361 @@
  * Called by the VGA refresh timer to wake up the FIFO thread when needed.
  *
- * @param   pThis   The VGA state.
+ * @param   pThis   The shared VGA/VMSVGA instance data.
  */
 void vmsvgaR3FifoWatchdogTimer(PPDMDEVINS pDevIns, PVGASTATE pThis)
@@ -3370 +3384 @@
 static DECLCALLBACK(int) vmsvgaR3FifoLoop(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    PVGASTATE       pThis = (PVGASTATE)pThread->pvUser;
+    PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATER3     pThisCC    = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
     int             rc;
@@ -3384 +3399 @@
     if (pThis->svga.fFifoExtCommandWakeup)
     {
-        vmsvgaR3FifoHandleExtCmd(pThis);
+        vmsvgaR3FifoHandleExtCmd(pDevIns, pThis, pThisCC);
         while (pThread->enmState == PDMTHREADSTATE_RUNNING)
             if (pThis->svga.u8FIFOExtCommand == VMSVGA_FIFO_EXTCMD_NONE)
                 PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pThis->svga.hFIFORequestSem, RT_MS_1MIN);
             else
-                vmsvgaR3FifoHandleExtCmd(pThis);
+                vmsvgaR3FifoHandleExtCmd(pDevIns, pThis, pThisCC);
         return VINF_SUCCESS;
     }
@@ -3515 +3530 @@
         if (pThis->svga.u8FIFOExtCommand != VMSVGA_FIFO_EXTCMD_NONE)
         {
-            vmsvgaR3FifoHandleExtCmd(pThis);
+            vmsvgaR3FifoHandleExtCmd(pDevIns, pThis, pThisCC);
             continue;
         }
@@ -3525 +3540 @@
             || !pThis->svga.fConfigured)
         {
-            vmsvgaR3FifoSetNotBusy(pThis, pSVGAState, pFIFO[SVGA_FIFO_MIN]);
+            vmsvgaR3FifoSetNotBusy(pDevIns, pThis, pSVGAState, pFIFO[SVGA_FIFO_MIN]);
             fBadOrDisabledFifo = true;
             cMsSleep           = cMsMaxSleep; /* cheat */
@@ -3551 +3566 @@
             STAM_REL_COUNTER_INC(&pSVGAState->StatFifoErrors);
             LogRelMax(8, ("vmsvgaR3FifoLoop: Bad fifo: min=%#x stop=%#x max=%#x\n", offFifoMin, offCurrentCmd, offFifoMax));
-            vmsvgaR3FifoSetNotBusy(pThis, pSVGAState, offFifoMin);
+            vmsvgaR3FifoSetNotBusy(pDevIns, pThis, pSVGAState, offFifoMin);
             fBadOrDisabledFifo = true;
             continue;
@@ -3574 +3589 @@
             else
             {
-                uint32_t const uLastCursorCount = vmsvgaR3FifoUpdateCursor(pThis, pSVGAState, pFIFO, offFifoMin, uCursorUpdateCount,
-                                                                         &xLastCursor, &yLastCursor, &fLastCursorVisible);
-                ASMAtomicWriteU32(&pThis->svga.uLastCursorUpdateCount, uLastCursorCount);
+                uint32_t const uNewCount = vmsvgaR3FifoUpdateCursor(pThisCC, pSVGAState, pFIFO, offFifoMin, uCursorUpdateCount,
+                                                                    &xLastCursor, &yLastCursor, &fLastCursorVisible);
+                ASMAtomicWriteU32(&pThis->svga.uLastCursorUpdateCount, uNewCount);
             }
         }
@@ -3637 +3652 @@
             if (ASMBitTestAndClear(&pThis->svga.u32ActionFlags, VMSVGA_ACTION_CHANGEMODE_BIT))
             {
-                vmsvgaR3ChangeMode(pThis);
+                vmsvgaR3ChangeMode(pThis, pThisCC);
 # ifdef VBOX_WITH_VMSVGA3D
                 if (pThis->svga.p3dState != NULL)
@@ -3703 +3718 @@
                 VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThis, 0);
                 AssertBreak(pScreen);
-                vmsvgaR3UpdateScreen(pThis, pScreen, pUpdate->x, pUpdate->y, pUpdate->width, pUpdate->height);
+                vmsvgaR3UpdateScreen(pThisCC, pScreen, pUpdate->x, pUpdate->y, pUpdate->width, pUpdate->height);
                 break;
             }
@@ -3728 +3743 @@
                 VMSVGAFIFO_GET_MORE_CMD_BUFFER_BREAK(pCursor, SVGAFifoCmdDefineCursor, sizeof(*pCursor) + cbAndMask + cbXorMask);
 
-                vmsvgaR3CmdDefineCursor(pThis, pSVGAState, pCursor, (uint8_t const *)(pCursor + 1), cbAndLine,
+                vmsvgaR3CmdDefineCursor(pThis, pThisCC, pSVGAState, pCursor, (uint8_t const *)(pCursor + 1), cbAndLine,
                                         (uint8_t const *)(pCursor + 1) + cbAndMask, cbXorLine);
                 break;
@@ -3768 +3783 @@
                 memcpy(pCursorCopy + cbAndMask, (pCursor + 1), pCursor->width * pCursor->height * sizeof(uint32_t));
 
-                vmsvgaR3InstallNewCursor(pThis, pSVGAState, true /*fAlpha*/, pCursor->hotspotX, pCursor->hotspotY,
+                vmsvgaR3InstallNewCursor(pThisCC, pSVGAState, true /*fAlpha*/, pCursor->hotspotX, pCursor->hotspotY,
                                          pCursor->width, pCursor->height, pCursorCopy, cbCursorShape);
                 break;
@@ -4017 +4032 @@
 
 #  ifdef DEBUG_GMR_ACCESS
-                VMR3ReqCallWaitU(PDMDevHlpGetUVM(pThis->pDevInsR3), VMCPUID_ANY, (PFNRT)vmsvgaR3RegisterGmr, 2, pThis->pDevInsR3, pCmd->gmrId);
+                VMR3ReqCallWaitU(PDMDevHlpGetUVM(pDevIns), VMCPUID_ANY, (PFNRT)vmsvgaR3RegisterGmr, 2, pDevIns, pCmd->gmrId);
 #  endif
                 break;
@@ -4088 +4103 @@
 
                 pThis->svga.fGFBRegisters = false;
-                vmsvgaR3ChangeMode(pThis);
+                vmsvgaR3ChangeMode(pThis, pThisCC);
                 break;
             }
@@ -4109 +4124 @@
                 pScreen->idScreen  = idScreen;
 
-                vmsvgaR3ChangeMode(pThis);
+                vmsvgaR3ChangeMode(pThis, pThisCC);
                 break;
             }
@@ -4172 +4187 @@
                  * Important are pbHstBuf and cbHstBuf. offHst and cbHstPitch are verified by vmsvgaR3GmrTransfer.
                  */
-                uint8_t * const pbHstBuf = (uint8_t *)pThis->CTX_SUFF(vram_ptr) + pScreen->offVRAM;
+                uint8_t * const pbHstBuf = (uint8_t *)pThisCC->pbVRam + pScreen->offVRAM;
                 uint32_t const cbScanline = pScreen->cbPitch ? pScreen->cbPitch :
                                                                width * (RT_ALIGN(pScreen->cBpp, 8) / 8);
@@ -4188 +4203 @@
                 int32_t const cbGstPitch = pSVGAState->GMRFB.bytesPerLine;
 
-                rc = vmsvgaR3GmrTransfer(pThis, SVGA3D_WRITE_HOST_VRAM,
-                                       pbHstBuf, cbHstBuf, offHst, cbHstPitch,
-                                       gstPtr, offGst, cbGstPitch,
-                                       (width * RT_ALIGN(pScreen->cBpp, 8)) / 8, height);
+                rc = vmsvgaR3GmrTransfer(pThis, pThisCC, SVGA3D_WRITE_HOST_VRAM,
+                                         pbHstBuf, cbHstBuf, offHst, cbHstPitch,
+                                         gstPtr, offGst, cbGstPitch,
+                                         (width * RT_ALIGN(pScreen->cBpp, 8)) / 8, height);
                 AssertRC(rc);
-                vmsvgaR3UpdateScreen(pThis, pScreen, clipRect.left, clipRect.top, width, height);
+                vmsvgaR3UpdateScreen(pThisCC, pScreen, clipRect.left, clipRect.top, width, height);
                 break;
             }
@@ -4244 +4259 @@
                  * Important are pbHstBuf and cbHstBuf. offHst and cbHstPitch are verified by vmsvgaR3GmrTransfer.
                  */
-                uint8_t * const pbHstBuf = (uint8_t *)pThis->CTX_SUFF(vram_ptr) + pScreen->offVRAM;
+                uint8_t * const pbHstBuf = (uint8_t *)pThisCC->pbVRam + pScreen->offVRAM;
                 uint32_t const cbScanline = pScreen->cbPitch ? pScreen->cbPitch :
                                                                width * (RT_ALIGN(pScreen->cBpp, 8) / 8);
@@ -4260 +4275 @@
                 int32_t const cbGstPitch = pSVGAState->GMRFB.bytesPerLine;
 
-                rc = vmsvgaR3GmrTransfer(pThis, SVGA3D_READ_HOST_VRAM,
+                rc = vmsvgaR3GmrTransfer(pThis, pThisCC, SVGA3D_READ_HOST_VRAM,
                                          pbHstBuf, cbHstBuf, offHst, cbHstPitch,
                                          gstPtr, offGst, cbGstPitch,
@@ -4336 +4351 @@
                                                    SVGA3D_TEX_FILTER_NONE, cMipLevels, (SVGA3dSize *)(pCmd + 1));
 #  ifdef DEBUG_GMR_ACCESS
-                        VMR3ReqCallWaitU(PDMDevHlpGetUVM(pThis->pDevInsR3), VMCPUID_ANY, (PFNRT)vmsvgaR3ResetGmrHandlers, 1, pThis);
+                        VMR3ReqCallWaitU(PDMDevHlpGetUVM(pDevIns), VMCPUID_ANY, (PFNRT)vmsvgaR3ResetGmrHandlers, 1, pThis);
 #  endif
                         break;
@@ -4395 +4410 @@
                         cCopyBoxes = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dCopyBox);
                         STAM_PROFILE_START(&pSVGAState->StatR3Cmd3dSurfaceDmaProf, a);
-                        rc = vmsvga3dSurfaceDMA(pThis, pCmd->guest, pCmd->host, pCmd->transfer, cCopyBoxes, (SVGA3dCopyBox *)(pCmd + 1));
+                        rc = vmsvga3dSurfaceDMA(pThis, pThisCC, pCmd->guest, pCmd->host, pCmd->transfer,
+                                                cCopyBoxes, (SVGA3dCopyBox *)(pCmd + 1));
                         STAM_PROFILE_STOP(&pSVGAState->StatR3Cmd3dSurfaceDmaProf, a);
                         break;
@@ -4408 +4424 @@
 
                         cRects = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGASignedRect);
-                        rc = vmsvga3dSurfaceBlitToScreen(pThis, pCmd->destScreenId, pCmd->destRect, pCmd->srcImage, pCmd->srcRect, cRects, (SVGASignedRect *)(pCmd + 1));
+                        rc = vmsvga3dSurfaceBlitToScreen(pThis, pThisCC, pCmd->destScreenId, pCmd->destRect, pCmd->srcImage,
+                                                         pCmd->srcRect, cRects, (SVGASignedRect *)(pCmd + 1));
                         break;
                     }
@@ -4560 +4577 @@
 
                         STAM_PROFILE_START(&pSVGAState->StatR3Cmd3dPresentProf, a);
-                        rc = vmsvga3dCommandPresent(pThis, pCmd->sid, cRects, (SVGA3dCopyRect *)(pCmd + 1));
+                        rc = vmsvga3dCommandPresent(pThis, pThisCC, pCmd->sid, cRects, (SVGA3dCopyRect *)(pCmd + 1));
                         STAM_PROFILE_STOP(&pSVGAState->StatR3Cmd3dPresentProf, a);
                         break;
@@ -4671 +4688 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dWaitForQuery);
 
-                        rc = vmsvga3dQueryWait(pThis, pCmd->cid, pCmd->type, pCmd->guestResult);
+                        rc = vmsvga3dQueryWait(pThis, pThisCC, pCmd->cid, pCmd->type, pCmd->guestResult);
                         break;
                     }
@@ -4754 +4771 @@
         {
             Log(("vmsvgaR3FifoLoop: emptied the FIFO next=%x stop=%x\n", pFIFO[SVGA_FIFO_NEXT_CMD], offCurrentCmd));
-            vmsvgaR3FifoSetNotBusy(pThis, pSVGAState, offFifoMin);
+            vmsvgaR3FifoSetNotBusy(pDevIns, pThis, pSVGAState, offFifoMin);
         }
     }
@@ -4769 +4786 @@
  * Free the specified GMR
  *
- * @param   pThis           VGA device instance data.
+ * @param   pThis           The shared VGA/VMSVGA instance data.
  * @param   idGMR           GMR id
  */
@@ -4782 +4799 @@
     {
 # ifdef DEBUG_GMR_ACCESS
-        VMR3ReqCallWaitU(PDMDevHlpGetUVM(pThis->pDevInsR3), VMCPUID_ANY, (PFNRT)vmsvgaR3DeregisterGmr, 2, pThis->pDevInsR3, idGMR);
+        VMR3ReqCallWaitU(PDMDevHlpGetUVM(pDevIns), VMCPUID_ANY, (PFNRT)vmsvgaR3DeregisterGmr, 2, pDevIns, idGMR);
 # endif
 
@@ -4800 +4817 @@
  *
  * @returns VBox status code.
- * @param   pThis           VGA device instance data.
+ * @param   pThis           The shared VGA/VMSVGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  * @param   enmTransferType Transfer type (read/write)
  * @param   pbHstBuf        Host buffer pointer (valid)
@@ -4812 +4830 @@
  * @param   cHeight         Number of scanllines to copy
  */
-int vmsvgaR3GmrTransfer(PVGASTATE pThis, const SVGA3dTransferType enmTransferType,
+int vmsvgaR3GmrTransfer(PVGASTATE pThis, PVGASTATECC pThisCC, const SVGA3dTransferType enmTransferType,
                         uint8_t *pbHstBuf, uint32_t cbHstBuf, uint32_t offHst, int32_t cbHstPitch,
                         SVGAGuestPtr gstPtr, uint32_t offGst, int32_t cbGstPitch,
                         uint32_t cbWidth, uint32_t cHeight)
 {
-    PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
-    int            rc;
+    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PPDMDEVINS      pDevIns = pThisCC->pDevIns; /* simpler */
+    int             rc;
 
     LogFunc(("%s host %p size=%d offset %d pitch=%d; guest gmr=%#x:%#x offset=%d pitch=%d cbWidth=%d cHeight=%d\n",
@@ -4937 +4956 @@
     if (gstPtr.gmrId == SVGA_GMR_FRAMEBUFFER)
     {
-        uint8_t *pbGst = pThis->CTX_SUFF(vram_ptr) + offGmr;
+        uint8_t *pbGst = pThisCC->pbVRam + offGmr;
 
         uint8_t const *pbSrc;
@@ -5020 +5039 @@
 
             if (enmTransferType == SVGA3D_WRITE_HOST_VRAM)
-                rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhys, pbCurrentHost, cbToCopy);
+                rc = PDMDevHlpPhysRead(pDevIns, GCPhys, pbCurrentHost, cbToCopy);
             else
-                rc = PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), GCPhys, pbCurrentHost, cbToCopy);
+                rc = PDMDevHlpPhysWrite(pDevIns, GCPhys, pbCurrentHost, cbToCopy);
             AssertRCBreak(rc);
 
@@ -5197 +5216 @@
  * Enables or disables dirty page tracking for the framebuffer
  *
- * @param   pThis           VGA device instance data.
+ * @param   pDevIns         The device instance.
+ * @param   pThis           The shared VGA/VMSVGA instance data.
  * @param   fTraces         Enable/disable traces
  */
-static void vmsvgaR3SetTraces(PVGASTATE pThis, bool fTraces)
+static void vmsvgaR3SetTraces(PPDMDEVINS pDevIns, PVGASTATE pThis, bool fTraces)
 {
     if (    (!pThis->svga.fConfigured || !pThis->svga.fEnabled)
@@ -5230 +5250 @@
         {
             Log(("vmsvgaR3SetTraces: enable frame buffer dirty page tracking. (%x bytes; vram %x)\n", cbFrameBuffer, pThis->vram_size));
-            vgaR3RegisterVRAMHandler(pThis, cbFrameBuffer);
+            vgaR3RegisterVRAMHandler(pDevIns, pThis, cbFrameBuffer);
             pThis->svga.fVRAMTracking = true;
         }
@@ -5239 +5259 @@
         {
             Log(("vmsvgaR3SetTraces: disable frame buffer dirty page tracking\n"));
-            vgaR3UnregisterVRAMHandler(pThis);
+            vgaR3UnregisterVRAMHandler(pDevIns, pThis);
             pThis->svga.fVRAMTracking = false;
         }
@@ -5251 +5271 @@
                                                   RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
 {
-    PVGASTATE   pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     int         rc;
     RT_NOREF(pPciDev);
@@ -5309 +5329 @@
  *
  * @param   pDevIns             The device instance.
- * @param   pThis               The VGA device instance data.
+ * @param   pThis               The The shared VGA/VMSVGA instance data.
  * @param   sid                 Either UINT32_MAX or the ID of a specific
  *                              surface.  If UINT32_MAX is used, all surfaces
@@ -5361 +5381 @@
         fInvY = true;
 
-    vmsvga3dInfoSurfaceWorker(pDevIns, PDMINS_2_DATA(pDevIns, PVGASTATE), pHlp, sid, fVerbose, cxAscii, fInvY, NULL);
+    vmsvga3dInfoSurfaceWorker(pDevIns, PDMDEVINS_2_DATA(pDevIns, PVGASTATE), pHlp, sid, fVerbose, cxAscii, fInvY, NULL);
 }
 
@@ -5386 +5406 @@
     const uint32_t cxAscii = 0; /* No ASCII */
     const bool fInvY = false;   /* Do not invert. */
-    vmsvga3dInfoSurfaceWorker(pDevIns, PDMINS_2_DATA(pDevIns, PVGASTATE), pHlp, sid, fVerbose, cxAscii, fInvY, pszBitmapPath);
+    vmsvga3dInfoSurfaceWorker(pDevIns, PDMDEVINS_2_DATA(pDevIns, PVGASTATE), pHlp, sid, fVerbose, cxAscii, fInvY, pszBitmapPath);
 }
 
@@ -5408 +5428 @@
         fVerbose = false;
 
-    vmsvga3dInfoContextWorker(PDMINS_2_DATA(pDevIns, PVGASTATE), pHlp, sid, fVerbose);
+    vmsvga3dInfoContextWorker(PDMDEVINS_2_DATA(pDevIns, PVGASTATE), pHlp, sid, fVerbose);
 }
 
@@ -5418 +5438 @@
 static DECLCALLBACK(void) vmsvgaR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    RT_NOREF(pszArgs);
-    PVGASTATE       pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC    = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
     uint32_t RT_UNTRUSTED_VOLATILE_GUEST *pFIFO = pThis->svga.pFIFOR3;
+    RT_NOREF(pszArgs);
 
     pHlp->pfnPrintf(pHlp, "Extension enabled:  %RTbool\n", pThis->svga.fEnabled);
@@ -5457 +5478 @@
     pHlp->pfnPrintf(pHlp, "3D enabled:         %RTbool\n", pThis->svga.f3DEnabled);
 # endif
-    if (pThis->pDrv)
-    {
-        pHlp->pfnPrintf(pHlp, "Driver mode:        %ux%u %ubpp\n", pThis->pDrv->cx, pThis->pDrv->cy, pThis->pDrv->cBits);
-        pHlp->pfnPrintf(pHlp, "Driver pitch:       %u (%#x)\n", pThis->pDrv->cbScanline, pThis->pDrv->cbScanline);
+    if (pThisCC->pDrv)
+    {
+        pHlp->pfnPrintf(pHlp, "Driver mode:        %ux%u %ubpp\n", pThisCC->pDrv->cx, pThisCC->pDrv->cy, pThisCC->pDrv->cBits);
+        pHlp->pfnPrintf(pHlp, "Driver pitch:       %u (%#x)\n", pThisCC->pDrv->cbScanline, pThisCC->pDrv->cbScanline);
     }
 }
@@ -5529 +5550 @@
 {
     RT_NOREF(uPass);
-    PVGASTATE       pThis      = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
     PCPDMDEVHLPR3   pHlp       = pDevIns->pHlpR3;
@@ -5616 +5637 @@
 
 #  ifdef RT_OS_DARWIN  /** @todo r=bird: this is normally done on the EMT, so for DARWIN we do that when loading saved state too now. See DevVGA-SVGA3d-shared.h. */
-    vmsvga3dPowerOn(pThis);
+    vmsvga3dPowerOn(pDevIns, pThis, pThisCC);
 #  endif
 
@@ -5634 +5655 @@
 int vmsvgaR3LoadDone(PPDMDEVINS pDevIns)
 {
-    PVGASTATE       pThis      = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC    = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
 
@@ -5642 +5664 @@
     if (pSVGAState->Cursor.fActive)
     {
-        int rc;
-
-        rc = pThis->pDrv->pfnVBVAMousePointerShape(pThis->pDrv,
-                                                   true,
-                                                   true,
-                                                   pSVGAState->Cursor.xHotspot,
-                                                   pSVGAState->Cursor.yHotspot,
-                                                   pSVGAState->Cursor.width,
-                                                   pSVGAState->Cursor.height,
-                                                   pSVGAState->Cursor.pData);
+        int rc = pThisCC->pDrv->pfnVBVAMousePointerShape(pThisCC->pDrv,
+                                                         true /*fVisible*/,
+                                                         true /*fAlpha*/,
+                                                         pSVGAState->Cursor.xHotspot,
+                                                         pSVGAState->Cursor.yHotspot,
+                                                         pSVGAState->Cursor.width,
+                                                         pSVGAState->Cursor.height,
+                                                         pSVGAState->Cursor.pData);
         AssertRC(rc);
     }
@@ -5692 +5712 @@
 int vmsvgaR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
-    PVGASTATE       pThis      = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
     PCPDMDEVHLPR3   pHlp       = pDevIns->pHlpR3;
@@ -5991 +6011 @@
 int vmsvgaR3Reset(PPDMDEVINS pDevIns)
 {
-    PVGASTATE       pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
 
@@ -6043 +6063 @@
 int vmsvgaR3Destruct(PPDMDEVINS pDevIns)
 {
-    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
 
     /*
@@ -6099 +6119 @@
 int vmsvgaR3Init(PPDMDEVINS pDevIns)
 {
-    PVGASTATE       pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     PVMSVGAR3STATE  pSVGAState;
     int             rc;
@@ -6134 +6155 @@
     if (pThis->svga.f3DEnabled)
     {
-        rc = vmsvga3dInit(pThis);
+        rc = vmsvga3dInit(pDevIns, pThis, pThisCC);
         if (RT_FAILURE(rc))
         {
@@ -6162 +6183 @@
 # ifdef DEBUG_GMR_ACCESS
     /* Register the GMR access handler type. */
-    rc = PGMR3HandlerPhysicalTypeRegister(PDMDevHlpGetVM(pThis->pDevInsR3), PGMPHYSHANDLERKIND_WRITE,
+    rc = PGMR3HandlerPhysicalTypeRegister(PDMDevHlpGetVM(pDevIns), PGMPHYSHANDLERKIND_WRITE,
                                           vmsvgaR3GmrAccessHandler,
                                           NULL, NULL, NULL,
@@ -6174 +6195 @@
        debugging FIFO access, this is also used to facilitate
        extended fifo thread sleeps. */
-    rc = PGMR3HandlerPhysicalTypeRegister(PDMDevHlpGetVM(pThis->pDevInsR3),
+    rc = PGMR3HandlerPhysicalTypeRegister(PDMDevHlpGetVM(pDevIns),
 #  ifdef DEBUG_FIFO_ACCESS
                                           PGMPHYSHANDLERKIND_ALL,
@@ -6395 +6416 @@
 {
 # ifdef VBOX_WITH_VMSVGA3D
-    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     if (pThis->svga.f3DEnabled)
     {
-        int rc = vmsvga3dPowerOn(pThis);
+        int rc = vmsvga3dPowerOn(pDevIns, pThis, pThisCC);
 
         if (RT_SUCCESS(rc))

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

@@ -359 +359 @@
 } VMSVGAState;
 
-typedef struct VGAState *PVGASTATE;
+typedef struct VGAState   *PVGASTATE;
+typedef struct VGASTATER3 *PVGASTATER3;
+typedef struct VGASTATER0 *PVGASTATER0;
+typedef struct VGASTATERC *PVGASTATERC;
+typedef CTX_SUFF(PVGASTATE) PVGASTATECC;
 
 DECLCALLBACK(int) vmsvgaR3PciIORegionFifoMapUnmap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
@@ -381 +385 @@
 #ifdef IN_RING3
 VMSVGASCREENOBJECT *vmsvgaR3GetScreenObject(PVGASTATE pThis, uint32_t idScreen);
-int vmsvgaR3UpdateScreen(PVGASTATE pThis, VMSVGASCREENOBJECT *pScreen, int x, int y, int w, int h);
+int vmsvgaR3UpdateScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen, int x, int y, int w, int h);
 #endif
 
 void vmsvgaR3GmrFree(PVGASTATE pThis, uint32_t idGMR);
-int vmsvgaR3GmrTransfer(PVGASTATE pThis, const SVGA3dTransferType enmTransferType,
+int vmsvgaR3GmrTransfer(PVGASTATE pThis, PVGASTATECC pThisCC, const SVGA3dTransferType enmTransferType,
                         uint8_t *pbHstBuf, uint32_t cbHstBuf, uint32_t offHst, int32_t cbHstPitch,
                         SVGAGuestPtr gstPtr, uint32_t offGst, int32_t cbGstPitch,

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-info.cpp

@@ -512 +512 @@
  * Updates the heap buffers for all surfaces or one specific one.
  *
- * @param   pThis               The VGA device instance data.
+ * @param   pThis               The shared VGA instance data.
  * @param   sid                 The surface ID, UINT32_MAX if all.
  * @thread  VMSVGAFIFO

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-internal.h

@@ -1228 +1228 @@
                                    PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcFace, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
                                    SVGA3dStretchBltMode enmMode, PVMSVGA3DCONTEXT pContext);
-int  vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
+int  vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
                                    PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
                                    SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-ogl.cpp

@@ -583 +583 @@
  *
  * @returns VBox status code.
- * @param   pThis   The VGA device state where svga.p3dState will be modified.
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The shared VGA/VMSVGA state where svga.p3dState will be
+ *                      modified.
+ * @param   pThisCC     The VGA/VMSVGA state for ring-3.
  */
-int vmsvga3dInit(PVGASTATE pThis)
+int vmsvga3dInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
 {
     int rc;
+    RT_NOREF(pThisCC);
 
     AssertCompile(GL_TRUE == 1);
@@ -593 +597 @@
 
 #ifdef VMSVGA3D_DYNAMIC_LOAD
-    rc = glLdrInit(pThis->pDevInsR3);
+    rc = glLdrInit(pDevIns);
     if (RT_FAILURE(rc))
     {
@@ -809 +813 @@
 
 /* We must delay window creation until the PowerOn phase. Init is too early and will cause failures. */
-int vmsvga3dPowerOn(PVGASTATE pThis)
+int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
 {
     PVMSVGA3DSTATE pState = pThis->svga.p3dState;
@@ -818 +822 @@
 #endif
     int              rc;
+    RT_NOREF(pDevIns, pThisCC);
 
     if (pState->rsGLVersion != 0.0)
@@ -833 +838 @@
 #ifdef VMSVGA3D_DYNAMIC_LOAD
     /* Context is set and it is possible now to resolve extension functions. */
-    rc = glLdrGetExtFunctions(pThis->pDevInsR3);
+    rc = glLdrGetExtFunctions(pDevIns);
     if (RT_FAILURE(rc))
     {
@@ -2812 +2817 @@
  *
  * @returns Failure status code or @a rc.
- * @param   pThis               The VGA device instance data.
+ * @param   pThis               The shared VGA instance data.
+ * @param   pThisCC             The VGA/VMSVGA state for ring-3.
  * @param   pState              The VMSVGA3d state.
  * @param   pSurface            The host surface.
@@ -2826 +2832 @@
  * @param   iBox                The current box number (for Direct 3D).
  */
-int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
+int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
                                   PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
                                   SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
@@ -2924 +2930 @@
 
         rc = vmsvgaR3GmrTransfer(pThis,
+                                 pThisCC,
                                  transfer,
                                  pDoubleBuffer,
@@ -3072 +3079 @@
 
                 rc = vmsvgaR3GmrTransfer(pThis,
+                                         pThisCC,
                                          transfer,
                                          pbData,
@@ -3200 +3208 @@
  *
  * @returns VBox status code.
- * @param   pThis           VGA device instance data.
+ * @param   pThis           The shared VGA instance data.
  * @param   cid             Context id
  * @param   fFlags          VMSVGA3D_DEF_CTX_F_XXX.
@@ -3435 +3443 @@
  *
  * @returns VBox status code.
- * @param   pThis           VGA device instance data.
+ * @param   pThis           The shared VGA instance data.
  * @param   cid             Context id
  */
@@ -3447 +3455 @@
  *
  * @returns VBox status code.
- * @param   pThis           VGA device instance data.
+ * @param   pThis           The shared VGA instance data.
  * @param   pContext        The context to destroy.
  * @param   cid             Context id
@@ -3545 +3553 @@
  *
  * @returns VBox status code.
- * @param   pThis           VGA device instance data.
+ * @param   pThis           The shared VGA instance data.
  * @param   cid             Context id
  */
@@ -3567 +3575 @@
  * Worker for vmsvga3dChangeMode that resizes a context.
  *
- * @param   pThis               The VGA device instance data.
+ * @param   pThis               The shared VGA instance data.
  * @param   pState              The VMSVGA3d state.
  * @param   pContext            The context.

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-savedstate.cpp

@@ -147 +147 @@
 }
 
-int vmsvga3dLoadExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
+int vmsvga3dLoadExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
 {
     RT_NOREF(uPass);
@@ -159 +159 @@
 #ifndef RT_OS_DARWIN /** @todo r=bird: this is normally done on the EMT, so for DARWIN we do that when loading saved state too now. See DevVGA-SVGA.cpp */
     /* Must initialize now as the recreation calls below rely on an initialized 3d subsystem. */
-    vmsvga3dPowerOn(pThis);
+    vmsvga3dPowerOn(pDevIns, pThis, pThisCC);
 #endif
 

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win.cpp

@@ -161 +161 @@
 
 
-int vmsvga3dInit(PVGASTATE pThis)
-{
+int vmsvga3dInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
+{
+    RT_NOREF(pDevIns, pThisCC);
+
     PVMSVGA3DSTATE pState;
-    int rc;
-
     pThis->svga.p3dState = pState = (PVMSVGA3DSTATE)RTMemAllocZ(sizeof(VMSVGA3DSTATE));
     AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
 
     /* Create event semaphore. */
-    rc = RTSemEventCreate(&pState->WndRequestSem);
+    int rc = RTSemEventCreate(&pState->WndRequestSem);
     if (RT_FAILURE(rc))
     {
@@ -188 +188 @@
 }
 
-int vmsvga3dPowerOn(PVGASTATE pThis)
+int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
 {
     PVMSVGA3DSTATE pState = pThis->svga.p3dState;
     AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
     HRESULT hr;
+    RT_NOREF(pDevIns, pThisCC);
 
     if (pState->pD3D9)
@@ -205 +206 @@
     PFNDIRECT3DCREATE9EX pfnDirect3dCreate9Ex = (PFNDIRECT3DCREATE9EX)RTLdrGetSystemSymbol("d3d9.dll", "Direct3DCreate9Ex");
     if (!pfnDirect3dCreate9Ex)
-        return PDMDevHlpVMSetError(pThis->CTX_SUFF(pDevIns), VERR_SYMBOL_NOT_FOUND, RT_SRC_POS,
+        return PDMDevHlpVMSetError(pDevIns, VERR_SYMBOL_NOT_FOUND, RT_SRC_POS,
                                    "vmsvga3d: Unable to locate Direct3DCreate9Ex. This feature requires Vista and later.");
     hr = pfnDirect3dCreate9Ex(D3D_SDK_VERSION, &pState->pD3D9);
@@ -2319 +2320 @@
  *
  * @returns Failure status code or @a rc.
- * @param   pThis               The VGA device instance data.
+ * @param   pThis               The shared VGA instance data.
+ * @param   pThisCC             The VGA/VMSVGA state for ring-3.
  * @param   pState              The VMSVGA3d state.
  * @param   pSurface            The host surface.
@@ -2333 +2335 @@
  * @param   iBox                The current box number (for Direct 3D).
  */
-int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
+int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
                                   PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
                                   SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
@@ -2414 +2416 @@
 
         rc = vmsvgaR3GmrTransfer(pThis,
+                                 pThisCC,
                                  transfer,
                                  pu8LockedBuf,
@@ -2481 +2484 @@
         /* Copy data between the guest and the host buffer. */
         rc = vmsvgaR3GmrTransfer(pThis,
+                                 pThisCC,
                                  transfer,
                                  (uint8_t *)pMipLevel->pSurfaceData,
@@ -2558 +2562 @@
  *
  * @returns VBox status code.
- * @param   pThis           VGA device instance data.
+ * @param   pThis           The shared VGA instance data.
  * @param   cid             Context id
  */
@@ -2656 +2660 @@
  *
  * @returns VBox status code.
- * @param   pThis           VGA device instance data.
+ * @param   pThis           The shared VGA instance data.
  * @param   cid             Context id
  */

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.cpp

@@ -46 +46 @@
  *
  * @returns VBox status code (currently ignored).
- * @param   pThis               The VGA device instance data.
+ * @param   pThis               The shared VGA instance data.
  * @param   sid                 The ID of the surface to (re-)define.
  * @param   surfaceFlags        .
@@ -330 +330 @@
  *
  * @returns VBox status code (currently ignored).
- * @param   pThis               The VGA device instance data.
+ * @param   pThis               The shared VGA instance data.
  * @param   sid                 The ID of the surface to destroy.
  */
@@ -379 +379 @@
  *
  * @returns VBox status code (currently ignored).
- * @param   pThis               The VGA device instance data.
+ * @param   pThis               The shared VGA instance data.
  * @param   pDstSfcImg
  * @param   pDstBox
@@ -472 +472 @@
  *
  * @returns VBox status code (currently ignored).
- * @param   pThis               The VGA device instance data.
+ * @param   pThis               The shared VGA instance data.
+ * @param   pThisCC             The VGA/VMSVGA state for ring-3.
  * @param   guest               .
  * @param   host                .
@@ -479 +480 @@
  * @param   paBoxes             .
  */
-int vmsvga3dSurfaceDMA(PVGASTATE pThis, SVGA3dGuestImage guest, SVGA3dSurfaceImageId host, SVGA3dTransferType transfer,
-                       uint32_t cCopyBoxes, SVGA3dCopyBox *paBoxes)
+int vmsvga3dSurfaceDMA(PVGASTATE pThis, PVGASTATECC pThisCC, SVGA3dGuestImage guest, SVGA3dSurfaceImageId host,
+                       SVGA3dTransferType transfer, uint32_t cCopyBoxes, SVGA3dCopyBox *paBoxes)
 {
     PVMSVGA3DSTATE pState = pThis->svga.p3dState;
@@ -629 +630 @@
             {
                 rc = vmsvgaR3GmrTransfer(pThis,
+                                         pThisCC,
                                          transfer,
                                          (uint8_t *)pMipLevel->pSurfaceData,
@@ -661 +663 @@
             clipBox.srcy = srcy;
             clipBox.srcz = srcz;
-            rc = vmsvga3dBackSurfaceDMACopyBox(pThis, pState, pSurface, pMipLevel, host.face, host.mipmap,
+            rc = vmsvga3dBackSurfaceDMACopyBox(pThis, pThisCC, pState, pSurface, pMipLevel, host.face, host.mipmap,
                                                guest.ptr, cbGuestPitch, transfer,
                                                &clipBox, pContext, rc, i);
@@ -677 +679 @@
 }
 
-static int vmsvga3dQueryWriteResult(PVGASTATE pThis, SVGAGuestPtr guestResult, SVGA3dQueryState enmState, uint32_t u32Result)
+static int vmsvga3dQueryWriteResult(PVGASTATE pThis, PVGASTATECC pThisCC, SVGAGuestPtr guestResult,
+                                    SVGA3dQueryState enmState, uint32_t u32Result)
 {
     SVGA3dQueryResult queryResult;
@@ -684 +687 @@
     queryResult.result32 = u32Result;
 
-    int rc = vmsvgaR3GmrTransfer(pThis, SVGA3D_READ_HOST_VRAM,
+    int rc = vmsvgaR3GmrTransfer(pThis, pThisCC, SVGA3D_READ_HOST_VRAM,
                                  (uint8_t *)&queryResult, sizeof(queryResult), 0, sizeof(queryResult),
                                  guestResult, 0, sizeof(queryResult), sizeof(queryResult), 1);
@@ -756 +759 @@
 }
 
-int vmsvga3dQueryWait(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
+int vmsvga3dQueryWait(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
 {
     PVMSVGA3DSTATE pState = pThis->svga.p3dState;
@@ -789 +792 @@
             {
                 /* Return data to the guest. */
-                vmsvga3dQueryWriteResult(pThis, guestResult, SVGA3D_QUERYSTATE_SUCCEEDED, p->u32QueryResult);
+                vmsvga3dQueryWriteResult(pThis, pThisCC, guestResult, SVGA3D_QUERYSTATE_SUCCEEDED, p->u32QueryResult);
                 return VINF_SUCCESS;
             }
@@ -805 +808 @@
     }
 
-    vmsvga3dQueryWriteResult(pThis, guestResult, SVGA3D_QUERYSTATE_FAILED, 0);
+    vmsvga3dQueryWriteResult(pThis, pThisCC, guestResult, SVGA3D_QUERYSTATE_FAILED, 0);
     AssertFailedReturn(rc);
 }
 
-int vmsvga3dSurfaceBlitToScreen(PVGASTATE pThis, uint32_t idDstScreen, SVGASignedRect destRect, SVGA3dSurfaceImageId src, SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *pRect)
+int vmsvga3dSurfaceBlitToScreen(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t idDstScreen, SVGASignedRect destRect,
+                                SVGA3dSurfaceImageId src, SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *pRect)
 {
     /* Requires SVGA_FIFO_CAP_SCREEN_OBJECT support */
@@ -859 +863 @@
         box.srcy    = destRect.top;
 
-        int rc = vmsvga3dSurfaceDMA(pThis, dest, src, SVGA3D_READ_HOST_VRAM, 1, &box);
+        int rc = vmsvga3dSurfaceDMA(pThis, pThisCC, dest, src, SVGA3D_READ_HOST_VRAM, 1, &box);
         AssertRCReturn(rc, rc);
 
         /* Update the guest image, which is at box.src. */
-        vmsvgaR3UpdateScreen(pThis, pScreen, box.srcx, box.srcy, box.w, box.h);
+        vmsvgaR3UpdateScreen(pThisCC, pScreen, box.srcx, box.srcy, box.w, box.h);
     }
     else
@@ -884 +888 @@
             box.srcy = destRect.top  + pRect[i].top;
 
-            int rc = vmsvga3dSurfaceDMA(pThis, dest, src, SVGA3D_READ_HOST_VRAM, 1, &box);
+            int rc = vmsvga3dSurfaceDMA(pThis, pThisCC, dest, src, SVGA3D_READ_HOST_VRAM, 1, &box);
             AssertRCReturn(rc, rc);
 
             /* Update the guest image, which is at box.src. */
-            vmsvgaR3UpdateScreen(pThis, pScreen, box.srcx, box.srcy, box.w, box.h);
+            vmsvgaR3UpdateScreen(pThisCC, pScreen, box.srcx, box.srcy, box.w, box.h);
         }
     }
@@ -895 +899 @@
 }
 
-int vmsvga3dCommandPresent(PVGASTATE pThis, uint32_t sid, uint32_t cRects, SVGA3dCopyRect *pRect)
+int vmsvga3dCommandPresent(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t sid, uint32_t cRects, SVGA3dCopyRect *pRect)
 {
     /* Deprecated according to svga3d_reg.h. */
@@ -949 +953 @@
 
         /* Entire rect. */
-        rc = vmsvga3dSurfaceBlitToScreen(pThis, idDstScreen, destRect, src, srcRect, 0, NULL);
+        rc = vmsvga3dSurfaceBlitToScreen(pThis, pThisCC, idDstScreen, destRect, src, srcRect, 0, NULL);
         AssertRCReturn(rc, rc);
     }

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.h

@@ -56 +56 @@
 
 /* DevVGA-SVGA3d-ogl.cpp & DevVGA-SVGA3d-win.cpp: */
-int vmsvga3dInit(PVGASTATE pThis);
-int vmsvga3dPowerOn(PVGASTATE pThis);
-int vmsvga3dLoadExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
+int vmsvga3dInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
+int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
+int vmsvga3dLoadExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
 int vmsvga3dSaveExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PSSMHANDLE pSSM);
 int vmsvga3dTerminate(PVGASTATE pThis);
@@ -70 +70 @@
 int vmsvga3dSurfaceStretchBlt(PVGASTATE pThis, SVGA3dSurfaceImageId const *pDstSfcImg, SVGA3dBox const *pDstBox,
                               SVGA3dSurfaceImageId const *pSrcSfcImg, SVGA3dBox const *pSrcBox, SVGA3dStretchBltMode enmMode);
-int vmsvga3dSurfaceDMA(PVGASTATE pThis, SVGA3dGuestImage guest, SVGA3dSurfaceImageId host, SVGA3dTransferType transfer, uint32_t cCopyBoxes, SVGA3dCopyBox *pBoxes);
-int vmsvga3dSurfaceBlitToScreen(PVGASTATE pThis, uint32_t dest, SVGASignedRect destRect, SVGA3dSurfaceImageId src, SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *pRect);
+int vmsvga3dSurfaceDMA(PVGASTATE pThis, PVGASTATECC pThisCC, SVGA3dGuestImage guest, SVGA3dSurfaceImageId host, SVGA3dTransferType transfer, uint32_t cCopyBoxes, SVGA3dCopyBox *pBoxes);
+int vmsvga3dSurfaceBlitToScreen(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t dest, SVGASignedRect destRect, SVGA3dSurfaceImageId src, SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *pRect);
 
 int vmsvga3dContextDefine(PVGASTATE pThis, uint32_t cid);
@@ -89 +89 @@
 int vmsvga3dSetClipPlane(PVGASTATE pThis, uint32_t cid,  uint32_t index, float plane[4]);
 int vmsvga3dCommandClear(PVGASTATE pThis, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect);
-int vmsvga3dCommandPresent(PVGASTATE pThis, uint32_t sid, uint32_t cRects, SVGA3dCopyRect *pRect);
+int vmsvga3dCommandPresent(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t sid, uint32_t cRects, SVGA3dCopyRect *pRect);
 int vmsvga3dDrawPrimitives(PVGASTATE pThis, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl, uint32_t numRanges, SVGA3dPrimitiveRange *pNumRange, uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor);
 int vmsvga3dSetScissorRect(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect);
@@ -101 +101 @@
 int vmsvga3dQueryBegin(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type);
 int vmsvga3dQueryEnd(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult);
-int vmsvga3dQueryWait(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult);
+int vmsvga3dQueryWait(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult);
 
 /* DevVGA-SVGA3d-shared.h: */

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

@@ -54 +54 @@
 #define PCIDEV_2_VGASTATE(pPciDev)      ((PVGASTATE)((uintptr_t)pPciDev - RT_OFFSETOF(VGASTATE, Dev)))
 #endif /* VBOX_WITH_HGSMI */
-/** Converts a vga adaptor state pointer to a device instance pointer. */
-#define VGASTATE2DEVINS(pVgaState)      ((pVgaState)->CTX_SUFF(pDevIns))
 
 /* VGA text mode blinking constants (cursor and blinking chars). */
@@ -514 +512 @@
 }
 
-static uint8_t vga_retrace(PVGASTATE pThis)
+static uint8_t vga_retrace(PPDMDEVINS pDevIns, PVGASTATE pThis)
 {
     vga_retrace_s   *r = &pThis->retrace_state;
@@ -523 +521 @@
         uint64_t    time_ns;
 
-        time_ns = PDMDevHlpTMTimeVirtGetNano(VGASTATE2DEVINS(pThis));
+        time_ns = PDMDevHlpTMTimeVirtGetNano(pDevIns);
 
         /* Determine the time within the frame. */
@@ -558 +556 @@
 }
 
-static uint32_t vga_ioport_read(PVGASTATE pThis, uint32_t addr)
+static uint32_t vga_ioport_read(PPDMDEVINS pDevIns, PVGASTATE pThis, uint32_t addr)
 {
     int val, index;
@@ -630 +628 @@
         case 0x3ba:
         case 0x3da:
-            val = pThis->st01 = vga_retrace(pThis);
+            val = pThis->st01 = vga_retrace(pDevIns, pThis);
             pThis->ar_flip_flop = 0;
             break;
@@ -642 +640 @@
 }
 
-static void vga_ioport_write(PVGASTATE pThis, uint32_t addr, uint32_t val)
+static void vga_ioport_write(PPDMDEVINS pDevIns, PVGASTATE pThis, uint32_t addr, uint32_t val)
 {
     int index;
@@ -715 +713 @@
             if (pThis->fRemappedVGA)
             {
-                PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
                 IOMMmioResetRegion(PDMDevHlpGetVM(pDevIns), pDevIns, pThis->hMmioLegacy);
                 pThis->fRemappedVGA = false;
@@ -755 +752 @@
             if (pThis->fRemappedVGA)
             {
-                PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
                 IOMMmioResetRegion(PDMDevHlpGetVM(pDevIns), pDevIns, pThis->hMmioLegacy);
                 pThis->fRemappedVGA = false;
@@ -961 +957 @@
 }
 
-static VBOXSTRICTRC vbe_ioport_write_data(PVGASTATE pThis, uint32_t addr, uint32_t val)
+static VBOXSTRICTRC vbe_ioport_write_data(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t addr, uint32_t val)
 {
     uint32_t max_bank;
-    NOREF(addr);
+    RT_NOREF(pThisCC, addr);
 
     if (pThis->vbe_index <= VBE_DISPI_INDEX_NB) {
@@ -1027 +1023 @@
             if (pThis->fRemappedVGA)
             {
-                PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
                 IOMMmioResetRegion(PDMDevHlpGetVM(pDevIns), pDevIns, pThis->hMmioLegacy);
                 pThis->fRemappedVGA = false;
@@ -1071 +1066 @@
                                          pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_HEIGHT]);
                     uint16_t cbLinePitch = pThis->vbe_line_offset;
-                    memset(pThis->CTX_SUFF(vram_ptr), 0,
+                    memset(pThisCC->pbVRam, 0,
                            cY * cbLinePitch);
                 }
@@ -1129 +1124 @@
              * and reset VBVA.
              */
-            pThis->pDrv->pfnLFBModeChange(pThis->pDrv, (val & VBE_DISPI_ENABLED) != 0);
+            pThisCC->pDrv->pfnLFBModeChange(pThisCC->pDrv, (val & VBE_DISPI_ENABLED) != 0);
 #  ifdef VBOX_WITH_HGSMI
-            VBVAOnVBEChanged(pThis);
+            VBVAOnVBEChanged(pThis, pThisCC);
 #  endif
 
@@ -1137 +1132 @@
             if (pThis->fRemappedVGA)
             {
-                PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
                 IOMMmioResetRegion(PDMDevHlpGetVM(pDevIns), pDevIns, pThis->hMmioLegacy);
                 pThis->fRemappedVGA = false;
@@ -1158 +1152 @@
             /* Changes in the VGA device are minimal. The device is bypassed. The driver does all work. */
             if (val == VBOX_VIDEO_DISABLE_ADAPTER_MEMORY)
-                pThis->pDrv->pfnProcessAdapterData(pThis->pDrv, NULL, 0);
+                pThisCC->pDrv->pfnProcessAdapterData(pThisCC->pDrv, NULL, 0);
             else if (val == VBOX_VIDEO_INTERPRET_ADAPTER_MEMORY)
-                pThis->pDrv->pfnProcessAdapterData(pThis->pDrv, pThis->CTX_SUFF(vram_ptr), pThis->vram_size);
+                pThisCC->pDrv->pfnProcessAdapterData(pThisCC->pDrv, pThisCC->pbVRam, pThis->vram_size);
             else if ((val & 0xFFFF0000) == VBOX_VIDEO_INTERPRET_DISPLAY_MEMORY_BASE)
-                pThis->pDrv->pfnProcessDisplayData(pThis->pDrv, pThis->CTX_SUFF(vram_ptr), val & 0xFFFF);
+                pThisCC->pDrv->pfnProcessDisplayData(pThisCC->pDrv, pThisCC->pbVRam, val & 0xFFFF);
 # endif /* IN_RING3 */
             break;
@@ -1181 +1175 @@
 
 /* called for accesses between 0xa0000 and 0xc0000 */
-static uint32_t vga_mem_readb(PVGASTATE pThis, RTGCPHYS addr, int *prc)
+static uint32_t vga_mem_readb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, RTGCPHYS addr, int *prc)
 {
     int plane;
@@ -1239 +1233 @@
             /** @todo only allow read access (doesn't work now) */
             STAM_COUNTER_INC(&pThis->StatMapPage);
-            PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
             IOMMmioMapMmio2Page(PDMDevHlpGetVM(pDevIns), pDevIns, pThis->hMmioLegacy, GCPhys - 0xa0000,
                                 pThis->hMmio2VRam, addr, X86_PTE_RW | X86_PTE_P);
@@ -1249 +1242 @@
         VERIFY_VRAM_READ_OFF_RETURN(pThis, addr, *prc);
 #ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
-        ret = !pThis->svga.fEnabled            ? pThis->CTX_SUFF(vram_ptr)[addr]
+        ret = !pThis->svga.fEnabled            ? pThisCC->pbVRam[addr]
             : addr < VMSVGA_VGA_FB_BACKUP_SIZE ? pThis->svga.pbVgaFrameBufferR3[addr] : 0xff;
 #else
-        ret = pThis->CTX_SUFF(vram_ptr)[addr];
+        ret = pThisCC->pbVRam[addr];
 #endif
     } else if (!(pThis->sr[4] & 0x04)) {    /* Host access is controlled by SR4, not GR5! */
@@ -1261 +1254 @@
         VERIFY_VRAM_READ_OFF_RETURN(pThis, off, *prc);
 #ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
-        ret = !pThis->svga.fEnabled           ? pThis->CTX_SUFF(vram_ptr)[off]
+        ret = !pThis->svga.fEnabled           ? pThisCC->pbVRam[off]
             : off < VMSVGA_VGA_FB_BACKUP_SIZE ? pThis->svga.pbVgaFrameBufferR3[off] : 0xff;
 #else
-        ret = pThis->CTX_SUFF(vram_ptr)[off];
+        ret = pThisCC->pbVRam[off];
 #endif
     } else {
@@ -1270 +1263 @@
         VERIFY_VRAM_READ_OFF_RETURN(pThis, addr * 4 + 3, *prc);
 #ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
-        pThis->latch = !pThis->svga.fEnabled            ? ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr]
+        pThis->latch = !pThis->svga.fEnabled            ? ((uint32_t *)pThisCC->pbVRam)[addr]
                      : addr < VMSVGA_VGA_FB_BACKUP_SIZE ? ((uint32_t *)pThis->svga.pbVgaFrameBufferR3)[addr] : UINT32_MAX;
 #else
-        pThis->latch = ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr];
+        pThis->latch = ((uint32_t *)pThisCC->pbVRam)[addr];
 #endif
         if (!(pThis->gr[5] & 0x08)) {
@@ -1294 +1287 @@
  * called for accesses between 0xa0000 and 0xc0000
  */
-static VBOXSTRICTRC vga_mem_writeb(PVGASTATE pThis, RTGCPHYS addr, uint32_t val)
+static VBOXSTRICTRC vga_mem_writeb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, RTGCPHYS addr, uint32_t val)
 {
     int plane, write_mode, b, func_select, mask;
@@ -1348 +1341 @@
             {
                 STAM_COUNTER_INC(&pThis->StatMapPage);
-                PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
                 IOMMmioMapMmio2Page(PDMDevHlpGetVM(pDevIns), pDevIns, pThis->hMmioLegacy, GCPhys - 0xa0000,
                                     pThis->hMmio2VRam, addr, X86_PTE_RW | X86_PTE_P);
@@ -1358 +1350 @@
 #ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
             if (!pThis->svga.fEnabled)
-                pThis->CTX_SUFF(vram_ptr)[addr]      = val;
+                pThisCC->pbVRam[addr]      = val;
             else if (addr < VMSVGA_VGA_FB_BACKUP_SIZE)
                 pThis->svga.pbVgaFrameBufferR3[addr] = val;
@@ -1367 +1359 @@
             }
 #else
-            pThis->CTX_SUFF(vram_ptr)[addr] = val;
+            pThisCC->pbVRam[addr] = val;
 #endif
             Log3(("vga: chain4: [0x%x]\n", addr));
@@ -1387 +1379 @@
 #ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
             if (!pThis->svga.fEnabled)
-                pThis->CTX_SUFF(vram_ptr)[addr]      = val;
+                pThisCC->pbVRam[addr]      = val;
             else if (addr < VMSVGA_VGA_FB_BACKUP_SIZE)
                 pThis->svga.pbVgaFrameBufferR3[addr] = val;
@@ -1396 +1388 @@
             }
 #else
-            pThis->CTX_SUFF(vram_ptr)[addr] = val;
+            pThisCC->pbVRam[addr] = val;
 #endif
             Log3(("vga: odd/even: [0x%x]\n", addr));
@@ -1472 +1464 @@
         uint32_t *pu32Dst;
         if (!pThis->svga.fEnabled)
-            pu32Dst = &((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr];
+            pu32Dst = &((uint32_t *)pThisCC->pbVRam)[addr];
         else if (addr * 4 + 3 < VMSVGA_VGA_FB_BACKUP_SIZE)
             pu32Dst = &((uint32_t *)pThis->svga.pbVgaFrameBufferR3)[addr];
@@ -1482 +1474 @@
         *pu32Dst = (*pu32Dst & ~write_mask) | (val & write_mask);
 #else
-        ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr] = (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr] & ~write_mask)
+        ((uint32_t *)pThisCC->pbVRam)[addr] = (((uint32_t *)pThisCC->pbVRam)[addr] & ~write_mask)
                                                       | (val & write_mask);
 #endif
@@ -1501 +1493 @@
                                   const uint8_t *font_ptr, int h,
                                   uint32_t fgcol, uint32_t bgcol, int dup9);
-typedef void vga_draw_line_func(PVGASTATE pThis, uint8_t *pbDst, const uint8_t *pbSrc, int width);
+typedef void vga_draw_line_func(PVGASTATE pThis, PVGASTATECC pThisCC, uint8_t *pbDst, const uint8_t *pbSrc, int width);
 
 static inline unsigned int rgb_to_pixel8(unsigned int r, unsigned int g, unsigned b)
@@ -1566 +1558 @@
 
 /** return true if the palette was modified */
-static bool vgaR3UpdatePalette16(PVGASTATE pThis)
+static bool vgaR3UpdatePalette16(PVGASTATE pThis, PVGASTATER3 pThisCC)
 {
     bool full_update = false;
@@ -1580 +1572 @@
             v = ((pThis->ar[0x14] & 0xc) << 4) | (v & 0x3f);
         v = v * 3;
-        col = pThis->rgb_to_pixel(c6_to_8(pThis->palette[v]),
-                                  c6_to_8(pThis->palette[v + 1]),
-                                  c6_to_8(pThis->palette[v + 2]));
+        col = pThisCC->rgb_to_pixel(c6_to_8(pThis->palette[v]),
+                                    c6_to_8(pThis->palette[v + 1]),
+                                    c6_to_8(pThis->palette[v + 2]));
         if (col != palette[i]) {
             full_update = true;
@@ -1592 +1584 @@
 
 /** return true if the palette was modified */
-static bool vgaR3UpdatePalette256(PVGASTATE pThis)
+static bool vgaR3UpdatePalette256(PVGASTATE pThis, PVGASTATER3 pThisCC)
 {
     bool full_update = false;
@@ -1605 +1597 @@
     for(i = 0; i < 256; i++) {
         if (wide_dac)
-            col = pThis->rgb_to_pixel(pThis->palette[v],
-                                      pThis->palette[v + 1],
-                                      pThis->palette[v + 2]);
+            col = pThisCC->rgb_to_pixel(pThis->palette[v],
+                                        pThis->palette[v + 1],
+                                        pThis->palette[v + 2]);
         else
-            col = pThis->rgb_to_pixel(c6_to_8(pThis->palette[v]),
-                                      c6_to_8(pThis->palette[v + 1]),
-                                      c6_to_8(pThis->palette[v + 2]));
+            col = pThisCC->rgb_to_pixel(c6_to_8(pThis->palette[v]),
+                                        c6_to_8(pThis->palette[v + 1]),
+                                        c6_to_8(pThis->palette[v + 2]));
         if (col != palette[i]) {
             full_update = true;
@@ -1658 +1650 @@
 
 /** update start_addr and line_offset. Return TRUE if modified */
-static bool vgaR3UpdateBasicParams(PVGASTATE pThis)
+static bool vgaR3UpdateBasicParams(PVGASTATE pThis, PVGASTATER3 pThisCC)
 {
     bool full_update = false;
     uint32_t start_addr, line_offset, line_compare;
 
-    pThis->get_offsets(pThis, &line_offset, &start_addr, &line_compare);
+    pThisCC->get_offsets(pThis, &line_offset, &start_addr, &line_compare);
 
     if (line_offset != pThis->line_offset ||
@@ -1738 +1730 @@
  * - underline
  */
-static int vgaR3DrawText(PVGASTATE pThis, bool full_update, bool fFailOnResize, bool reset_dirty, PDMIDISPLAYCONNECTOR *pDrv)
+static int vgaR3DrawText(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATER3 pThisCC, bool full_update,
+                         bool fFailOnResize, bool reset_dirty, PDMIDISPLAYCONNECTOR *pDrv)
 {
     int cx, cy, cheight, cw, ch, cattr, height, width, ch_attr;
@@ -1755 +1748 @@
     bool blink_enabled, blink_do_redraw;
 
-    full_update |= vgaR3UpdatePalette16(pThis);
+    full_update |= vgaR3UpdatePalette16(pThis, pThisCC);
     palette = pThis->last_palette;
 
@@ -1765 +1758 @@
         full_update = true;
     }
-    font_base[0] = pThis->CTX_SUFF(vram_ptr) + offset;
+    font_base[0] = pThisCC->pbVRam + offset;
 
     offset = (((v >> 5) & 1) | ((v >> 1) & 6)) * 8192 * 4 + 2;
-    font_base[1] = pThis->CTX_SUFF(vram_ptr) + offset;
+    font_base[1] = pThisCC->pbVRam + offset;
     if (offset != pThis->font_offsets[1]) {
         pThis->font_offsets[1] = offset;
@@ -1779 +1772 @@
         full_update = true;
     }
-    full_update |= vgaR3UpdateBasicParams(pThis);
+    full_update |= vgaR3UpdateBasicParams(pThis, pThisCC);
 
     line_offset = pThis->line_offset;
-    s1 = pThis->CTX_SUFF(vram_ptr) + (pThis->start_addr * 8); /** @todo r=bird: Add comment why we do *8 instead of *4, it's not so obvious... */
+    s1 = pThisCC->pbVRam + (pThis->start_addr * 8); /** @todo r=bird: Add comment why we do *8 instead of *4, it's not so obvious... */
 
     /* double scanning - not for 9-wide modes */
@@ -1844 +1837 @@
         pThis->cursor_end = pThis->cr[0xb];
     }
-    cursor_ptr = pThis->CTX_SUFF(vram_ptr) + (pThis->start_addr + cursor_offset) * 8;
+    cursor_ptr = pThisCC->pbVRam + (pThis->start_addr + cursor_offset) * 8;
     depth_index = vgaR3GetDepthIndex(pDrv->cBits);
     if (cw == 16)
@@ -1860 +1853 @@
 
     /* Figure out if we're in the visible period of the blink cycle. */
-    time_ns  = PDMDevHlpTMTimeVirtGetNano(VGASTATE2DEVINS(pThis));
+    time_ns  = PDMDevHlpTMTimeVirtGetNano(pDevIns);
     blink_on = (time_ns % VGA_BLINK_PERIOD_FULL) < VGA_BLINK_PERIOD_ON;
     chr_blink_flip = false;
@@ -2084 +2077 @@
  * @returns VINF_SUCCESS on success.
  * @returns VINF_VGA_RESIZE_IN_PROGRESS if the operation wasn't complete.
- * @param   pThis   Pointer to the vga state.
+ * @param   pThis   Pointer to the shared VGA state.
+ * @param   pThisCC Pointer to the ring-3 VGA state.
  * @param   cx      The width.
  * @param   cy      The height.
  * @param   pDrv    The display connector.
  */
-static int vgaR3ResizeGraphic(PVGASTATE pThis, int cx, int cy, PDMIDISPLAYCONNECTOR *pDrv)
-{
-    const unsigned cBits = pThis->get_bpp(pThis);
+static int vgaR3ResizeGraphic(PVGASTATE pThis, PVGASTATER3 pThisCC, int cx, int cy, PDMIDISPLAYCONNECTOR *pDrv)
+{
+    const unsigned cBits = pThisCC->get_bpp(pThis);
 
     int rc;
@@ -2109 +2103 @@
      *
      * The reason for doing this for WDDM driver only now is to avoid regressions of the current code */
-    PVBOXVDMAHOST pVdma = pThis->pVdma;
+    PVBOXVDMAHOST pVdma = pThisCC->pVdma;
     if (pVdma && vboxVDMAIsEnabled(pVdma))
         rc = VINF_SUCCESS;
@@ -2118 +2112 @@
         if (pThis->start_addr * 4 + pThis->line_offset * cy < pThis->vram_size)
             /* Take into account the programmed start address (in DWORDs) of the visible screen. */
-            rc = pDrv->pfnResize(pDrv, cBits, pThis->CTX_SUFF(vram_ptr) + pThis->start_addr * 4, pThis->line_offset, cx, cy);
+            rc = pDrv->pfnResize(pDrv, cBits, pThisCC->pbVRam + pThis->start_addr * 4, pThis->line_offset, cx, cy);
         else
         {
@@ -2140 +2134 @@
     switch (pDrv->cBits)
     {
-        case 32:    pThis->rgb_to_pixel = rgb_to_pixel32_dup; break;
+        case 32:    pThisCC->rgb_to_pixel = rgb_to_pixel32_dup; break;
         case 16:
-        default:    pThis->rgb_to_pixel = rgb_to_pixel16_dup; break;
-        case 15:    pThis->rgb_to_pixel = rgb_to_pixel15_dup; break;
-        case 8:     pThis->rgb_to_pixel = rgb_to_pixel8_dup;  break;
+        default:    pThisCC->rgb_to_pixel = rgb_to_pixel16_dup; break;
+        case 15:    pThisCC->rgb_to_pixel = rgb_to_pixel15_dup; break;
+        case 8:     pThisCC->rgb_to_pixel = rgb_to_pixel8_dup;  break;
     }
     if (pThis->shift_control == 0)
-        vgaR3UpdatePalette16(pThis);
+        vgaR3UpdatePalette16(pThis, pThisCC);
     else if (pThis->shift_control == 1)
-        vgaR3UpdatePalette16(pThis);
+        vgaR3UpdatePalette16(pThis, pThisCC);
     return VINF_SUCCESS;
 }
@@ -2225 +2219 @@
  * graphic modes
  */
-static int vmsvgaR3DrawGraphic(PVGASTATE pThis, bool fFullUpdate, bool fFailOnResize, bool reset_dirty,
-                               PDMIDISPLAYCONNECTOR *pDrv)
+static int vmsvgaR3DrawGraphic(PVGASTATE pThis, PVGASTATER3 pThisCC, bool fFullUpdate,
+                               bool fFailOnResize, bool reset_dirty, PDMIDISPLAYCONNECTOR *pDrv)
 {
     RT_NOREF1(fFailOnResize);
@@ -2275 +2269 @@
     vga_draw_line_func *pfnVgaDrawLine = vga_draw_line_table[v * 4 + vgaR3GetDepthIndex(pDrv->cBits)];
 
-    Assert(!pThis->cursor_invalidate);
-    Assert(!pThis->cursor_draw_line);
-    //not used// if (pThis->cursor_invalidate)
-    //not used//     pThis->cursor_invalidate(pThis);
+    Assert(!pThisCC->cursor_invalidate);
+    Assert(!pThisCC->cursor_draw_line);
+    //not used// if (pThisCC->cursor_invalidate)
+    //not used//     pThisCC->cursor_invalidate(pThis);
 
     uint8_t    *pbDst          = pDrv->pbData;
@@ -2312 +2306 @@
                 offPageMax = offPage1;
             if (pThis->fRenderVRAM)
-                pfnVgaDrawLine(pThis, pbDst, pThis->CTX_SUFF(vram_ptr) + offSrcLine, cx);
-            //not used// if (pThis->cursor_draw_line)
-            //not used//     pThis->cursor_draw_line(pThis, pbDst, y);
+                pfnVgaDrawLine(pThis, pThisCC, pbDst, pThisCC->pbVRam + offSrcLine, cx);
+            //not used// if (pThisCC->cursor_draw_line)
+            //not used//     pThisCC->cursor_draw_line(pThis, pbDst, y);
         }
         else if (yUpdateRectTop != UINT32_MAX)
@@ -2345 +2339 @@
  * graphic modes
  */
-static int vgaR3DrawGraphic(PVGASTATE pThis, bool full_update, bool fFailOnResize, bool reset_dirty,
+static int vgaR3DrawGraphic(PVGASTATE pThis, PVGASTATER3 pThisCC, bool full_update, bool fFailOnResize, bool reset_dirty,
                             PDMIDISPLAYCONNECTOR *pDrv)
 {
@@ -2353 +2347 @@
     uint8_t *d;
     uint32_t v, addr1, addr;
-    vga_draw_line_func *vga_draw_line;
-
-    bool offsets_changed = vgaR3UpdateBasicParams(pThis);
+    vga_draw_line_func *pfnVgaDrawLine;
+
+    bool offsets_changed = vgaR3UpdateBasicParams(pThis, pThisCC);
 
     full_update |= offsets_changed;
 
-    pThis->get_resolution(pThis, &width, &height);
+    pThisCC->get_resolution(pThis, &width, &height);
     disp_width = width;
 
@@ -2373 +2367 @@
 
     if (shift_control == 0) {
-        full_update |= vgaR3UpdatePalette16(pThis);
+        full_update |= vgaR3UpdatePalette16(pThis, pThisCC);
         if (pThis->sr[0x01] & 8) {
             v = VGA_DRAW_LINE4D2;
@@ -2382 +2376 @@
         bits = 4;
     } else if (shift_control == 1) {
-        full_update |= vgaR3UpdatePalette16(pThis);
+        full_update |= vgaR3UpdatePalette16(pThis, pThisCC);
         if (pThis->sr[0x01] & 8) {
             v = VGA_DRAW_LINE2D2;
@@ -2391 +2385 @@
         bits = 4;
     } else {
-        switch(pThis->get_bpp(pThis)) {
+        switch(pThisCC->get_bpp(pThis)) {
         default:
         case 0:
-            full_update |= vgaR3UpdatePalette256(pThis);
+            full_update |= vgaR3UpdatePalette256(pThis, pThisCC);
             v = VGA_DRAW_LINE8D2;
             bits = 4;
             break;
         case 8:
-            full_update |= vgaR3UpdatePalette256(pThis);
+            full_update |= vgaR3UpdatePalette256(pThis, pThisCC);
             v = VGA_DRAW_LINE8;
             bits = 8;
@@ -2423 +2417 @@
     if (    disp_width     != (int)pThis->last_width
         ||  height         != (int)pThis->last_height
-        ||  pThis->get_bpp(pThis)  != (int)pThis->last_bpp
+        ||  pThisCC->get_bpp(pThis)  != (int)pThis->last_bpp
         || (offsets_changed && !pThis->fRenderVRAM))
     {
@@ -2431 +2425 @@
             return VERR_TRY_AGAIN;
         }
-        int rc = vgaR3ResizeGraphic(pThis, disp_width, height, pDrv);
+        int rc = vgaR3ResizeGraphic(pThis, pThisCC, disp_width, height, pDrv);
         if (rc != VINF_SUCCESS)  /* Return any rc, particularly VINF_VGA_RESIZE_IN_PROGRESS, to the caller. */
             return rc;
@@ -2453 +2447 @@
     }
 
-    vga_draw_line = vga_draw_line_table[v * 4 + vgaR3GetDepthIndex(pDrv->cBits)];
-
-    if (pThis->cursor_invalidate)
-        pThis->cursor_invalidate(pThis);
+    pfnVgaDrawLine = vga_draw_line_table[v * 4 + vgaR3GetDepthIndex(pDrv->cBits)];
+
+    if (pThisCC->cursor_invalidate)
+        pThisCC->cursor_invalidate(pThis);
 
     line_offset = pThis->line_offset;
@@ -2511 +2505 @@
                 page_max = page1;
             if (pThis->fRenderVRAM)
-                vga_draw_line(pThis, d, pThis->CTX_SUFF(vram_ptr) + addr, width);
-            if (pThis->cursor_draw_line)
-                pThis->cursor_draw_line(pThis, d, y);
+                pfnVgaDrawLine(pThis, pThisCC, d, pThisCC->pbVRam + addr, width);
+            if (pThisCC->cursor_draw_line)
+                pThisCC->cursor_draw_line(pThis, d, y);
         } else {
             if (y_start >= 0) {
@@ -2554 +2548 @@
  * blanked modes
  */
-static int vgaR3DrawBlank(PVGASTATE pThis, bool full_update, bool fFailOnResize, bool reset_dirty,
-                          PDMIDISPLAYCONNECTOR *pDrv)
+static int vgaR3DrawBlank(PVGASTATE pThis, PVGASTATER3 pThisCC, bool full_update,
+                          bool fFailOnResize, bool reset_dirty, PDMIDISPLAYCONNECTOR *pDrv)
 {
     int i, w, val;
@@ -2585 +2579 @@
         vgaR3ResetDirty(pThis, page_min, page_max + PAGE_SIZE);
     }
-    if (pDrv->pbData == pThis->vram_ptrR3) /* Do not clear the VRAM itself. */
+    if (pDrv->pbData == pThisCC->pbVRam) /* Do not clear the VRAM itself. */
         return VINF_SUCCESS;
     if (!full_update)
@@ -2592 +2586 @@
         return VINF_SUCCESS;
     if (pDrv->cBits == 8)
-        val = pThis->rgb_to_pixel(0, 0, 0);
+        val = pThisCC->rgb_to_pixel(0, 0, 0);
     else
         val = 0;
@@ -2620 +2614 @@
  * vgaR3PortTakeScreenshot().
  */
-static int vgaR3UpdateDisplay(PVGASTATE pThis, bool fUpdateAll, bool fFailOnResize, bool reset_dirty,
-                              PDMIDISPLAYCONNECTOR *pDrv, int32_t *pcur_graphic_mode)
+static int vgaR3UpdateDisplay(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATER3 pThisCC, bool fUpdateAll,
+                              bool fFailOnResize, bool reset_dirty, PDMIDISPLAYCONNECTOR *pDrv, int32_t *pcur_graphic_mode)
 {
     int rc = VINF_SUCCESS;
@@ -2631 +2625 @@
         switch(pDrv->cBits) {
         case 8:
-            pThis->rgb_to_pixel = rgb_to_pixel8_dup;
+            pThisCC->rgb_to_pixel = rgb_to_pixel8_dup;
             break;
         case 15:
-            pThis->rgb_to_pixel = rgb_to_pixel15_dup;
+            pThisCC->rgb_to_pixel = rgb_to_pixel15_dup;
             break;
         default:
         case 16:
-            pThis->rgb_to_pixel = rgb_to_pixel16_dup;
+            pThisCC->rgb_to_pixel = rgb_to_pixel16_dup;
             break;
         case 32:
-            pThis->rgb_to_pixel = rgb_to_pixel32_dup;
+            pThisCC->rgb_to_pixel = rgb_to_pixel32_dup;
             break;
         }
@@ -2662 +2656 @@
         switch(graphic_mode) {
         case GMODE_TEXT:
-            rc = vgaR3DrawText(pThis, full_update, fFailOnResize, reset_dirty, pDrv);
+            rc = vgaR3DrawText(pDevIns, pThis, pThisCC, full_update, fFailOnResize, reset_dirty, pDrv);
             break;
         case GMODE_GRAPH:
-            rc = vgaR3DrawGraphic(pThis, full_update, fFailOnResize, reset_dirty, pDrv);
+            rc = vgaR3DrawGraphic(pThis, pThisCC, full_update, fFailOnResize, reset_dirty, pDrv);
             break;
 #ifdef VBOX_WITH_VMSVGA
         case GMODE_SVGA:
-            rc = vmsvgaR3DrawGraphic(pThis, full_update, fFailOnResize, reset_dirty, pDrv);
+            rc = vmsvgaR3DrawGraphic(pThis, pThisCC, full_update, fFailOnResize, reset_dirty, pDrv);
             break;
 #endif
         case GMODE_BLANK:
         default:
-            rc = vgaR3DrawBlank(pThis, full_update, fFailOnResize, reset_dirty, pDrv);
+            rc = vgaR3DrawBlank(pThis, pThisCC, full_update, fFailOnResize, reset_dirty, pDrv);
             break;
         }
@@ -2842 +2836 @@
         NOREF(pvUser); \
         if (cb == 1) \
-            vga_ioport_write(pThis, offPort, u32); \
+            vga_ioport_write(pDevIns, pThis, offPort, u32); \
         else if (cb == 2) \
         { \
-            vga_ioport_write(pThis, offPort, u32 & 0xff); \
-            vga_ioport_write(pThis, offPort + 1, u32 >> 8); \
+            vga_ioport_write(pDevIns, pThis, offPort, u32 & 0xff); \
+            vga_ioport_write(pDevIns, pThis, offPort + 1, u32 >> 8); \
         } \
         return VINF_SUCCESS; \
@@ -2858 +2852 @@
         NOREF(pvUser); \
         if (cb == 1) \
-            *pu32 = vga_ioport_read(pThis, offPort); \
+            *pu32 = vga_ioport_read(pDevIns, pThis, offPort); \
         else if (cb == 2) \
         { \
-            uint32_t u32 = vga_ioport_read(pThis, offPort); \
-            u32 |= vga_ioport_read(pThis, offPort + 1) << 8; \
+            uint32_t u32 = vga_ioport_read(pDevIns, pThis, offPort); \
+            u32 |= vga_ioport_read(pDevIns, pThis, offPort + 1) << 8; \
             *pu32 = u32; \
         } \
@@ -3071 +3065 @@
 vgaIoPortWriteVbeData(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
 
@@ -3096 +3091 @@
             {
                 pThis->fWriteVBEData = false;
-                return vbe_ioport_write_data(pThis, offPort, u32 & 0xFF);
+                return vbe_ioport_write_data(pDevIns, pThis, pThisCC, offPort, u32 & 0xFF);
             }
 
@@ -3110 +3105 @@
 #endif
     if (cb == 2 || cb == 4)
-        return vbe_ioport_write_data(pThis, offPort, u32);
+        return vbe_ioport_write_data(pDevIns, pThis, pThisCC, offPort, u32);
     AssertMsgFailed(("vgaIoPortWriteVbeData: offPort=%#x cb=%d u32=%#x\n", offPort, cb, u32));
 
@@ -3231 +3226 @@
 vgaR3IOPortHgsmiWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
     LogFlowFunc(("offPort=0x%x u32=0x%x cb=%u\n", offPort, u32, cb));
@@ -3251 +3247 @@
                     {
                         PDMDevHlpPCISetIrqNoWait(pDevIns, 0, PDM_IRQ_LEVEL_LOW);
-                        HGSMIClearHostGuestFlags(pThis->pHGSMI,
+                        HGSMIClearHostGuestFlags(pThisCC->pHGSMI,
                                                  HGSMIHOSTFLAGS_IRQ
                                                  | HGSMIHOSTFLAGS_VSYNC
@@ -3259 +3255 @@
                     else
                     {
-                        HGSMISetHostGuestFlags(pThis->pHGSMI, HGSMIHOSTFLAGS_IRQ | pThis->fu32PendingGuestFlags);
+                        HGSMISetHostGuestFlags(pThisCC->pHGSMI, HGSMIHOSTFLAGS_IRQ | pThis->fu32PendingGuestFlags);
                         pThis->fu32PendingGuestFlags = 0;
                         /* Keep the IRQ unchanged. */
@@ -3269 +3265 @@
 # endif
                 {
-                    HGSMIHostWrite(pThis->pHGSMI, u32);
+                    HGSMIHostWrite(pThisCC->pHGSMI, u32);
                 }
                 break;
@@ -3275 +3271 @@
 
             case VGA_PORT_HGSMI_GUEST: /* Guest */
-                HGSMIGuestWrite(pThis->pHGSMI, u32);
+                HGSMIGuestWrite(pThisCC->pHGSMI, u32);
                 break;
 
@@ -3307 +3303 @@
 vgaR3IOPortHgmsiRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
     LogFlowFunc(("offPort=0x%x cb=%d\n", offPort, cb));
@@ -3319 +3316 @@
         {
             case VGA_PORT_HGSMI_HOST: /* Host */
-                *pu32 = HGSMIHostRead(pThis->pHGSMI);
+                *pu32 = HGSMIHostRead(pThisCC->pHGSMI);
                 break;
             case VGA_PORT_HGSMI_GUEST: /* Guest */
-                *pu32 = HGSMIGuestRead(pThis->pHGSMI);
+                *pu32 = HGSMIGuestRead(pThisCC->pHGSMI);
                 break;
             default:
@@ -3389 +3386 @@
  * @param   cItems      Number of data items to write.
  */
-static int vgaInternalMMIOFill(PVGASTATE pThis, void *pvUser, RTGCPHYS GCPhysAddr,
+static int vgaInternalMMIOFill(PVGASTATE pThis, PVGASTATECC pThisCC, void *pvUser, RTGCPHYS GCPhysAddr,
                                uint32_t u32Item, unsigned cbItem, unsigned cItems)
 {
@@ -3437 +3434 @@
                 if (pThis->sr[2] & (1 << (GCPhysAddr & 3)))
                 {
-                    pThis->CTX_SUFF(vram_ptr)[GCPhysAddr] = aVal[i];
+                    pThisCC->pbVRam[GCPhysAddr] = aVal[i];
                     vgaR3MarkDirty(pThis, GCPhysAddr);
                 }
@@ -3451 +3448 @@
                 if (pThis->sr[2] & (1 << plane)) {
                     RTGCPHYS PhysAddr2 = ((GCPhysAddr & ~1) * 4) | plane;
-                    pThis->CTX_SUFF(vram_ptr)[PhysAddr2] = aVal[i];
+                    pThisCC->pbVRam[PhysAddr2] = aVal[i];
                     vgaR3MarkDirty(pThis, PhysAddr2);
                 }
@@ -3523 +3520 @@
             while (cItems-- > 0)
             {
-                ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[0] & write_mask);
+                ((uint32_t *)pThisCC->pbVRam)[GCPhysAddr] = (((uint32_t *)pThisCC->pbVRam)[GCPhysAddr] & ~write_mask) | (aVal[0] & write_mask);
                 vgaR3MarkDirty(pThis, GCPhysAddr * 4);
                 GCPhysAddr++;
@@ -3533 +3530 @@
             while (cItems-- > 0)
             {
-                ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[0] & write_mask);
+                ((uint32_t *)pThisCC->pbVRam)[GCPhysAddr] = (((uint32_t *)pThisCC->pbVRam)[GCPhysAddr] & ~write_mask) | (aVal[0] & write_mask);
                 vgaR3MarkDirty(pThis, GCPhysAddr * 4);
                 GCPhysAddr++;
 
-                ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[1] & write_mask);
+                ((uint32_t *)pThisCC->pbVRam)[GCPhysAddr] = (((uint32_t *)pThisCC->pbVRam)[GCPhysAddr] & ~write_mask) | (aVal[1] & write_mask);
                 vgaR3MarkDirty(pThis, GCPhysAddr * 4);
                 GCPhysAddr++;
@@ -3549 +3546 @@
                 for (i = 0; i < cbItem; i++)
                 {
-                    ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[i] & write_mask);
+                    ((uint32_t *)pThisCC->pbVRam)[GCPhysAddr] = (((uint32_t *)pThisCC->pbVRam)[GCPhysAddr] & ~write_mask) | (aVal[i] & write_mask);
                     vgaR3MarkDirty(pThis, GCPhysAddr * 4);
                     GCPhysAddr++;
@@ -3569 +3566 @@
 vgaMmioFill(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, uint32_t u32Item, unsigned cbItem, unsigned cItems)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
 
-    return vgaInternalMMIOFill(pThis, pvUser, off, u32Item, cbItem, cItems);
+    return vgaInternalMMIOFill(pThis, pThisCC, pvUser, off, u32Item, cbItem, cItems);
 }
 
@@ -3582 +3580 @@
 static DECLCALLBACK(VBOXSTRICTRC) vgaMmioRead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void *pv, unsigned cb)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     STAM_PROFILE_START(&pThis->CTX_MID_Z(Stat,MemoryRead), a);
     Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
@@ -3591 +3590 @@
     {
         case 1:
-            *(uint8_t  *)pv = vga_mem_readb(pThis, off, &rc);
+            *(uint8_t  *)pv = vga_mem_readb(pDevIns, pThis, pThisCC, off, &rc);
             break;
         case 2:
@@ -3597 +3596 @@
  *        crossing the 512KB VRAM boundrary if the access is handled in
  *        ring-0 and operating in latched mode. */
-            *(uint16_t *)pv = vga_mem_readb(pThis, off, &rc)
-                           | (vga_mem_readb(pThis, off + 1, &rc) << 8);
+            *(uint16_t *)pv = vga_mem_readb(pDevIns, pThis, pThisCC, off, &rc)
+                           | (vga_mem_readb(pDevIns, pThis, pThisCC, off + 1, &rc) << 8);
             break;
         case 4:
-            *(uint32_t *)pv = vga_mem_readb(pThis, off, &rc)
-                           | (vga_mem_readb(pThis, off + 1, &rc) <<  8)
-                           | (vga_mem_readb(pThis, off + 2, &rc) << 16)
-                           | (vga_mem_readb(pThis, off + 3, &rc) << 24);
+            *(uint32_t *)pv = vga_mem_readb(pDevIns, pThis, pThisCC, off, &rc)
+                           | (vga_mem_readb(pDevIns, pThis, pThisCC, off + 1, &rc) <<  8)
+                           | (vga_mem_readb(pDevIns, pThis, pThisCC, off + 2, &rc) << 16)
+                           | (vga_mem_readb(pDevIns, pThis, pThisCC, off + 3, &rc) << 24);
             break;
 
         case 8:
-            *(uint64_t *)pv = (uint64_t)vga_mem_readb(pThis, off, &rc)
-                           | ((uint64_t)vga_mem_readb(pThis, off + 1, &rc) <<  8)
-                           | ((uint64_t)vga_mem_readb(pThis, off + 2, &rc) << 16)
-                           | ((uint64_t)vga_mem_readb(pThis, off + 3, &rc) << 24)
-                           | ((uint64_t)vga_mem_readb(pThis, off + 4, &rc) << 32)
-                           | ((uint64_t)vga_mem_readb(pThis, off + 5, &rc) << 40)
-                           | ((uint64_t)vga_mem_readb(pThis, off + 6, &rc) << 48)
-                           | ((uint64_t)vga_mem_readb(pThis, off + 7, &rc) << 56);
+            *(uint64_t *)pv = (uint64_t)vga_mem_readb(pDevIns, pThis, pThisCC, off, &rc)
+                           | ((uint64_t)vga_mem_readb(pDevIns, pThis, pThisCC, off + 1, &rc) <<  8)
+                           | ((uint64_t)vga_mem_readb(pDevIns, pThis, pThisCC, off + 2, &rc) << 16)
+                           | ((uint64_t)vga_mem_readb(pDevIns, pThis, pThisCC, off + 3, &rc) << 24)
+                           | ((uint64_t)vga_mem_readb(pDevIns, pThis, pThisCC, off + 4, &rc) << 32)
+                           | ((uint64_t)vga_mem_readb(pDevIns, pThis, pThisCC, off + 5, &rc) << 40)
+                           | ((uint64_t)vga_mem_readb(pDevIns, pThis, pThisCC, off + 6, &rc) << 48)
+                           | ((uint64_t)vga_mem_readb(pDevIns, pThis, pThisCC, off + 7, &rc) << 56);
             break;
 
@@ -3623 +3622 @@
             while (cb-- > 0)
             {
-                *pbData++ = vga_mem_readb(pThis, off++, &rc);
+                *pbData++ = vga_mem_readb(pDevIns, pThis, pThisCC, off++, &rc);
                 if (RT_UNLIKELY(rc != VINF_SUCCESS))
                     break;
@@ -3640 +3639 @@
 static DECLCALLBACK(VBOXSTRICTRC) vgaMmioWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void const *pv, unsigned cb)
 {
-    PVGASTATE      pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
-    uint8_t const *pbSrc = (uint8_t const *)pv;
+    PVGASTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    uint8_t const *pbSrc  = (uint8_t const *)pv;
     NOREF(pvUser);
     STAM_PROFILE_START(&pThis->CTX_MID_Z(Stat,MemoryWrite), a);
@@ -3650 +3650 @@
     {
         case 1:
-            rc = vga_mem_writeb(pThis, off, *pbSrc);
+            rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off, *pbSrc);
             break;
 #if 1
         case 2:
-            rc = vga_mem_writeb(pThis, off + 0, pbSrc[0]);
+            rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 0, pbSrc[0]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 1, pbSrc[1]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 1, pbSrc[1]);
             break;
         case 4:
-            rc = vga_mem_writeb(pThis, off + 0, pbSrc[0]);
+            rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 0, pbSrc[0]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 1, pbSrc[1]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 1, pbSrc[1]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 2, pbSrc[2]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 2, pbSrc[2]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 3, pbSrc[3]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 3, pbSrc[3]);
             break;
         case 8:
-            rc = vga_mem_writeb(pThis, off + 0, pbSrc[0]);
+            rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 0, pbSrc[0]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 1, pbSrc[1]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 1, pbSrc[1]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 2, pbSrc[2]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 2, pbSrc[2]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 3, pbSrc[3]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 3, pbSrc[3]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 4, pbSrc[4]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 4, pbSrc[4]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 5, pbSrc[5]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 5, pbSrc[5]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 6, pbSrc[6]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 6, pbSrc[6]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pThis, off + 7, pbSrc[7]);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off + 7, pbSrc[7]);
             break;
 #else
@@ -3698 +3698 @@
             rc = VINF_SUCCESS;
             while (cb-- > 0 && rc == VINF_SUCCESS)
-                rc = vga_mem_writeb(pThis, off++, *pbSrc++);
+                rc = vga_mem_writeb(pDevIns, pThis, pThisCC, off++, *pbSrc++);
             break;
 
@@ -3712 +3712 @@
  * @returns Strict VBox status code.
  * @param   pVM         VM handle.
- * @param   pThis       VGA device instance data.
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The shared VGA instance data.
  * @param   GCPhys      The access physical address.
  * @param   GCPtr       The access virtual address (only GC).
  */
-static VBOXSTRICTRC vgaLFBAccess(PVMCC pVM, PVGASTATE pThis, RTGCPHYS GCPhys, RTGCPTR GCPtr)
-{
-    VBOXSTRICTRC rc = PDMDevHlpCritSectEnter(pThis->CTX_SUFF(pDevIns), &pThis->CritSect, VINF_EM_RAW_EMULATE_INSTR);
+static VBOXSTRICTRC vgaLFBAccess(PVMCC pVM, PPDMDEVINS pDevIns, PVGASTATE pThis, RTGCPHYS GCPhys, RTGCPTR GCPtr)
+{
+    VBOXSTRICTRC rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VINF_EM_RAW_EMULATE_INSTR);
     if (rc == VINF_SUCCESS)
     {
@@ -3736 +3737 @@
         {
 #ifndef IN_RING3
-            rc = PGMShwMakePageWritable(PDMDevHlpGetVMCPU(pThis->CTX_SUFF(pDevIns)), GCPtr,
+            rc = PGMShwMakePageWritable(PDMDevHlpGetVMCPU(pDevIns), GCPtr,
                                         PGM_MK_PG_IS_MMIO2 | PGM_MK_PG_IS_WRITE_FAULT);
-            PDMDevHlpCritSectLeave(pThis->CTX_SUFF(pDevIns), &pThis->CritSect);
+            PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
             AssertMsgReturn(    rc == VINF_SUCCESS
                             /* In the SMP case the page table might be removed while we wait for the PGM lock in the trap handler. */
@@ -3746 +3747 @@
                             VBOXSTRICTRC_VAL(rc));
 #else  /* IN_RING3 - We don't have any virtual page address of the access here. */
-            PDMDevHlpCritSectLeave(pThis->CTX_SUFF(pDevIns), &pThis->CritSect);
+            PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
             Assert(GCPtr == 0);
             RT_NOREF1(GCPtr);
@@ -3753 +3754 @@
         }
 
-        PDMDevHlpCritSectLeave(pThis->CTX_SUFF(pDevIns), &pThis->CritSect);
+        PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
         AssertMsgFailed(("PGMHandlerPhysicalPageTempOff -> rc=%d\n", VBOXSTRICTRC_VAL(rc)));
     }
@@ -3767 +3768 @@
                                                   RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
 {
-    PVGASTATE   pThis = (PVGASTATE)pvUser;
-    AssertPtr(pThis);
+    PPDMDEVINS  pDevIns = (PPDMDEVINS)pvUser;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    //PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     Assert(GCPhysFault >= pThis->GCPhysVRAM);
     AssertMsg(uErrorCode & X86_TRAP_PF_RW, ("uErrorCode=%#x\n", uErrorCode));
     RT_NOREF3(pVCpu, pRegFrame, uErrorCode);
 
-    return vgaLFBAccess(pVM, pThis, GCPhysFault, pvFault);
+    return vgaLFBAccess(pVM, pDevIns, pThis, GCPhysFault, pvFault);
 }
 #endif /* !IN_RING3 */
@@ -3786 +3788 @@
                                                   PGMACCESSORIGIN enmOrigin, void *pvUser)
 {
-    PVGASTATE pThis = (PVGASTATE)pvUser;
-    Assert(pThis);
+    PPDMDEVINS  pDevIns = (PPDMDEVINS)pvUser;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    //PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     Assert(GCPhys >= pThis->GCPhysVRAM);
     RT_NOREF(pVCpu, pvPhys, pvBuf, cbBuf, enmAccessType, enmOrigin);
 
-    VBOXSTRICTRC rc = vgaLFBAccess(pVM, pThis, GCPhys, 0);
+    VBOXSTRICTRC rc = vgaLFBAccess(pVM, pDevIns, pThis, GCPhys, 0);
     if (rc == VINF_SUCCESS)
         rc = VINF_PGM_HANDLER_DO_DEFAULT;
@@ -3868 +3871 @@
 vbeR3IOPortWriteVbeExtra(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
     RT_NOREF(offPort, pvUser);
@@ -3875 +3878 @@
     {
         Log(("vbeR3IOPortWriteVbeExtra: addr=%#RX32\n", u32));
-        pThis->u16VBEExtraAddress = u32;
+        pThisCC->u16VBEExtraAddress = u32;
     }
     else
@@ -3891 +3894 @@
 vbeR3IoPortReadVbeExtra(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
     RT_NOREF(offPort, pvUser);
 
     int rc = VINF_SUCCESS;
-    if (pThis->u16VBEExtraAddress == 0xffff)
+    if (pThisCC->u16VBEExtraAddress == 0xffff)
     {
         Log(("vbeR3IoPortReadVbeExtra: Requested number of 64k video banks\n"));
         *pu32 = pThis->vram_size / _64K;
     }
-    else if (   pThis->u16VBEExtraAddress >= pThis->cbVBEExtraData
-             || pThis->u16VBEExtraAddress + cb > pThis->cbVBEExtraData)
+    else if (   pThisCC->u16VBEExtraAddress >= pThisCC->cbVBEExtraData
+             || pThisCC->u16VBEExtraAddress + cb > pThisCC->cbVBEExtraData)
     {
         *pu32 = 0;
         Log(("vbeR3IoPortReadVbeExtra: Requested address is out of VBE data!!! Address=%#x(%d) cbVBEExtraData=%#x(%d)\n",
-             pThis->u16VBEExtraAddress, pThis->u16VBEExtraAddress, pThis->cbVBEExtraData, pThis->cbVBEExtraData));
+             pThisCC->u16VBEExtraAddress, pThisCC->u16VBEExtraAddress, pThisCC->cbVBEExtraData, pThisCC->cbVBEExtraData));
     }
     else
@@ -3913 +3917 @@
         if (cb == 1)
         {
-            *pu32 = pThis->pbVBEExtraData[pThis->u16VBEExtraAddress] & 0xFF;
+            *pu32 = pThisCC->pbVBEExtraData[pThisCC->u16VBEExtraAddress] & 0xFF;
 
             Log(("vbeR3IoPortReadVbeExtra: cb=%#x %.*Rhxs\n", cb, cb, pu32));
@@ -3919 +3923 @@
         else if (cb == 2)
         {
-            *pu32 =           pThis->pbVBEExtraData[pThis->u16VBEExtraAddress]
-                  | (uint32_t)pThis->pbVBEExtraData[pThis->u16VBEExtraAddress + 1] << 8;
+            *pu32 =           pThisCC->pbVBEExtraData[pThisCC->u16VBEExtraAddress]
+                  | (uint32_t)pThisCC->pbVBEExtraData[pThisCC->u16VBEExtraAddress + 1] << 8;
 
             Log(("vbeR3IoPortReadVbeExtra: cb=%#x %.*Rhxs\n", cb, cb, pu32));
@@ -3942 +3946 @@
  * @param   pThis       The VGA instance data.
  */
-static int vbeR3ParseBitmap(PVGASTATE pThis)
+static int vbeR3ParseBitmap(PVGASTATECC pThisCC)
 {
     /*
      * Get bitmap header data
      */
-    PBMPINFO pBmpInfo = (PBMPINFO)(pThis->pbLogo + sizeof(LOGOHDR));
-    PWINHDR  pWinHdr  = (PWINHDR)(pThis->pbLogo + sizeof(LOGOHDR) + sizeof(BMPINFO));
+    PBMPINFO pBmpInfo = (PBMPINFO)(pThisCC->pbLogo + sizeof(LOGOHDR));
+    PWINHDR  pWinHdr  = (PWINHDR)(pThisCC->pbLogo + sizeof(LOGOHDR) + sizeof(BMPINFO));
 
     if (pBmpInfo->Type == BMP_ID)
@@ -3957 +3961 @@
             {
                 POS2HDR pOs2Hdr = (POS2HDR)pWinHdr;
-                pThis->cxLogo = pOs2Hdr->Width;
-                pThis->cyLogo = pOs2Hdr->Height;
-                pThis->cLogoPlanes = pOs2Hdr->Planes;
-                pThis->cLogoBits = pOs2Hdr->BitCount;
-                pThis->LogoCompression = BMP_COMPRESS_NONE;
-                pThis->cLogoUsedColors = 0;
+                pThisCC->cxLogo = pOs2Hdr->Width;
+                pThisCC->cyLogo = pOs2Hdr->Height;
+                pThisCC->cLogoPlanes = pOs2Hdr->Planes;
+                pThisCC->cLogoBits = pOs2Hdr->BitCount;
+                pThisCC->LogoCompression = BMP_COMPRESS_NONE;
+                pThisCC->cLogoUsedColors = 0;
                 break;
             }
@@ -3969 +3973 @@
             {
                 POS22HDR pOs22Hdr = (POS22HDR)pWinHdr;
-                pThis->cxLogo = pOs22Hdr->Width;
-                pThis->cyLogo = pOs22Hdr->Height;
-                pThis->cLogoPlanes = pOs22Hdr->Planes;
-                pThis->cLogoBits = pOs22Hdr->BitCount;
-                pThis->LogoCompression = pOs22Hdr->Compression;
-                pThis->cLogoUsedColors = pOs22Hdr->ClrUsed;
+                pThisCC->cxLogo = pOs22Hdr->Width;
+                pThisCC->cyLogo = pOs22Hdr->Height;
+                pThisCC->cLogoPlanes = pOs22Hdr->Planes;
+                pThisCC->cLogoBits = pOs22Hdr->BitCount;
+                pThisCC->LogoCompression = pOs22Hdr->Compression;
+                pThisCC->cLogoUsedColors = pOs22Hdr->ClrUsed;
                 break;
             }
 
             case BMP_HEADER_WIN3:
-                pThis->cxLogo = pWinHdr->Width;
-                pThis->cyLogo = pWinHdr->Height;
-                pThis->cLogoPlanes = pWinHdr->Planes;
-                pThis->cLogoBits = pWinHdr->BitCount;
-                pThis->LogoCompression = pWinHdr->Compression;
-                pThis->cLogoUsedColors = pWinHdr->ClrUsed;
+                pThisCC->cxLogo = pWinHdr->Width;
+                pThisCC->cyLogo = pWinHdr->Height;
+                pThisCC->cLogoPlanes = pWinHdr->Planes;
+                pThisCC->cLogoBits = pWinHdr->BitCount;
+                pThisCC->LogoCompression = pWinHdr->Compression;
+                pThisCC->cLogoUsedColors = pWinHdr->ClrUsed;
                 break;
 
@@ -3993 +3997 @@
         }
 
-        AssertLogRelMsgReturn(pThis->cxLogo <= LOGO_MAX_WIDTH && pThis->cyLogo <= LOGO_MAX_HEIGHT,
-                              ("Bitmap %ux%u is too big.\n", pThis->cxLogo, pThis->cyLogo),
+        AssertLogRelMsgReturn(pThisCC->cxLogo <= LOGO_MAX_WIDTH && pThisCC->cyLogo <= LOGO_MAX_HEIGHT,
+                              ("Bitmap %ux%u is too big.\n", pThisCC->cxLogo, pThisCC->cyLogo),
                               VERR_INVALID_PARAMETER);
 
-        AssertLogRelMsgReturn(pThis->cLogoPlanes == 1,
-                              ("Bitmap planes %u != 1.\n", pThis->cLogoPlanes),
+        AssertLogRelMsgReturn(pThisCC->cLogoPlanes == 1,
+                              ("Bitmap planes %u != 1.\n", pThisCC->cLogoPlanes),
                               VERR_INVALID_PARAMETER);
 
-        AssertLogRelMsgReturn(pThis->cLogoBits == 4 || pThis->cLogoBits == 8 || pThis->cLogoBits == 24,
-                              ("Unsupported %u depth.\n", pThis->cLogoBits),
+        AssertLogRelMsgReturn(pThisCC->cLogoBits == 4 || pThisCC->cLogoBits == 8 || pThisCC->cLogoBits == 24,
+                              ("Unsupported %u depth.\n", pThisCC->cLogoBits),
                               VERR_INVALID_PARAMETER);
 
-        AssertLogRelMsgReturn(pThis->cLogoUsedColors <= 256,
-                              ("Unsupported %u colors.\n", pThis->cLogoUsedColors),
+        AssertLogRelMsgReturn(pThisCC->cLogoUsedColors <= 256,
+                              ("Unsupported %u colors.\n", pThisCC->cLogoUsedColors),
                               VERR_INVALID_PARAMETER);
 
-        AssertLogRelMsgReturn(pThis->LogoCompression == BMP_COMPRESS_NONE,
-                               ("Unsupported %u compression.\n", pThis->LogoCompression),
+        AssertLogRelMsgReturn(pThisCC->LogoCompression == BMP_COMPRESS_NONE,
+                               ("Unsupported %u compression.\n", pThisCC->LogoCompression),
                                VERR_INVALID_PARAMETER);
 
@@ -4016 +4020 @@
          * Read bitmap palette
          */
-        if (!pThis->cLogoUsedColors)
-            pThis->cLogoPalEntries = 1 << (pThis->cLogoPlanes * pThis->cLogoBits);
+        if (!pThisCC->cLogoUsedColors)
+            pThisCC->cLogoPalEntries = 1 << (pThisCC->cLogoPlanes * pThisCC->cLogoBits);
         else
-            pThis->cLogoPalEntries = pThis->cLogoUsedColors;
-
-        if (pThis->cLogoPalEntries)
+            pThisCC->cLogoPalEntries = pThisCC->cLogoUsedColors;
+
+        if (pThisCC->cLogoPalEntries)
         {
-            const uint8_t *pbPal = pThis->pbLogo + sizeof(LOGOHDR) + sizeof(BMPINFO) + pWinHdr->Size; /* ASSUMES Size location (safe) */
-
-            for (uint16_t i = 0; i < pThis->cLogoPalEntries; i++)
+            const uint8_t *pbPal = pThisCC->pbLogo + sizeof(LOGOHDR) + sizeof(BMPINFO) + pWinHdr->Size; /* ASSUMES Size location (safe) */
+
+            for (uint16_t i = 0; i < pThisCC->cLogoPalEntries; i++)
             {
                 uint16_t j;
@@ -4038 +4042 @@
 
                 pbPal++; /* skip unused byte */
-                pThis->au32LogoPalette[i] = u32Pal;
+                pThisCC->au32LogoPalette[i] = u32Pal;
             }
         }
@@ -4045 +4049 @@
          * Bitmap data offset
          */
-        pThis->pbLogoBitmap = pThis->pbLogo + sizeof(LOGOHDR) + pBmpInfo->Offset;
+        pThisCC->pbLogoBitmap = pThisCC->pbLogo + sizeof(LOGOHDR) + pBmpInfo->Offset;
     }
     else
@@ -4208 +4212 @@
 vbeR3IoPortWriteCmdLogo(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     RT_NOREF(pvUser, offPort);
 
@@ -4219 +4224 @@
         {
             case LOGO_CMD_SET_OFFSET:
-                pThis->offLogoData = u32 & 0xFF;
+                pThisCC->offLogoData = u32 & 0xFF;
                 break;
 
@@ -4225 +4230 @@
             {
                 uint8_t         iStep = u32 & 0xFF;
-                const uint8_t  *pbSrc = pThis->pbLogoBitmap;
+                const uint8_t  *pbSrc = pThisCC->pbLogoBitmap;
                 uint8_t        *pbDst;
-                PCLOGOHDR       pLogoHdr = (PCLOGOHDR)pThis->pbLogo;
+                PCLOGOHDR       pLogoHdr = (PCLOGOHDR)pThisCC->pbLogo;
                 uint32_t        offDirty = 0;
-                uint16_t        xLogo = (LOGO_MAX_WIDTH - pThis->cxLogo) / 2;
-                uint16_t        yLogo = LOGO_MAX_HEIGHT - (LOGO_MAX_HEIGHT - pThis->cyLogo) / 2;
+                uint16_t        xLogo = (LOGO_MAX_WIDTH - pThisCC->cxLogo) / 2;
+                uint16_t        yLogo = LOGO_MAX_HEIGHT - (LOGO_MAX_HEIGHT - pThisCC->cyLogo) / 2;
 
                 /* Check VRAM size */
@@ -4237 +4242 @@
 
                 if (pThis->vram_size >= LOGO_MAX_SIZE * 2)
-                    pbDst = pThis->vram_ptrR3 + LOGO_MAX_SIZE;
+                    pbDst = pThisCC->pbVRam + LOGO_MAX_SIZE;
                 else
-                    pbDst = pThis->vram_ptrR3;
+                    pbDst = pThisCC->pbVRam;
 
                 /* Clear screen - except on power on... */
-                if (!pThis->fLogoClearScreen)
+                if (!pThisCC->fLogoClearScreen)
                 {
                     /* Clear vram */
@@ -4249 +4254 @@
                         for (int j = 0; j < LOGO_MAX_HEIGHT; j++)
                             *pu32Dst++ = 0;
-                    pThis->fLogoClearScreen = true;
+                    pThisCC->fLogoClearScreen = true;
                 }
 
                 /* Show the bitmap. */
-                vbeR3ShowBitmap(pThis->cLogoBits, xLogo, yLogo,
-                              pThis->cxLogo, pThis->cyLogo,
-                              false, iStep, &pThis->au32LogoPalette[0],
-                              pbSrc, pbDst);
+                vbeR3ShowBitmap(pThisCC->cLogoBits, xLogo, yLogo,
+                                pThisCC->cxLogo, pThisCC->cyLogo,
+                                false, iStep, &pThisCC->au32LogoPalette[0],
+                                pbSrc, pbDst);
 
                 /* Show the 'Press F12...' text. */
                 if (pLogoHdr->fu8ShowBootMenu == 2)
                     vbeR3ShowBitmap(1, LOGO_F12TEXT_X, LOGO_F12TEXT_Y,
-                                  LOGO_F12TEXT_WIDTH, LOGO_F12TEXT_HEIGHT,
-                                  pThis->fBootMenuInverse, iStep, &pThis->au32LogoPalette[0],
-                                  &g_abLogoF12BootText[0], pbDst);
+                                    LOGO_F12TEXT_WIDTH, LOGO_F12TEXT_HEIGHT,
+                                    pThisCC->fBootMenuInverse, iStep, &pThisCC->au32LogoPalette[0],
+                                    &g_abLogoF12BootText[0], pbDst);
 
                 /* Blit the offscreen buffer. */
                 if (pThis->vram_size >= LOGO_MAX_SIZE * 2)
                 {
-                    uint32_t *pu32TmpDst = (uint32_t *)pThis->vram_ptrR3;
-                    uint32_t *pu32TmpSrc = (uint32_t *)(pThis->vram_ptrR3 + LOGO_MAX_SIZE);
+                    uint32_t *pu32TmpDst = (uint32_t *)pThisCC->pbVRam;
+                    uint32_t *pu32TmpSrc = (uint32_t *)(pThisCC->pbVRam + LOGO_MAX_SIZE);
                     for (int i = 0; i < LOGO_MAX_WIDTH; i++)
                     {
@@ -4288 +4293 @@
             default:
                 Log(("vbeR3IoPortWriteCmdLogo: invalid command %d\n", u32));
-                pThis->LogoCommand = LOGO_CMD_NOP;
+                pThisCC->LogoCommand = LOGO_CMD_NOP;
                 break;
         }
@@ -4307 +4312 @@
 vbeR3IoPortReadCmdLogo(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     RT_NOREF(pvUser, offPort);
 
-    if (pThis->offLogoData + cb > pThis->cbLogo)
+    if (pThisCC->offLogoData + cb > pThisCC->cbLogo)
     {
         Log(("vbeR3IoPortReadCmdLogo: Requested address is out of Logo data!!! offLogoData=%#x(%d) cbLogo=%#x(%d)\n",
-             pThis->offLogoData, pThis->offLogoData, pThis->cbLogo, pThis->cbLogo));
+             pThisCC->offLogoData, pThisCC->offLogoData, pThisCC->cbLogo, pThisCC->cbLogo));
         return VINF_SUCCESS;
     }
     RT_UNTRUSTED_VALIDATED_FENCE();
 
-    PCRTUINT64U p = (PCRTUINT64U)&pThis->pbLogo[pThis->offLogoData];
+    PCRTUINT64U p = (PCRTUINT64U)&pThisCC->pbLogo[pThisCC->offLogoData];
     switch (cb)
     {
@@ -4327 +4332 @@
         default: AssertFailed(); break;
     }
-    Log(("vbeR3IoPortReadCmdLogo: LogoOffset=%#x(%d) cb=%#x %.*Rhxs\n", pThis->offLogoData, pThis->offLogoData, cb, cb, pu32));
-
-    pThis->LogoCommand = LOGO_CMD_NOP;
-    pThis->offLogoData += cb;
+    Log(("vbeR3IoPortReadCmdLogo: LogoOffset=%#x(%d) cb=%#x %.*Rhxs\n", pThisCC->offLogoData, pThisCC->offLogoData, cb, cb, pu32));
+
+    pThisCC->LogoCommand = LOGO_CMD_NOP;
+    pThisCC->offLogoData += cb;
 
     return VINF_SUCCESS;
@@ -4454 +4459 @@
  * Worker for vgaR3InfoText.
  *
- * @param   pThis       The vga state.
+ * @param   pThis       The shared VGA state.
+ * @param   pThisCC     The VGA state for ring-3.
  * @param   pHlp        Callback functions for doing output.
  * @param   offStart    Where to start dumping (relative to the VRAM).
@@ -4464 +4470 @@
  *                      (exclusive).
  */
-static void vgaR3InfoTextWorker(PVGASTATE pThis, PCDBGFINFOHLP pHlp,
+static void vgaR3InfoTextWorker(PVGASTATE pThis, PVGASTATER3 pThisCC, PCDBGFINFOHLP pHlp,
                                 uint32_t offStart, uint32_t cbLine,
                                 uint32_t cCols, uint32_t cRows,
@@ -4478 +4484 @@
 
     /* Do the dumping. */
-    uint8_t const *pbSrcOuter = pThis->CTX_SUFF(vram_ptr) + offStart;
+    uint8_t const *pbSrcOuter = pThisCC->pbVRam + offStart;
     uint32_t iRow;
     for (iRow = 0; iRow < cRows; iRow++, pbSrcOuter += cbLine)
     {
-        if ((uintptr_t)(pbSrcOuter + cbLine - pThis->CTX_SUFF(vram_ptr)) > pThis->vram_size) {
+        if ((uintptr_t)(pbSrcOuter + cbLine - pThisCC->pbVRam) > pThis->vram_size) {
             pHlp->pfnPrintf(pHlp, "The last %u row/rows is/are outside the VRAM.\n", cRows - iRow);
             break;
@@ -4518 +4524 @@
 static DECLCALLBACK(void) vgaR3InfoText(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
 
     /*
@@ -4542 +4549 @@
     if (!(pThis->gr[6] & 1))
     {
-        uint8_t *pbSrc = pThis->vram_ptrR3;
+        uint8_t *pbSrc = pThisCC->pbVRam;
         if (pbSrc)
         {
@@ -4573 +4580 @@
 
             if (fAll)
-                vgaR3InfoTextWorker(pThis, pHlp, offStart - iScrBegin * cbLine, cbLine,
+                vgaR3InfoTextWorker(pThis, pThisCC, pHlp, offStart - iScrBegin * cbLine, cbLine,
                                     cCols, cRows, iScrBegin, iScrBegin + cScrRows);
             else
-                vgaR3InfoTextWorker(pThis, pHlp, offStart, cbLine, cCols, cScrRows, 0, cScrRows);
+                vgaR3InfoTextWorker(pThis, pThisCC, pHlp, offStart, cbLine, cCols, cScrRows, 0, cScrRows);
         }
         else
@@ -4746 +4753 @@
 static DECLCALLBACK(void *) vgaR3PortQueryInterface(PPDMIBASE pInterface, const char *pszIID)
 {
-    PVGASTATE pThis = RT_FROM_MEMBER(pInterface, VGASTATE, IBase);
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYPORT, &pThis->IPort);
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYPORT, &pThisCC->IPort);
 # if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_CRHGSMI))
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYVBVACALLBACKS, &pThis->IVBVACallbacks);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYVBVACALLBACKS, &pThisCC->IVBVACallbacks);
 # endif
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->ILeds);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds);
     return NULL;
 }
@@ -4764 +4771 @@
 static DECLCALLBACK(int) vgaR3PortQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
 {
-    PVGASTATE pThis = RT_FROM_MEMBER(pInterface, VGASTATE, ILeds);
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, ILeds);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     switch (iLUN)
     {
@@ -4815 +4824 @@
 /* -=-=-=-=-=- Ring 3: IDisplayPort -=-=-=-=-=- */
 
-/** Converts a display port interface pointer to a vga state pointer. */
-# define IDISPLAYPORT_2_VGASTATE(pInterface) ( (PVGASTATE)((uintptr_t)pInterface - RT_OFFSETOF(VGASTATE, IPort)) )
-
-
 /**
  * @interface_method_impl{PDMIDISPLAYPORT,pfnUpdateDisplay}
@@ -4824 +4829 @@
 static DECLCALLBACK(int) vgaR3PortUpdateDisplay(PPDMIDISPLAYPORT pInterface)
 {
-    PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
-    PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PDMDEV_ASSERT_EMT(pDevIns);
 
     int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
@@ -4844 +4850 @@
     /* This should be called only in non VBVA mode. */
 # else
-    if (VBVAUpdateDisplay(pThis) == VINF_SUCCESS)
+    if (VBVAUpdateDisplay(pThis, pThisCC) == VINF_SUCCESS)
     {
         PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
@@ -4863 +4869 @@
     }
 
-    rc = vgaR3UpdateDisplay(pThis, false /*fUpdateAll*/, false /*fFailOnResize*/, true /*reset_dirty*/,
-                            pThis->pDrv, &pThis->graphic_mode);
+    rc = vgaR3UpdateDisplay(pDevIns, pThis, pThisCC, false /*fUpdateAll*/, false /*fFailOnResize*/, true /*reset_dirty*/,
+                            pThisCC->pDrv, &pThis->graphic_mode);
     PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     return rc;
@@ -4873 +4879 @@
  * Internal vgaR3PortUpdateDisplayAll worker called under pThis->CritSect.
  */
-static int vboxR3UpdateDisplayAllInternal(PVGASTATE pThis, bool fFailOnResize)
-{
-    PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
-
+static int vboxR3UpdateDisplayAllInternal(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, bool fFailOnResize)
+{
 # ifdef VBOX_WITH_VMSVGA
     if (    !pThis->svga.fEnabled
@@ -4896 +4900 @@
     pThis->graphic_mode = -1; /* force full update */
 
-    return vgaR3UpdateDisplay(pThis, true /*fUpdateAll*/, fFailOnResize, true /*reset_dirty*/, pThis->pDrv, &pThis->graphic_mode);
+    return vgaR3UpdateDisplay(pDevIns, pThis, pThisCC, true /*fUpdateAll*/, fFailOnResize,
+                              true /*reset_dirty*/, pThisCC->pDrv, &pThis->graphic_mode);
 }
 
@@ -4905 +4910 @@
 static DECLCALLBACK(int) vgaR3PortUpdateDisplayAll(PPDMIDISPLAYPORT pInterface, bool fFailOnResize)
 {
-    PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     PDMDEV_ASSERT_EMT(pDevIns);
 
@@ -4918 +4924 @@
     AssertRC(rc);
 
-    rc = vboxR3UpdateDisplayAllInternal(pThis, fFailOnResize);
+    rc = vboxR3UpdateDisplayAllInternal(pDevIns, pThis, pThisCC, fFailOnResize);
 
     PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
@@ -4930 +4936 @@
 static DECLCALLBACK(int) vgaR3PortSetRefreshRate(PPDMIDISPLAYPORT pInterface, uint32_t cMilliesInterval)
 {
-    PVGASTATE  pThis   = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PPDMDEVINS pDevIns = pThis->pDevInsR3;
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
 
     /*
@@ -4955 +4962 @@
 static DECLCALLBACK(int) vgaR3PortQueryVideoMode(PPDMIDISPLAYPORT pInterface, uint32_t *pcBits, uint32_t *pcx, uint32_t *pcy)
 {
-    PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
-
-    if (!pcBits)
-        return VERR_INVALID_PARAMETER;
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+
+    AssertReturn(pcBits, VERR_INVALID_PARAMETER);
+
     *pcBits = vgaR3GetBpp(pThis);
     if (pcx)
@@ -4974 +4983 @@
                                                  uint32_t *pcx, uint32_t *pcy)
 {
-    PVGASTATE  pThis   = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
-    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PDMDEV_ASSERT_EMT(pDevIns);
 
     LogFlow(("vgaR3PortTakeScreenshot: ppbData=%p pcbData=%p pcx=%p pcy=%p\n", ppbData, pcbData, pcx, pcy));
@@ -5035 +5045 @@
              * If there is a pending resize, the function will fail.
              */
-            rc = vgaR3UpdateDisplay(pThis, false /*fUpdateAll*/, true /*fFailOnResize*/, false /*reset_dirty*/,
-                                    &Connector, &cur_graphic_mode);
+            rc = vgaR3UpdateDisplay(pDevIns, pThis, pThisCC, false /*fUpdateAll*/, true /*fFailOnResize*/,
+                                    false /*reset_dirty*/, &Connector, &cur_graphic_mode);
 
             pThis->fRenderVRAM = fSavedRenderVRAM;
@@ -5093 +5103 @@
                                              uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
 {
-    PVGASTATE       pThis   = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PPDMDEVINS      pDevIns = pThis->CTX_SUFF(pDevIns);
-    int             rc;
-    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PDMDEV_ASSERT_EMT(pDevIns);
     LogFlow(("vgaR3PortDisplayBlt: pvData=%p x=%d y=%d cx=%d cy=%d\n", pvData, x, y, cx, cy));
 
-    rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
+    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     AssertRC(rc);
 
@@ -5106 +5116 @@
      */
     if (    pvData
-        &&  x      <  pThis->pDrv->cx
-        &&  cx     <= pThis->pDrv->cx
-        &&  cx + x <= pThis->pDrv->cx
-        &&  y      <  pThis->pDrv->cy
-        &&  cy     <= pThis->pDrv->cy
-        &&  cy + y <= pThis->pDrv->cy)
+        &&  x      <  pThisCC->pDrv->cx
+        &&  cx     <= pThisCC->pDrv->cx
+        &&  cx + x <= pThisCC->pDrv->cx
+        &&  y      <  pThisCC->pDrv->cy
+        &&  cy     <= pThisCC->pDrv->cy
+        &&  cy + y <= pThisCC->pDrv->cy)
     {
         /*
@@ -5117 +5127 @@
          */
         size_t  cbPixelDst = 0;
-        switch (pThis->pDrv->cBits)
+        switch (pThisCC->pDrv->cBits)
         {
             case 8:
@@ -5143 +5153 @@
             size_t      cbLineSrc   = cx * 4; /* 32 bits per pixel. */
             uint8_t    *pbSrc       = (uint8_t *)pvData;
-            size_t      cbLineDst   = pThis->pDrv->cbScanline;
-            uint8_t    *pbDst       = pThis->pDrv->pbData + y * cbLineDst + x * cbPixelDst;
+            size_t      cbLineDst   = pThisCC->pDrv->cbScanline;
+            uint8_t    *pbDst       = pThisCC->pDrv->pbData + y * cbLineDst + x * cbPixelDst;
             uint32_t    cyLeft      = cy;
-            vga_draw_line_func *pfnVgaDrawLine = vga_draw_line_table[VGA_DRAW_LINE32 * 4 + vgaR3GetDepthIndex(pThis->pDrv->cBits)];
+            vga_draw_line_func *pfnVgaDrawLine = vga_draw_line_table[VGA_DRAW_LINE32 * 4 + vgaR3GetDepthIndex(pThisCC->pDrv->cBits)];
             Assert(pfnVgaDrawLine);
             while (cyLeft-- > 0)
             {
-                pfnVgaDrawLine(pThis, pbDst, pbSrc, cx);
+                pfnVgaDrawLine(pThis, pThisCC, pbDst, pbSrc, cx);
                 pbDst += cbLineDst;
                 pbSrc += cbLineSrc;
@@ -5158 +5168 @@
              * Invalidate the area.
              */
-            pThis->pDrv->pfnUpdateRect(pThis->pDrv, x, y, cx, cy);
+            pThisCC->pDrv->pfnUpdateRect(pThisCC->pDrv, x, y, cx, cy);
         }
     }
@@ -5176 +5186 @@
 static DECLCALLBACK(void) vgaR3PortUpdateDisplayRect(PPDMIDISPLAYPORT pInterface, int32_t x, int32_t y, uint32_t cx, uint32_t cy)
 {
-    PVGASTATE  pThis   = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     uint32_t v;
-    vga_draw_line_func *vga_draw_line;
 
     uint32_t cbPixelDst;
@@ -5210 +5220 @@
     }
 
-    Assert(pThis->pDrv);
-    Assert(pThis->pDrv->pbData);
+    Assert(pThisCC->pDrv);
+    Assert(pThisCC->pDrv->pbData);
 
     /* Correct negative x and y coordinates. */
@@ -5229 +5239 @@
 
     /* Also check if coords are greater than the display resolution. */
-    if (x + cx > pThis->pDrv->cx)
+    if (x + cx > pThisCC->pDrv->cx)
     {
         // x < 0 is not possible here
-        cx = pThis->pDrv->cx > (uint32_t)x? pThis->pDrv->cx - x: 0;
-    }
-
-    if (y + cy > pThis->pDrv->cy)
+        cx = pThisCC->pDrv->cx > (uint32_t)x? pThisCC->pDrv->cx - x: 0;
+    }
+
+    if (y + cy > pThisCC->pDrv->cy)
     {
         // y < 0 is not possible here
-        cy = pThis->pDrv->cy > (uint32_t)y? pThis->pDrv->cy - y: 0;
+        cy = pThisCC->pDrv->cy > (uint32_t)y? pThisCC->pDrv->cy - y: 0;
     }
 
@@ -5262 +5272 @@
 
     /* Choose the rendering function. */
-    switch(pThis->get_bpp(pThis))
+    switch(pThisCC->get_bpp(pThis))
     {
         default:
@@ -5289 +5299 @@
     }
 
-    vga_draw_line = vga_draw_line_table[v * 4 + vgaR3GetDepthIndex(pThis->pDrv->cBits)];
+    vga_draw_line_func *pfnVgaDrawLine = vga_draw_line_table[v * 4 + vgaR3GetDepthIndex(pThisCC->pDrv->cBits)];
 
     /* Compute source and destination addresses and pitches. */
-    cbPixelDst = (pThis->pDrv->cBits + 7) / 8;
-    cbLineDst  = pThis->pDrv->cbScanline;
-    pbDst      = pThis->pDrv->pbData + y * cbLineDst + x * cbPixelDst;
-
-    cbPixelSrc = (pThis->get_bpp(pThis) + 7) / 8;
+    cbPixelDst = (pThisCC->pDrv->cBits + 7) / 8;
+    cbLineDst  = pThisCC->pDrv->cbScanline;
+    pbDst      = pThisCC->pDrv->pbData + y * cbLineDst + x * cbPixelDst;
+
+    cbPixelSrc = (pThisCC->get_bpp(pThis) + 7) / 8;
     uint32_t offSrc, u32Dummy;
-    pThis->get_offsets(pThis, &cbLineSrc, &offSrc, &u32Dummy);
+    pThisCC->get_offsets(pThis, &cbLineSrc, &offSrc, &u32Dummy);
 
     /* Assume that rendering is performed only on visible part of VRAM.
      * This is true because coordinates were verified.
      */
-    pbSrc = pThis->vram_ptrR3;
+    pbSrc = pThisCC->pbVRam;
     pbSrc += offSrc * 4 + y * cbLineSrc + x * cbPixelSrc;
 
@@ -5314 +5324 @@
     while (cy-- > 0)
     {
-        vga_draw_line (pThis, pbDst, pbSrc, cx);
+        pfnVgaDrawLine(pThis, pThisCC, pbDst, pbSrc, cx);
         pbDst += cbLineDst;
         pbSrc += cbLineSrc;
@@ -5337 +5347 @@
                   uint32_t cbDstLine, uint32_t cDstBitsPerPixel)
 {
-    PVGASTATE  pThis   = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     uint32_t v;
-    vga_draw_line_func *vga_draw_line;
 
 # ifdef DEBUG_sunlover
@@ -5347 +5357 @@
 
     Assert(pInterface);
-    Assert(pThis->pDrv);
+    Assert(pThisCC->pDrv);
 
     int32_t  xSrcCorrected = xSrc;
@@ -5422 +5432 @@
      */
     if (   (pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) == 0
-        && VBVAIsPaused(pThis)
+        && VBVAIsPaused(pThisCC)
 # ifdef VBOX_WITH_VMSVGA
         && !pThis->svga.fEnabled
@@ -5457 +5467 @@
     }
 
-    vga_draw_line = vga_draw_line_table[v * 4 + vgaR3GetDepthIndex(cDstBitsPerPixel)];
+    vga_draw_line_func *pfnVgaDrawLine = vga_draw_line_table[v * 4 + vgaR3GetDepthIndex(cDstBitsPerPixel)];
 
     /* Compute source and destination addresses and pitches. */
@@ -5474 +5484 @@
     while (cyCorrected-- > 0)
     {
-        vga_draw_line(pThis, pbDstCur, pbSrcCur, cxCorrected);
+        pfnVgaDrawLine(pThis, pThisCC, pbDstCur, pbSrcCur, cxCorrected);
         pbDstCur += cbLineDst;
         pbSrcCur += cbLineSrc;
@@ -5492 +5502 @@
 static DECLCALLBACK(void) vgaR3PortSetRenderVRAM(PPDMIDISPLAYPORT pInterface, bool fRender)
 {
-    PVGASTATE  pThis   = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
 
     LogFlow(("vgaR3PortSetRenderVRAM: fRender = %d\n", fRender));
@@ -5530 +5541 @@
 static DECLCALLBACK(void) vgaTimerRefresh(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
 {
-    PVGASTATE pThis = (PVGASTATE)pvUser;
-    RT_NOREF(pTimer);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    RT_NOREF(pvUser, pTimer);
 
     if (pThis->fScanLineCfg & VBVASCANLINECFG_ENABLE_VSYNC_IRQ)
-        VBVARaiseIrq(pThis, HGSMIHOSTFLAGS_VSYNC);
-
-    if (pThis->pDrv)
-        pThis->pDrv->pfnRefresh(pThis->pDrv);
+        VBVARaiseIrq(pDevIns, pThis, pThisCC, HGSMIHOSTFLAGS_VSYNC);
+
+    if (pThisCC->pDrv)
+        pThisCC->pDrv->pfnRefresh(pThisCC->pDrv);
 
     if (pThis->cMilliesRefreshInterval)
@@ -5543 +5555 @@
 
 # ifdef VBOX_WITH_VIDEOHWACCEL
-    vbvaTimerCb(pThis);
+    vbvaTimerCb(pDevIns, pThis, pThisCC);
 # endif
 
@@ -5561 +5573 @@
  * Helper for VMSVGA.
  */
-int vgaR3RegisterVRAMHandler(PVGASTATE pVGAState, uint64_t cbFrameBuffer)
-{
-    PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
-    Assert(pVGAState->GCPhysVRAM);
-
+int vgaR3RegisterVRAMHandler(PPDMDEVINS pDevIns, PVGASTATE pThis, uint64_t cbFrameBuffer)
+{
+    Assert(pThis->GCPhysVRAM);
     int rc = PGMHandlerPhysicalRegister(PDMDevHlpGetVM(pDevIns),
-                                        pVGAState->GCPhysVRAM, pVGAState->GCPhysVRAM + (cbFrameBuffer - 1),
-                                        pVGAState->hLfbAccessHandlerType, pVGAState, pDevIns->pvInstanceDataR0,
+                                        pThis->GCPhysVRAM, pThis->GCPhysVRAM + (cbFrameBuffer - 1),
+                                        pThis->hLfbAccessHandlerType, pThis, pDevIns->pvInstanceDataR0,
                                         pDevIns->pvInstanceDataRC, "VGA LFB");
 
@@ -5579 +5589 @@
  * Helper for VMSVGA.
  */
-int vgaR3UnregisterVRAMHandler(PVGASTATE pVGAState)
-{
-    PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
-
-    Assert(pVGAState->GCPhysVRAM);
-    int rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns), pVGAState->GCPhysVRAM);
+int vgaR3UnregisterVRAMHandler(PPDMDEVINS pDevIns, PVGASTATE pThis)
+{
+    Assert(pThis->GCPhysVRAM);
+    int rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns), pThis->GCPhysVRAM);
     AssertRC(rc);
     return rc;
@@ -5620 +5628 @@
         {
             rc = PGMHandlerPhysicalRegister(PDMDevHlpGetVM(pDevIns), GCPhysAddress, GCPhysAddress + (pThis->vram_size - 1),
-                                            pThis->hLfbAccessHandlerType, pThis, pDevIns->pvInstanceDataR0,
-                                            pDevIns->pvInstanceDataRC, "VGA LFB");
+                                            pThis->hLfbAccessHandlerType, pDevIns, pDevIns->pDevInsR0RemoveMe,
+                                            pDevIns->pDevInsForRC, "VGA LFB");
             AssertLogRelRC(rc);
             if (RT_SUCCESS(rc))
@@ -5819 +5827 @@
 static DECLCALLBACK(int) vgaR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
-    PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
 
 # ifdef VBOX_WITH_VDMA
-    vboxVDMASaveStateExecPrep(pThis->pVdma);
+    vboxVDMASaveStateExecPrep(pThisCC->pVdma);
 # endif
 
@@ -5843 +5852 @@
     rc = pHlp->pfnSSMPutU32(pSSM, 1);
     AssertRCReturn(rc, rc);
-    rc = vboxVDMASaveStateExecPerform(pHlp, pThis->pVdma, pSSM);
+    rc = vboxVDMASaveStateExecPerform(pHlp, pThisCC->pVdma, pSSM);
 # else
     rc = pHlp->pfnSSMPutU32(pSSM, 0);
@@ -5850 +5859 @@
 
 # ifdef VBOX_WITH_VDMA
-    vboxVDMASaveStateExecDone(pThis->pVdma);
+    vboxVDMASaveStateExecDone(pThisCC->pVdma);
 # endif
 
@@ -5872 +5881 @@
 static DECLCALLBACK(int) vgaR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
 {
-    PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
-    PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
     int             rc;
 
@@ -5931 +5941 @@
                 if (u32 == 1)
                 {
-                    rc = vboxVDMASaveLoadExecPerform(pHlp, pThis->pVdma, pSSM, uVersion);
+                    rc = vboxVDMASaveLoadExecPerform(pHlp, pThisCC->pVdma, pSSM, uVersion);
                     AssertRCReturn(rc, rc);
                 }
@@ -5962 +5972 @@
 static DECLCALLBACK(int) vgaR3LoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
-    RT_NOREF(pSSM);
-    int rc = VINF_SUCCESS;
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    int         rc;
+    RT_NOREF(pThisCC, pThis, pSSM);
 
 # ifdef VBOX_WITH_HGSMI
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     rc = vboxVBVALoadStateDone(pDevIns);
     AssertRCReturn(rc, rc);
 # ifdef VBOX_WITH_VDMA
-    rc = vboxVDMASaveLoadDone(pThis->pVdma);
+    rc = vboxVDMASaveLoadDone(pThisCC->pVdma);
     AssertRCReturn(rc, rc);
 # endif
     /* Now update the current VBVA state which depends on VBE registers. vboxVBVALoadStateDone cleared the state. */
-    VBVAOnVBEChanged(pThis);
+    VBVAOnVBEChanged(pThis, pThisCC);
 # endif
 # ifdef VBOX_WITH_VMSVGA
@@ -5983 +5994 @@
     }
 # endif
-    return rc;
+    return VINF_SUCCESS;
 }
 
@@ -5994 +6005 @@
 static DECLCALLBACK(void) vgaR3Resume(PPDMDEVINS pDevIns)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
-    VBVAOnResume(pThis);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    VBVAOnResume(pDevIns, pThis, pThisCC);
 }
 
@@ -6004 +6016 @@
 static DECLCALLBACK(void)  vgaR3Reset(PPDMDEVINS pDevIns)
 {
-    PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     char           *pchStart;
     char           *pchEnd;
     LogFlow(("vgaReset\n"));
 
-    if (pThis->pVdma)
-        vboxVDMAReset(pThis->pVdma);
+    if (pThisCC->pVdma)
+        vboxVDMAReset(pThisCC->pVdma);
 
 # ifdef VBOX_WITH_VMSVGA
@@ -6018 +6031 @@
 
 # ifdef VBOX_WITH_HGSMI
-    VBVAReset(pThis);
+    VBVAReset(pDevIns, pThis, pThisCC);
 # endif
 
 
     /* Clear the VRAM ourselves. */
-    if (pThis->vram_ptrR3 && pThis->vram_size)
-        memset(pThis->vram_ptrR3, 0, pThis->vram_size);
+    if (pThisCC->pbVRam && pThis->vram_size)
+        memset(pThisCC->pbVRam, 0, pThis->vram_size);
 
     /*
@@ -6046 +6059 @@
      * Restore and re-init some bits.
      */
-    pThis->get_bpp        = vgaR3GetBpp;
-    pThis->get_offsets    = vgaR3GetOffsets;
-    pThis->get_resolution = vgaR3GetResolution;
+    pThisCC->get_bpp        = vgaR3GetBpp;
+    pThisCC->get_offsets    = vgaR3GetOffsets;
+    pThisCC->get_resolution = vgaR3GetResolution;
     pThis->graphic_mode   = -1;         /* Force full update. */
 # ifdef CONFIG_BOCHS_VBE
@@ -6078 +6091 @@
      * Reset the logo data.
      */
-    pThis->LogoCommand = LOGO_CMD_NOP;
-    pThis->offLogoData = 0;
+    pThisCC->LogoCommand = LOGO_CMD_NOP;
+    pThisCC->offLogoData = 0;
 
     /* notify port handler */
-    if (pThis->pDrv)
+    if (pThisCC->pDrv)
     {
         PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect); /* hack around lock order issue. */
-        pThis->pDrv->pfnReset(pThis->pDrv);
-        pThis->pDrv->pfnVBVAMousePointerShape(pThis->pDrv, false, false, 0, 0, 0, 0, NULL);
+        pThisCC->pDrv->pfnReset(pThisCC->pDrv);
+        pThisCC->pDrv->pfnVBVAMousePointerShape(pThisCC->pDrv, false, false, 0, 0, 0, 0, NULL);
         PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     }
@@ -6106 +6119 @@
 static DECLCALLBACK(void) vgaR3PowerOn(PPDMDEVINS pDevIns)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
 # ifdef VBOX_WITH_VMSVGA
     vmsvgaR3PowerOn(pDevIns);
 # endif
-    VBVAOnResume(pThis);
+    VBVAOnResume(pDevIns, pThis, pThisCC);
 }
 
@@ -6125 +6139 @@
         LogFlow(("vgaRelocate: offDelta = %08X\n", offDelta));
 
-        pThis->vram_ptrRC += offDelta;
+        pThisRC->pbVRam += offDelta;
         pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
     }
@@ -6141 +6155 @@
 static DECLCALLBACK(int)  vgaAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
 {
-    PVGASTATE   pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
 
     AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
@@ -6152 +6167 @@
         case 0:
         {
-            int rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->IBase, &pThis->pDrvBase, "Display Port");
+            int rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThisCC->IBase, &pThisCC->pDrvBase, "Display Port");
             if (RT_SUCCESS(rc))
             {
-                pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIDISPLAYCONNECTOR);
-                if (pThis->pDrv)
+                pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMIDISPLAYCONNECTOR);
+                if (pThisCC->pDrv)
                 {
-                    /* pThis->pDrv->pbData can be NULL when there is no framebuffer. */
-                    if (    pThis->pDrv->pfnRefresh
-                        &&  pThis->pDrv->pfnResize
-                        &&  pThis->pDrv->pfnUpdateRect)
+                    /* pThisCC->pDrv->pbData can be NULL when there is no framebuffer. */
+                    if (    pThisCC->pDrv->pfnRefresh
+                        &&  pThisCC->pDrv->pfnResize
+                        &&  pThisCC->pDrv->pfnUpdateRect)
                         rc = VINF_SUCCESS;
                     else
                     {
-                        Assert(pThis->pDrv->pfnRefresh);
-                        Assert(pThis->pDrv->pfnResize);
-                        Assert(pThis->pDrv->pfnUpdateRect);
-                        pThis->pDrv = NULL;
-                        pThis->pDrvBase = NULL;
+                        Assert(pThisCC->pDrv->pfnRefresh);
+                        Assert(pThisCC->pDrv->pfnResize);
+                        Assert(pThisCC->pDrv->pfnUpdateRect);
+                        pThisCC->pDrv = NULL;
+                        pThisCC->pDrvBase = NULL;
                         rc = VERR_INTERNAL_ERROR;
                     }
@@ -6175 +6190 @@
                     if(rc == VINF_SUCCESS)
                     {
-                        rc = vbvaVHWAConstruct(pThis);
+                        rc = vbvaVHWAConstruct(pDevIns, pThis, pThisCC);
                         if (rc != VERR_NOT_IMPLEMENTED)
                             AssertRC(rc);
@@ -6184 +6199 @@
                 {
                     AssertMsgFailed(("LUN #0 doesn't have a display connector interface! rc=%Rrc\n", rc));
-                    pThis->pDrvBase = NULL;
+                    pThisCC->pDrvBase = NULL;
                     rc = VERR_PDM_MISSING_INTERFACE;
                 }
@@ -6212 +6227 @@
 static DECLCALLBACK(void)  vgaDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
 {
-    RT_NOREF1(fFlags);
-    PVGASTATE   pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     AssertMsg(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG, ("VGA device does not support hotplugging\n"));
+    RT_NOREF(fFlags);
 
     /*
@@ -6223 +6238 @@
         /* LUN #0: Display port. */
         case 0:
-            pThis->pDrv = NULL;
-            pThis->pDrvBase = NULL;
+            pThisCC->pDrv = NULL;
+            pThisCC->pDrvBase = NULL;
             break;
 
@@ -6240 +6255 @@
 {
     PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
-
-    PVGASTATE   pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
     LogFlow(("vgaR3Destruct:\n"));
 
 # ifdef VBOX_WITH_VDMA
-    if (pThis->pVdma)
-        vboxVDMADestruct(pThis->pVdma);
+    if (pThisCC->pVdma)
+        vboxVDMADestruct(pThisCC->pVdma);
 # endif
 
@@ -6255 +6270 @@
 
 # ifdef VBOX_WITH_HGSMI
-    VBVADestroy(pThis);
+    VBVADestroy(pThisCC);
 # endif
 
@@ -6261 +6276 @@
      * Free MM heap pointers.
      */
-    if (pThis->pbVBEExtraData)
-    {
-        PDMDevHlpMMHeapFree(pDevIns, pThis->pbVBEExtraData);
-        pThis->pbVBEExtraData = NULL;
-    }
-    if (pThis->pbVgaBios)
-    {
-        PDMDevHlpMMHeapFree(pDevIns, pThis->pbVgaBios);
-        pThis->pbVgaBios = NULL;
-    }
-
-    if (pThis->pszVgaBiosFile)
-    {
-        PDMDevHlpMMHeapFree(pDevIns, pThis->pszVgaBiosFile);
-        pThis->pszVgaBiosFile = NULL;
-    }
-
-    if (pThis->pszLogoFile)
-    {
-        PDMDevHlpMMHeapFree(pDevIns, pThis->pszLogoFile);
-        pThis->pszLogoFile = NULL;
-    }
-
-    if (pThis->pbLogo)
-    {
-        PDMDevHlpMMHeapFree(pDevIns, pThis->pbLogo);
-        pThis->pbLogo = NULL;
+    if (pThisCC->pbVBEExtraData)
+    {
+        PDMDevHlpMMHeapFree(pDevIns, pThisCC->pbVBEExtraData);
+        pThisCC->pbVBEExtraData = NULL;
+    }
+    if (pThisCC->pbVgaBios)
+    {
+        PDMDevHlpMMHeapFree(pDevIns, pThisCC->pbVgaBios);
+        pThisCC->pbVgaBios = NULL;
+    }
+
+    if (pThisCC->pszVgaBiosFile)
+    {
+        PDMDevHlpMMHeapFree(pDevIns, pThisCC->pszVgaBiosFile);
+        pThisCC->pszVgaBiosFile = NULL;
+    }
+
+    if (pThisCC->pszLogoFile)
+    {
+        PDMDevHlpMMHeapFree(pDevIns, pThisCC->pszLogoFile);
+        pThisCC->pszLogoFile = NULL;
+    }
+
+    if (pThisCC->pbLogo)
+    {
+        PDMDevHlpMMHeapFree(pDevIns, pThisCC->pbLogo);
+        pThisCC->pbLogo = NULL;
     }
 
@@ -6326 +6341 @@
 {
     PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
-    PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
-    PVM             pVM   = PDMDevHlpGetVM(pDevIns);
-    PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    PVM             pVM     = PDMDevHlpGetVM(pDevIns);
+    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
     int             rc;
     unsigned        i;
@@ -6464 +6480 @@
 # endif
 
-    pThis->pDevInsR3 = pDevIns;
-    pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-# ifdef VBOX_WITH_RAW_MODE_KEEP
-    pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-# endif
+    pThisCC->pDevIns = pDevIns;
 
     vgaR3Reset(pDevIns);
@@ -6507 +6519 @@
 
     /* the interfaces. */
-    pThis->IBase.pfnQueryInterface    = vgaR3PortQueryInterface;
-
-    pThis->IPort.pfnUpdateDisplay     = vgaR3PortUpdateDisplay;
-    pThis->IPort.pfnUpdateDisplayAll  = vgaR3PortUpdateDisplayAll;
-    pThis->IPort.pfnQueryVideoMode    = vgaR3PortQueryVideoMode;
-    pThis->IPort.pfnSetRefreshRate    = vgaR3PortSetRefreshRate;
-    pThis->IPort.pfnTakeScreenshot    = vgaR3PortTakeScreenshot;
-    pThis->IPort.pfnFreeScreenshot    = vgaR3PortFreeScreenshot;
-    pThis->IPort.pfnDisplayBlt        = vgaR3PortDisplayBlt;
-    pThis->IPort.pfnUpdateDisplayRect = vgaR3PortUpdateDisplayRect;
-    pThis->IPort.pfnCopyRect          = vgaR3PortCopyRect;
-    pThis->IPort.pfnSetRenderVRAM     = vgaR3PortSetRenderVRAM;
+    pThisCC->IBase.pfnQueryInterface    = vgaR3PortQueryInterface;
+
+    pThisCC->IPort.pfnUpdateDisplay     = vgaR3PortUpdateDisplay;
+    pThisCC->IPort.pfnUpdateDisplayAll  = vgaR3PortUpdateDisplayAll;
+    pThisCC->IPort.pfnQueryVideoMode    = vgaR3PortQueryVideoMode;
+    pThisCC->IPort.pfnSetRefreshRate    = vgaR3PortSetRefreshRate;
+    pThisCC->IPort.pfnTakeScreenshot    = vgaR3PortTakeScreenshot;
+    pThisCC->IPort.pfnFreeScreenshot    = vgaR3PortFreeScreenshot;
+    pThisCC->IPort.pfnDisplayBlt        = vgaR3PortDisplayBlt;
+    pThisCC->IPort.pfnUpdateDisplayRect = vgaR3PortUpdateDisplayRect;
+    pThisCC->IPort.pfnCopyRect          = vgaR3PortCopyRect;
+    pThisCC->IPort.pfnSetRenderVRAM     = vgaR3PortSetRenderVRAM;
 # ifdef VBOX_WITH_VMSVGA
-    pThis->IPort.pfnSetViewport       = vmsvgaR3PortSetViewport;
+    pThisCC->IPort.pfnSetViewport       = vmsvgaR3PortSetViewport;
 # else
-    pThis->IPort.pfnSetViewport       = NULL;
+    pThisCC->IPort.pfnSetViewport       = NULL;
 # endif
-    pThis->IPort.pfnSendModeHint      = vbvaR3PortSendModeHint;
-    pThis->IPort.pfnReportHostCursorCapabilities = vgaR3PortReportHostCursorCapabilities;
-    pThis->IPort.pfnReportHostCursorPosition = vgaR3PortReportHostCursorPosition;
+    pThisCC->IPort.pfnSendModeHint      = vbvaR3PortSendModeHint;
+    pThisCC->IPort.pfnReportHostCursorCapabilities = vgaR3PortReportHostCursorCapabilities;
+    pThisCC->IPort.pfnReportHostCursorPosition = vgaR3PortReportHostCursorPosition;
 
 # if defined(VBOX_WITH_HGSMI) && defined(VBOX_WITH_VIDEOHWACCEL)
-    pThis->IVBVACallbacks.pfnVHWACommandCompleteAsync = vbvaR3VHWACommandCompleteAsync;
+    pThisCC->IVBVACallbacks.pfnVHWACommandCompleteAsync = vbvaR3VHWACommandCompleteAsync;
 # endif
 
-    pThis->ILeds.pfnQueryStatusLed    = vgaR3PortQueryStatusLed;
+    pThisCC->ILeds.pfnQueryStatusLed    = vgaR3PortQueryStatusLed;
     pThis->Led3D.u32Magic               = PDMLED_MAGIC;
 
@@ -6588 +6600 @@
     rc = PDMDevHlpPCIIORegionCreateMmio2Ex(pDevIns, pThis->pciRegions.iVRAM, pThis->vram_size,
                                            PCI_ADDRESS_SPACE_MEM_PREFETCH, 0 /*fFlags*/, vgaR3PciIORegionVRamMapUnmap,
-                                           "VRam", (void **)&pThis->vram_ptrR3, &pThis->hMmio2VRam);
+                                           "VRam", (void **)&pThisCC->pbVRam, &pThis->hMmio2VRam);
     AssertLogRelRCReturn(rc, PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
                                                  N_("Failed to allocate %u bytes of VRAM"), pThis->vram_size));
 # ifndef VGA_WITH_PARTIAL_RING0_MAPPING
-    pThis->vram_ptrR0 = (RTR0PTR)pThis->vram_ptrR3;
+    pThis->vram_ptrR0 = (RTR0PTR)pThisCC->pbVRam;
 # endif
 
@@ -6658 +6670 @@
      * Get the VGA BIOS ROM file name.
      */
-    rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "BiosRom", &pThis->pszVgaBiosFile);
+    rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "BiosRom", &pThisCC->pszVgaBiosFile);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
     {
-        pThis->pszVgaBiosFile = NULL;
+        pThisCC->pszVgaBiosFile = NULL;
         rc = VINF_SUCCESS;
     }
     else if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Querying \"BiosRom\" as a string failed"));
-    else if (!*pThis->pszVgaBiosFile)
-    {
-        PDMDevHlpMMHeapFree(pDevIns, pThis->pszVgaBiosFile);
-        pThis->pszVgaBiosFile = NULL;
+    else if (!*pThisCC->pszVgaBiosFile)
+    {
+        PDMDevHlpMMHeapFree(pDevIns, pThisCC->pszVgaBiosFile);
+        pThisCC->pszVgaBiosFile = NULL;
     }
 
@@ -6676 +6688 @@
      */
     RTFILE FileVgaBios = NIL_RTFILE;
-    if (pThis->pszVgaBiosFile)
-    {
-        rc = RTFileOpen(&FileVgaBios, pThis->pszVgaBiosFile,
-                        RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
+    if (pThisCC->pszVgaBiosFile)
+    {
+        rc = RTFileOpen(&FileVgaBios, pThisCC->pszVgaBiosFile, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
         if (RT_SUCCESS(rc))
         {
-            rc = RTFileQuerySize(FileVgaBios, &pThis->cbVgaBios);
+            rc = RTFileQuerySize(FileVgaBios, &pThisCC->cbVgaBios);
             if (RT_SUCCESS(rc))
             {
-                if (    RT_ALIGN(pThis->cbVgaBios, _4K) != pThis->cbVgaBios
-                    ||  pThis->cbVgaBios > _64K
-                    ||  pThis->cbVgaBios < 16 * _1K)
+                if (    RT_ALIGN(pThisCC->cbVgaBios, _4K) != pThisCC->cbVgaBios
+                    ||  pThisCC->cbVgaBios > _64K
+                    ||  pThisCC->cbVgaBios < 16 * _1K)
                     rc = VERR_TOO_MUCH_DATA;
             }
@@ -6696 +6707 @@
              * In case of failure simply fall back to the built-in VGA BIOS ROM.
              */
-            Log(("vgaConstruct: Failed to open VGA BIOS ROM file '%s', rc=%Rrc!\n", pThis->pszVgaBiosFile, rc));
+            Log(("vgaConstruct: Failed to open VGA BIOS ROM file '%s', rc=%Rrc!\n", pThisCC->pszVgaBiosFile, rc));
             RTFileClose(FileVgaBios);
             FileVgaBios = NIL_RTFILE;
-            PDMDevHlpMMHeapFree(pDevIns, pThis->pszVgaBiosFile);
-            pThis->pszVgaBiosFile = NULL;
+            PDMDevHlpMMHeapFree(pDevIns, pThisCC->pszVgaBiosFile);
+            pThisCC->pszVgaBiosFile = NULL;
         }
     }
@@ -6707 +6718 @@
      * Attempt to get the VGA BIOS ROM data from file.
      */
-    if (pThis->pszVgaBiosFile)
+    if (pThisCC->pszVgaBiosFile)
     {
         /*
          * Allocate buffer for the VGA BIOS ROM data.
          */
-        pThis->pbVgaBios = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, pThis->cbVgaBios);
-        if (pThis->pbVgaBios)
+        pThisCC->pbVgaBios = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, pThisCC->cbVgaBios);
+        if (pThisCC->pbVgaBios)
         {
-            rc = RTFileRead(FileVgaBios, pThis->pbVgaBios, pThis->cbVgaBios, NULL);
+            rc = RTFileRead(FileVgaBios, pThisCC->pbVgaBios, pThisCC->cbVgaBios, NULL);
             if (RT_FAILURE(rc))
             {
-                AssertMsgFailed(("RTFileRead(,,%d,NULL) -> %Rrc\n", pThis->cbVgaBios, rc));
-                PDMDevHlpMMHeapFree(pDevIns, pThis->pbVgaBios);
-                pThis->pbVgaBios = NULL;
+                AssertMsgFailed(("RTFileRead(,,%d,NULL) -> %Rrc\n", pThisCC->cbVgaBios, rc));
+                PDMDevHlpMMHeapFree(pDevIns, pThisCC->pbVgaBios);
+                pThisCC->pbVgaBios = NULL;
             }
             rc = VINF_SUCCESS;
@@ -6728 +6739 @@
     }
     else
-        pThis->pbVgaBios = NULL;
+        pThisCC->pbVgaBios = NULL;
 
     /* cleanup */
@@ -6739 +6750 @@
     uint64_t        cbVgaBiosBinary;
     uint32_t        fFlags = 0;
-    if (pThis->pbVgaBios == NULL)
+    if (pThisCC->pbVgaBios == NULL)
     {
         CPUMMICROARCH enmMicroarch = pVM ? CPUMGetGuestMicroarch(pVM) : kCpumMicroarch_Intel_P6;
@@ -6767 +6778 @@
     else
     {
-        pbVgaBiosBinary = pThis->pbVgaBios;
-        cbVgaBiosBinary = pThis->cbVgaBios;
+        pbVgaBiosBinary = pThisCC->pbVgaBios;
+        cbVgaBiosBinary = pThisCC->cbVgaBios;
     }
 
@@ -6790 +6801 @@
      * Create the refresh timer.
      */
-    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_REAL, vgaTimerRefresh, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
+    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_REAL, vgaTimerRefresh, NULL, TMTIMER_FLAGS_NO_CRIT_SECT,
                               "VGA Refresh Timer", &pThis->hRefreshTimer);
     AssertRCReturn(rc, rc);
@@ -6834 +6845 @@
      */
     AssertRelease(sizeof(VBEHEADER) + cb < 65536);
-    pThis->cbVBEExtraData = (uint16_t)(sizeof(VBEHEADER) + cb);
-    pThis->pbVBEExtraData = (uint8_t *)PDMDevHlpMMHeapAllocZ(pDevIns, pThis->cbVBEExtraData);
-    if (!pThis->pbVBEExtraData)
+    pThisCC->cbVBEExtraData = (uint16_t)(sizeof(VBEHEADER) + cb);
+    pThisCC->pbVBEExtraData = (uint8_t *)PDMDevHlpMMHeapAllocZ(pDevIns, pThisCC->cbVBEExtraData);
+    if (!pThisCC->pbVBEExtraData)
         return VERR_NO_MEMORY;
 
-    pVBEDataHdr = (PVBEHEADER)pThis->pbVBEExtraData;
+    pVBEDataHdr = (PVBEHEADER)pThisCC->pbVBEExtraData;
     pVBEDataHdr->u16Signature = VBEHEADER_MAGIC;
     pVBEDataHdr->cbData = cb;
@@ -7059 +7070 @@
      * Get the Logo file name.
      */
-    rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "LogoFile", &pThis->pszLogoFile);
+    rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "LogoFile", &pThisCC->pszLogoFile);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pThis->pszLogoFile = NULL;
+        pThisCC->pszLogoFile = NULL;
     else if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("Configuration error: Querying \"LogoFile\" as a string failed"));
-    else if (!*pThis->pszLogoFile)
-    {
-        PDMDevHlpMMHeapFree(pDevIns, pThis->pszLogoFile);
-        pThis->pszLogoFile = NULL;
+    else if (!*pThisCC->pszLogoFile)
+    {
+        PDMDevHlpMMHeapFree(pDevIns, pThisCC->pszLogoFile);
+        pThisCC->pszLogoFile = NULL;
     }
 
@@ -7076 +7087 @@
     LogoHdr.cbLogo = g_cbVgaDefBiosLogo;
     RTFILE FileLogo = NIL_RTFILE;
-    if (pThis->pszLogoFile)
-    {
-        rc = RTFileOpen(&FileLogo, pThis->pszLogoFile,
+    if (pThisCC->pszLogoFile)
+    {
+        rc = RTFileOpen(&FileLogo, pThisCC->pszLogoFile,
                         RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
         if (RT_SUCCESS(rc))
@@ -7097 +7108 @@
              * Ignore failure and fall back to the default logo.
              */
-            LogRel(("vgaR3Construct: Failed to open logo file '%s', rc=%Rrc!\n", pThis->pszLogoFile, rc));
+            LogRel(("vgaR3Construct: Failed to open logo file '%s', rc=%Rrc!\n", pThisCC->pszLogoFile, rc));
             if (FileLogo != NIL_RTFILE)
                 RTFileClose(FileLogo);
             FileLogo = NIL_RTFILE;
-            PDMDevHlpMMHeapFree(pDevIns, pThis->pszLogoFile);
-            pThis->pszLogoFile = NULL;
+            PDMDevHlpMMHeapFree(pDevIns, pThisCC->pszLogoFile);
+            pThisCC->pszLogoFile = NULL;
         }
     }
@@ -7116 +7127 @@
      * Let us fall back to default logo on read failure.
      */
-    pThis->cbLogo = LogoHdr.cbLogo;
+    pThisCC->cbLogo = LogoHdr.cbLogo;
     if (g_cbVgaDefBiosLogo)
-        pThis->cbLogo = g_cbVgaDefBiosLogo;
+        pThisCC->cbLogo = g_cbVgaDefBiosLogo;
 # ifndef VBOX_OSE
     if (g_cbVgaDefBiosLogoNY)
-        pThis->cbLogo = g_cbVgaDefBiosLogoNY;
+        pThisCC->cbLogo = g_cbVgaDefBiosLogoNY;
 # endif
-    pThis->cbLogo += sizeof(LogoHdr);
-
-    pThis->pbLogo = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, pThis->cbLogo);
-    if (pThis->pbLogo)
+    pThisCC->cbLogo += sizeof(LogoHdr);
+
+    pThisCC->pbLogo = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, pThisCC->cbLogo);
+    if (pThisCC->pbLogo)
     {
         /*
          * Write the logo header.
          */
-        PLOGOHDR pLogoHdr = (PLOGOHDR)pThis->pbLogo;
+        PLOGOHDR pLogoHdr = (PLOGOHDR)pThisCC->pbLogo;
         *pLogoHdr = LogoHdr;
 
@@ -7137 +7148 @@
          * Write the logo bitmap.
          */
-        if (pThis->pszLogoFile)
+        if (pThisCC->pszLogoFile)
         {
             rc = RTFileRead(FileLogo, pLogoHdr + 1, LogoHdr.cbLogo, NULL);
             if (RT_SUCCESS(rc))
-                rc = vbeR3ParseBitmap(pThis);
+                rc = vbeR3ParseBitmap(pThisCC);
             if (RT_FAILURE(rc))
             {
                 LogRel(("Error %Rrc reading logo file '%s', using internal logo\n",
-                       rc, pThis->pszLogoFile));
+                       rc, pThisCC->pszLogoFile));
                 pLogoHdr->cbLogo = LogoHdr.cbLogo = g_cbVgaDefBiosLogo;
             }
         }
-        if (   !pThis->pszLogoFile
+        if (   !pThisCC->pszLogoFile
             || RT_FAILURE(rc))
         {
@@ -7164 +7175 @@
                 pLogoHdr->cbLogo = LogoHdr.cbLogo = g_cbVgaDefBiosLogoNY;
                 memcpy(pLogoHdr + 1, g_abVgaDefBiosLogoNY, LogoHdr.cbLogo);
-                pThis->fBootMenuInverse = true;
+                pThisCC->fBootMenuInverse = true;
             }
             else
 # endif
                 memcpy(pLogoHdr + 1, g_abVgaDefBiosLogo, LogoHdr.cbLogo);
-            rc = vbeR3ParseBitmap(pThis);
-            if (RT_FAILURE(rc))
-                AssertReleaseMsgFailed(("Parsing of internal bitmap failed! vbeR3ParseBitmap() -> %Rrc\n", rc));
+            rc = vbeR3ParseBitmap(pThisCC);
+            AssertLogRelMsgReturn(RT_SUCCESS(rc), ("Parsing of internal bitmap failed! vbeR3ParseBitmap() -> %Rrc\n", rc), rc);
         }
 
@@ -7186 +7196 @@
 
 # ifdef VBOX_WITH_HGSMI
-    VBVAInit (pThis);
+    VBVAInit(pDevIns, pThis, pThisCC);
 # endif
 
@@ -7192 +7202 @@
     if (rc == VINF_SUCCESS)
     {
-        rc = vboxVDMAConstruct(pThis, 1024);
+        rc = vboxVDMAConstruct(pThis, pThisCC, 1024);
         AssertRC(rc);
     }
@@ -7227 +7237 @@
          * Attach status driver (optional).
          */
-        rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
+        rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pBase, "Status Port");
         if (RT_SUCCESS(rc))
-            pThis->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
+            pThisCC->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
         else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
         {
@@ -7252 +7262 @@
 {
     PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
 
     int rc = PDMDevHlpSetDeviceCritSect(pDevIns, &pThis->CritSect);
@@ -7311 +7322 @@
      */
 # if defined(VBOX_WITH_2X_4GB_ADDR_SPACE) || (defined(IN_RING0) && defined(VGA_WITH_PARTIAL_RING0_MAPPING))
-    rc = PDMDevHlpMmio2SetUpContext(pDevIns, pThis->hMmio2VRam, 0 /* off */, VGA_MAPPING_SIZE, (void **)&pThis->CTX_SUFF(vram_ptr));
+    rc = PDMDevHlpMmio2SetUpContext(pDevIns, pThis->hMmio2VRam, 0 /* off */, VGA_MAPPING_SIZE, (void **)&pThisCC->pbVRam);
     AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMmio2SetUpContext(,VRAM,0,%#x,) -> %Rrc\n", VGA_MAPPING_SIZE, rc), rc);
 # endif
@@ -7349 +7360 @@
     /* .uSharedVersion = */         42,
     /* .cbInstanceShared = */       sizeof(VGASTATE),
-    /* .cbInstanceCC = */           0,
-    /* .cbInstanceRC = */           0,
+    /* .cbInstanceCC = */           sizeof(VGASTATECC),
+    /* .cbInstanceRC = */           sizeof(VGASTATERC),
     /* .cMaxPciDevices = */         1,
     /* .cMaxMsixVectors = */        0,

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

@@ -282 +282 @@
 
 
+/**
+ * The shared VGA state data.
+ */
 typedef struct VGAState
 {
-#ifndef VBOX
-    VGA_STATE_COMMON
-#else /* VBOX */
-    R3PTRTYPE(uint8_t *) vram_ptrR3;
-    R3PTRTYPE(FNGETBPP *) get_bpp;
-    R3PTRTYPE(FNGETOFFSETS *) get_offsets;
-    R3PTRTYPE(FNGETRESOLUTION *) get_resolution;
-    R3PTRTYPE(FNRGBTOPIXEL *) rgb_to_pixel;
-    R3PTRTYPE(FNCURSORINVALIDATE *) cursor_invalidate;
-    R3PTRTYPE(FNCURSORDRAWLINE *) cursor_draw_line;
-    RTR3PTR R3PtrCmnAlignment;
     uint32_t vram_size;
     uint32_t latch;
@@ -337 +329 @@
     bool last_cur_blink, last_chr_blink;
     uint32_t cursor_offset;
-    /* hardware mouse cursor support */
+    /** hardware mouse cursor support */
     uint32_t invalidated_y_table[VGA_MAX_HEIGHT / 32];
-    /* tell for each page if it has been updated since the last time */
+    /** tell for each page if it has been updated since the last time */
     uint32_t last_palette[256];
     uint32_t last_ch_attr[CH_ATTR_SIZE]; /* XXX: make it dynamic */
@@ -346 +338 @@
     uint32_t                    u32Marker;
 
-# ifdef VBOX_WITH_RAW_MODE_KEEP
-    /** Pointer to the device instance - RC Ptr. */
-    PPDMDEVINSRC                pDevInsRC;
-    /** Pointer to the GC vram mapping. */
-    RCPTRTYPE(uint8_t *)        vram_ptrRC;
-    uint32_t                    Padding1;
-# endif
-
-    /** Pointer to the device instance - R3 Ptr. */
-    PPDMDEVINSR3                pDevInsR3;
-# ifdef VBOX_WITH_HGSMI
-    R3PTRTYPE(PHGSMIINSTANCE)   pHGSMI;
-# endif
-# ifdef VBOX_WITH_VDMA
-    R3PTRTYPE(PVBOXVDMAHOST)    pVdma;
-# endif
-    /** LUN\#0: The display port base interface. */
-    PDMIBASE                    IBase;
-    /** LUN\#0: The display port interface. */
-    PDMIDISPLAYPORT             IPort;
-# if defined(VBOX_WITH_HGSMI)
-    /** LUN\#0: VBVA callbacks interface */
-    PDMIDISPLAYVBVACALLBACKS    IVBVACallbacks;
-# else
-    RTR3PTR                     Padding2;
-# endif
-    /** Status LUN: Leds interface. */
-    PDMILEDPORTS                ILeds;
-
-    /** Pointer to base interface of the driver. */
-    R3PTRTYPE(PPDMIBASE)        pDrvBase;
-    /** Pointer to display connector interface of the driver. */
-    R3PTRTYPE(PPDMIDISPLAYCONNECTOR) pDrv;
-
-    /** Status LUN: Partner of ILeds. */
-    R3PTRTYPE(PPDMILEDCONNECTORS)   pLedsConnector;
-
     /** Refresh timer handle - HC. */
     TMTIMERHANDLE               hRefreshTimer;
 
-    /** Pointer to the device instance - R0 Ptr. */
-    PPDMDEVINSR0                pDevInsR0;
-    /** The R0 vram pointer... */
-    R0PTRTYPE(uint8_t *)        vram_ptrR0;
-
-# ifdef VBOX_WITH_VMSVGA
+#ifdef VBOX_WITH_VMSVGA
     VMSVGAState                 svga;
-# endif
+#endif
 
     /** The number of monitors. */
@@ -412 +362 @@
     /** Whether 3D is enabled for the VM. */
     bool                        f3DEnabled;
-# ifdef VBOX_WITH_VMSVGA
+#ifdef VBOX_WITH_VMSVGA
     /* Whether the SVGA emulation is enabled or not. */
     bool                        fVMSVGAEnabled;
@@ -418 +368 @@
     bool                        fVMSVGAPciBarLayout;
     bool                        Padding4[4];
-# else
+#else
     bool                        Padding4[3+4];
-# endif
+#endif
 
     struct {
         uint32_t                    u32Padding1;
         uint32_t                    iVRAM;
-# ifdef VBOX_WITH_VMSVGA
+#ifdef VBOX_WITH_VMSVGA
         uint32_t                    iIO;
         uint32_t                    iFIFO;
-# endif
+#endif
     } pciRegions;
 
@@ -438 +388 @@
     /** The critical section protect the instance data. */
     PDMCRITSECT                 CritSect;
-
-    STAMPROFILE                 StatRZMemoryRead;
-    STAMPROFILE                 StatR3MemoryRead;
-    STAMPROFILE                 StatRZMemoryWrite;
-    STAMPROFILE                 StatR3MemoryWrite;
-    STAMCOUNTER                 StatMapPage;            /**< Counts IOMMMIOMapMMIO2Page calls.  */
-    STAMCOUNTER                 StatUpdateDisp;         /**< Counts vgaPortUpdateDisplay calls.  */
-# ifdef VBOX_WITH_HGSMI
-    STAMCOUNTER                 StatHgsmiMdaCgaAccesses;
-# endif
 
     /* Keep track of ring 0 latched accesses to the VGA MMIO memory. */
@@ -455 +395 @@
     uint16_t                    iMask;
 
-# ifdef VBE_BYTEWISE_IO
+#ifdef VBE_BYTEWISE_IO
     /** VBE read/write data/index flags */
     uint8_t                     fReadVBEData;
@@ -467 +407 @@
     uint8_t                     cbWriteVBEExtraAddress;
     uint8_t                     Padding5;
-# endif
+#endif
 
     /** Retrace emulation state */
@@ -474 +414 @@
     vga_retrace_s               retrace_state;
 
-    /** The VBE BIOS extra data. */
-    R3PTRTYPE(uint8_t *)        pbVBEExtraData;
-    /** The size of the VBE BIOS extra data. */
-    uint16_t                    cbVBEExtraData;
-    /** The VBE BIOS current memory address. */
-    uint16_t                    u16VBEExtraAddress;
-    uint16_t                    Padding7[2];
-
-    /** The BIOS logo data. */
-    R3PTRTYPE(uint8_t *)        pbLogo;
-    /** The name of the logo file. */
-    R3PTRTYPE(char *)           pszLogoFile;
-    /** Bitmap image data. */
-    R3PTRTYPE(uint8_t *)        pbLogoBitmap;
+#ifdef VBOX_WITH_HGSMI
+    /** Base port in the assigned PCI I/O space. */
+    RTIOPORT                    IOPortBase;
+# ifdef VBOX_WITH_WDDM
+    uint8_t                     Padding10[2];
+    /** Specifies guest driver caps, i.e. whether it can handle IRQs from the
+     * adapter, the way it can handle async HGSMI command completion, etc. */
+    uint32_t                    fGuestCaps;
+    uint32_t                    fScanLineCfg;
+    uint32_t                    Padding11;
+# else
+    uint8_t                     Padding11[14];
+# endif
+
+    /** The critical section serializes the HGSMI IRQ setting/clearing. */
+    PDMCRITSECT                 CritSectIRQ;
+    /** VBVARaiseIRQ flags which were set when the guest was still processing previous IRQ. */
+    uint32_t                    fu32PendingGuestFlags;
+    uint32_t                    Padding12;
+#endif /* VBOX_WITH_HGSMI */
+
+    PDMLED Led3D;
+
+    struct {
+        volatile uint32_t cPending;
+        uint32_t Padding1;
+        union
+        {
+            RTLISTNODE PendingList;
+            /* make sure the structure sized cross different contexts correctly */
+            struct
+            {
+                R3PTRTYPE(void *) dummy1;
+                R3PTRTYPE(void *) dummy2;
+            } dummy;
+        };
+    } pendingVhwaCommands;
+
+    /** The MMIO handle of the legacy graphics buffer/regs at 0xa0000-0xbffff. */
+    PGMMMIO2HANDLE              hMmioLegacy;
+
+    /** @name I/O ports for range 0x3c0-3cf.
+     * @{ */
+    IOMIOPORTHANDLE             hIoPortAr;
+    IOMIOPORTHANDLE             hIoPortMsrSt00;
+    IOMIOPORTHANDLE             hIoPort3c3;
+    IOMIOPORTHANDLE             hIoPortSr;
+    IOMIOPORTHANDLE             hIoPortDac;
+    IOMIOPORTHANDLE             hIoPortPos;
+    IOMIOPORTHANDLE             hIoPortGr;
+    /** @} */
+
+    /** @name I/O ports for MDA 0x3b0-0x3bf (sparse)
+     * @{ */
+    IOMIOPORTHANDLE             hIoPortMdaCrt;
+    IOMIOPORTHANDLE             hIoPortMdaFcrSt;
+    /** @} */
+
+    /** @name I/O ports for CGA 0x3d0-0x3df (sparse)
+     * @{ */
+    IOMIOPORTHANDLE             hIoPortCgaCrt;
+    IOMIOPORTHANDLE             hIoPortCgaFcrSt;
+    /** @} */
+
+#ifdef VBOX_WITH_HGSMI
+    /** @name I/O ports for HGSMI 0x3b0-03b3 and 0x3d0-03d3 (ring-3 only)
+     * @{ */
+    IOMIOPORTHANDLE             hIoPortHgsmiHost;
+    IOMIOPORTHANDLE             hIoPortHgsmiGuest;
+    /** @} */
+#endif
+
+    /** @name I/O ports for Boch VBE 0x1ce-0x1cf
+     *  @{ */
+    IOMIOPORTHANDLE             hIoPortVbeIndex;
+    IOMIOPORTHANDLE             hIoPortVbeData;
+    /** @} */
+
+    /** The BIOS printf I/O port. */
+    IOMIOPORTHANDLE             hIoPortBios;
+    /** The VBE extra data I/O port. */
+    IOMIOPORTHANDLE             hIoPortVbeExtra;
+    /** The logo command I/O port. */
+    IOMIOPORTHANDLE             hIoPortCmdLogo;
+
+#ifdef VBOX_WITH_VMSVGA
+    /** VMSVGA: I/O port PCI region. */
+    IOMIOPORTHANDLE             hIoPortVmSvga;
+    /** VMSVGA: The MMIO2 handle of the FIFO PCI region. */
+    PGMMMIO2HANDLE              hMmio2VmSvgaFifo;
+#endif
+    /** The MMIO2 handle of the VRAM. */
+    PGMMMIO2HANDLE              hMmio2VRam;
+
+    STAMPROFILE                 StatRZMemoryRead;
+    STAMPROFILE                 StatR3MemoryRead;
+    STAMPROFILE                 StatRZMemoryWrite;
+    STAMPROFILE                 StatR3MemoryWrite;
+    STAMCOUNTER                 StatMapPage;            /**< Counts IOMMMIOMapMMIO2Page calls.  */
+    STAMCOUNTER                 StatUpdateDisp;         /**< Counts vgaPortUpdateDisplay calls.  */
+#ifdef VBOX_WITH_HGSMI
+    STAMCOUNTER                 StatHgsmiMdaCgaAccesses;
+#endif
+} VGAState;
+#ifdef VBOX
+/** VGA state. */
+typedef VGAState VGASTATE;
+/** Pointer to the VGA state. */
+typedef VGASTATE *PVGASTATE;
+AssertCompileMemberAlignment(VGASTATE, bank_offset, 8);
+AssertCompileMemberAlignment(VGASTATE, font_offsets, 8);
+AssertCompileMemberAlignment(VGASTATE, last_ch_attr, 8);
+AssertCompileMemberAlignment(VGASTATE, u32Marker, 8);
+#endif
+
+
+/**
+ * The VGA state data for ring-3 context.
+ */
+typedef struct VGASTATER3
+{
+    R3PTRTYPE(uint8_t *)        pbVRam;
+    R3PTRTYPE(FNGETBPP *)       get_bpp;
+    R3PTRTYPE(FNGETOFFSETS *)   get_offsets;
+    R3PTRTYPE(FNGETRESOLUTION *) get_resolution;
+    R3PTRTYPE(FNRGBTOPIXEL *)   rgb_to_pixel;
+    R3PTRTYPE(FNCURSORINVALIDATE *) cursor_invalidate;
+    R3PTRTYPE(FNCURSORDRAWLINE *) cursor_draw_line;
+
+    /** Pointer to the device instance.
+     * @note Only for getting our bearings in interface methods.  */
+    PPDMDEVINSR3                pDevIns;
+#ifdef VBOX_WITH_HGSMI
+    R3PTRTYPE(PHGSMIINSTANCE)   pHGSMI;
+#endif
+#ifdef VBOX_WITH_VDMA
+    R3PTRTYPE(PVBOXVDMAHOST)    pVdma;
+#endif
+
+    /** LUN\#0: The display port base interface. */
+    PDMIBASE                    IBase;
+    /** LUN\#0: The display port interface. */
+    PDMIDISPLAYPORT             IPort;
+#ifdef VBOX_WITH_HGSMI
+    /** LUN\#0: VBVA callbacks interface */
+    PDMIDISPLAYVBVACALLBACKS    IVBVACallbacks;
+#endif
+    /** Status LUN: Leds interface. */
+    PDMILEDPORTS                ILeds;
+
+    /** Pointer to base interface of the driver. */
+    R3PTRTYPE(PPDMIBASE)        pDrvBase;
+    /** Pointer to display connector interface of the driver. */
+    R3PTRTYPE(PPDMIDISPLAYCONNECTOR) pDrv;
+
+    /** Status LUN: Partner of ILeds. */
+    R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
+
+    /** The VGA BIOS ROM data. */
+    R3PTRTYPE(uint8_t *)        pbVgaBios;
+    /** The size of the VGA BIOS ROM. */
+    uint64_t                    cbVgaBios;
+    /** The name of the VGA BIOS ROM file. */
+    R3PTRTYPE(char *)           pszVgaBiosFile;
+
+    /** @name Logo data
+     * @{ */
     /** Current logo data offset. */
     uint32_t                    offLogoData;
@@ -514 +607 @@
     /** Palette data. */
     uint32_t                    au32LogoPalette[256];
-
-    /** The VGA BIOS ROM data. */
-    R3PTRTYPE(uint8_t *)        pbVgaBios;
-    /** The size of the VGA BIOS ROM. */
-    uint64_t                    cbVgaBios;
-    /** The name of the VGA BIOS ROM file. */
-    R3PTRTYPE(char *)           pszVgaBiosFile;
-# if HC_ARCH_BITS == 32
-    uint32_t                    Padding9;
-# endif
-
-# ifdef VBOX_WITH_HGSMI
-    /** Base port in the assigned PCI I/O space. */
-    RTIOPORT                    IOPortBase;
-#  ifdef VBOX_WITH_WDDM
-    uint8_t                     Padding10[2];
-    /** Specifies guest driver caps, i.e. whether it can handle IRQs from the
-     * adapter, the way it can handle async HGSMI command completion, etc. */
-    uint32_t                    fGuestCaps;
-    uint32_t                    fScanLineCfg;
-    uint32_t                    Padding11;
-#  else
-    uint8_t                     Padding11[14];
-#  endif
-
-    /** The critical section serializes the HGSMI IRQ setting/clearing. */
-    PDMCRITSECT                 CritSectIRQ;
-    /** VBVARaiseIRQ flags which were set when the guest was still processing previous IRQ. */
-    uint32_t                    fu32PendingGuestFlags;
-    uint32_t                    Padding12;
-# endif /* VBOX_WITH_HGSMI */
-
-    PDMLED Led3D;
-
-    struct {
-        volatile uint32_t cPending;
-        uint32_t Padding1;
-        union
-        {
-            RTLISTNODE PendingList;
-            /* make sure the structure sized cross different contexts correctly */
-            struct
-            {
-                R3PTRTYPE(void *) dummy1;
-                R3PTRTYPE(void *) dummy2;
-            } dummy;
-        };
-    } pendingVhwaCommands;
-
-    /** The MMIO handle of the legacy graphics buffer/regs at 0xa0000-0xbffff. */
-    PGMMMIO2HANDLE              hMmioLegacy;
-
-    /** @name I/O ports for range 0x3c0-3cf.
+    /** The BIOS logo data. */
+    R3PTRTYPE(uint8_t *)        pbLogo;
+    /** The name of the logo file. */
+    R3PTRTYPE(char *)           pszLogoFile;
+    /** Bitmap image data. */
+    R3PTRTYPE(uint8_t *)        pbLogoBitmap;
+    /** @} */
+
+    /** @name VBE extra data (modes)
      * @{ */
-    IOMIOPORTHANDLE             hIoPortAr;
-    IOMIOPORTHANDLE             hIoPortMsrSt00;
-    IOMIOPORTHANDLE             hIoPort3c3;
-    IOMIOPORTHANDLE             hIoPortSr;
-    IOMIOPORTHANDLE             hIoPortDac;
-    IOMIOPORTHANDLE             hIoPortPos;
-    IOMIOPORTHANDLE             hIoPortGr;
+    /** The VBE BIOS extra data. */
+    R3PTRTYPE(uint8_t *)        pbVBEExtraData;
+    /** The size of the VBE BIOS extra data. */
+    uint16_t                    cbVBEExtraData;
+    /** The VBE BIOS current memory address. */
+    uint16_t                    u16VBEExtraAddress;
+    uint16_t                    Padding7[2];
     /** @} */
 
-    /** @name I/O ports for MDA 0x3b0-0x3bf (sparse)
-     * @{ */
-    IOMIOPORTHANDLE             hIoPortMdaCrt;
-    IOMIOPORTHANDLE             hIoPortMdaFcrSt;
-    /** @} */
-
-    /** @name I/O ports for CGA 0x3d0-0x3df (sparse)
-     * @{ */
-    IOMIOPORTHANDLE             hIoPortCgaCrt;
-    IOMIOPORTHANDLE             hIoPortCgaFcrSt;
-    /** @} */
-
-# ifdef VBOX_WITH_HGSMI
-    /** @name I/O ports for HGSMI 0x3b0-03b3 and 0x3d0-03d3 (ring-3 only)
-     * @{ */
-    IOMIOPORTHANDLE             hIoPortHgsmiHost;
-    IOMIOPORTHANDLE             hIoPortHgsmiGuest;
-    /** @} */
-# endif
-
-    /** @name I/O ports for Boch VBE 0x1ce-0x1cf
-     *  @{ */
-    IOMIOPORTHANDLE             hIoPortVbeIndex;
-    IOMIOPORTHANDLE             hIoPortVbeData;
-    /** @} */
-
-    /** The BIOS printf I/O port. */
-    IOMIOPORTHANDLE             hIoPortBios;
-    /** The VBE extra data I/O port. */
-    IOMIOPORTHANDLE             hIoPortVbeExtra;
-    /** The logo command I/O port. */
-    IOMIOPORTHANDLE             hIoPortCmdLogo;
-
-# ifdef VBOX_WITH_VMSVGA
-    /** VMSVGA: I/O port PCI region. */
-    IOMIOPORTHANDLE             hIoPortVmSvga;
-    /** VMSVGA: The MMIO2 handle of the FIFO PCI region. */
-    PGMMMIO2HANDLE              hMmio2VmSvgaFifo;
-# endif
-    /** The MMIO2 handle of the VRAM. */
-    PGMMMIO2HANDLE              hMmio2VRam;
-#endif /* VBOX */
-} VGAState;
-#ifdef VBOX
-/** VGA state. */
-typedef VGAState VGASTATE;
-/** Pointer to the VGA state. */
-typedef VGASTATE *PVGASTATE;
-AssertCompileMemberAlignment(VGASTATE, bank_offset, 8);
-AssertCompileMemberAlignment(VGASTATE, font_offsets, 8);
-AssertCompileMemberAlignment(VGASTATE, last_ch_attr, 8);
-AssertCompileMemberAlignment(VGASTATE, u32Marker, 8);
-#endif
+} VGASTATER3;
+/** Pointer to the ring-3 VGA state. */
+typedef VGASTATER3 *PVGASTATER3;
+
+
+/**
+ * The VGA state data for ring-0 context.
+ */
+typedef struct VGASTATER0
+{
+    /** The R0 vram pointer... */
+    R0PTRTYPE(uint8_t *)        pbVRam;
+} VGASTATER0;
+/** Pointer to the ring-0 VGA state. */
+typedef VGASTATER0 *PVGASTATER0;
+
+
+/**
+ * The VGA state data for raw-mode context.
+ */
+typedef struct VGASTATERC
+{
+    /** Pointer to the GC vram mapping. */
+    RCPTRTYPE(uint8_t *)        pbVRam;
+} VGASTATERC;
+/** Pointer to the raw-mode VGA state. */
+typedef VGASTATERC *PVGASTATERC;
+
+
+/** The VGA state for the current context. */
+typedef CTX_SUFF(VGASTATE) VGASTATECC;
+/** Pointer to the VGA state for the current context. */
+typedef CTX_SUFF(PVGASTATE) PVGASTATECC;
+
+
 
 /** VBE Extra Data. */
@@ -648 +679 @@
 
 #ifdef VBOX_WITH_HGSMI
-int      VBVAInit       (PVGASTATE pVGAState);
-void     VBVADestroy    (PVGASTATE pVGAState);
-int      VBVAUpdateDisplay (PVGASTATE pVGAState);
-void     VBVAReset (PVGASTATE pVGAState);
-void     VBVAPause (PVGASTATE pVGAState, bool fPause);
-void     VBVAOnVBEChanged(PVGASTATE pVGAState);
-void     VBVAOnResume(PVGASTATE pThis);
-
-bool VBVAIsPaused(PVGASTATE pVGAState);
-bool VBVAIsEnabled(PVGASTATE pVGAState);
-
-void VBVARaiseIrq(PVGASTATE pVGAState, uint32_t fFlags);
-
-int VBVAInfoView(PVGASTATE pVGAState, const VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_HOST *pView);
-int VBVAInfoScreen(PVGASTATE pVGAState, const VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_HOST *pScreen);
-int VBVAGetInfoViewAndScreen(PVGASTATE pVGAState, uint32_t u32ViewIndex, VBVAINFOVIEW *pView, VBVAINFOSCREEN *pScreen);
+int     VBVAInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
+void    VBVADestroy(PVGASTATECC pThisCC);
+int     VBVAUpdateDisplay(PVGASTATE pThis, PVGASTATECC pThisCC);
+void    VBVAReset(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
+void    VBVAOnVBEChanged(PVGASTATE pThis, PVGASTATECC pThisCC);
+void    VBVAOnResume(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
+
+bool    VBVAIsPaused(PVGASTATECC pThisCC);
+#ifdef UNUSED_FUNCTION
+bool    VBVAIsEnabled(PVGASTATECC pThisCC);
+#endif
+
+void    VBVARaiseIrq(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t fFlags);
+
+int     VBVAInfoScreen(PVGASTATE pThis, const VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_HOST *pScreen);
+#ifdef UNUSED_FUNCTION
+int     VBVAGetInfoViewAndScreen(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t u32ViewIndex,
+                                 VBVAINFOVIEW *pView, VBVAINFOSCREEN *pScreen);
+#endif
 
 /* @return host-guest flags that were set on reset
@@ -673 +707 @@
 DECLCALLBACK(int) vbvaR3VHWACommandCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface,
                                                  VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd);
-int vbvaVHWAConstruct(PVGASTATE pVGAState);
-int vbvaVHWAReset(PVGASTATE pVGAState);
-
-void vbvaTimerCb(PVGASTATE pVGAState);
+int vbvaVHWAConstruct(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
+
+void vbvaTimerCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
 
 int vboxVBVASaveStatePrep(PPDMDEVINS pDevIns);
@@ -682 +715 @@
 # endif
 
-#define PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(_pcb) ( (PVGASTATE)((uint8_t *)(_pcb) - RT_OFFSETOF(VGASTATE, IVBVACallbacks)) )
-
 int vboxVBVASaveStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM);
 int vboxVBVALoadStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t u32Version);
@@ -693 +724 @@
 # ifdef VBOX_WITH_VDMA
 typedef struct VBOXVDMAHOST *PVBOXVDMAHOST;
-int vboxVDMAConstruct(PVGASTATE pVGAState, uint32_t cPipeElements);
+int vboxVDMAConstruct(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t cPipeElements);
 void vboxVDMADestruct(PVBOXVDMAHOST pVdma);
 void vboxVDMAReset(PVBOXVDMAHOST pVdma);
@@ -708 +739 @@
 
 # ifdef VBOX_WITH_VMSVGA
-int vgaR3RegisterVRAMHandler(PVGASTATE pVGAState, uint64_t cbFrameBuffer);
-int vgaR3UnregisterVRAMHandler(PVGASTATE pVGAState);
-int vgaR3UpdateDisplay(PVGASTATE pVGAState, unsigned xStart, unsigned yStart, unsigned width, unsigned height);
+int vgaR3UnregisterVRAMHandler(PPDMDEVINS pDevIns, PVGASTATE pThis);
+int vgaR3RegisterVRAMHandler(PPDMDEVINS pDevIns, PVGASTATE pThis, uint64_t cbFrameBuffer);
+int vgaR3UpdateDisplay(PVGASTATE pThis, unsigned xStart, unsigned yStart, unsigned width, unsigned height);
 # endif
 

trunk/src/VBox/Devices/Graphics/DevVGATmpl.h

@@ -181 +181 @@
  * 4 color mode
  */
-static void RT_CONCAT(vga_draw_line2_, DEPTH)(VGAState *s1, uint8_t *d,
+static void RT_CONCAT(vga_draw_line2_, DEPTH)(VGAState *s1, PVGASTATER3 pThisCC, uint8_t *d,
                                               const uint8_t *s, int width)
 {
     uint32_t plane_mask, *palette, data, v, src_inc, dwb_mode;
     int x;
+    RT_NOREF(pThisCC);
 
     palette = s1->last_palette;
@@ -225 +226 @@
  * 4 color mode, dup2 horizontal
  */
-static void RT_CONCAT(vga_draw_line2d2_, DEPTH)(VGAState *s1, uint8_t *d,
+static void RT_CONCAT(vga_draw_line2d2_, DEPTH)(VGAState *s1, PVGASTATER3 pThisCC, uint8_t *d,
                                                 const uint8_t *s, int width)
 {
     uint32_t plane_mask, *palette, data, v, src_inc, dwb_mode;
     int x;
+    RT_NOREF(pThisCC);
 
     palette = s1->last_palette;
@@ -260 +262 @@
  * 16 color mode
  */
-static void RT_CONCAT(vga_draw_line4_, DEPTH)(VGAState *s1, uint8_t *d,
+static void RT_CONCAT(vga_draw_line4_, DEPTH)(VGAState *s1, PVGASTATER3 pThisCC, uint8_t *d,
                                               const uint8_t *s, int width)
 {
     uint32_t plane_mask, data, v, *palette, vram_ofs;
     int x;
-
-    vram_ofs = s - s1->vram_ptrR3;
+    RT_NOREF(pThisCC);
+
+    vram_ofs = s - pThisCC->pbVRam;
     palette = s1->last_palette;
     plane_mask = mask16[s1->ar[0x12] & 0xf];
     width >>= 3;
     for(x = 0; x < width; x++) {
-        s = s1->vram_ptrR3 + (vram_ofs & s1->vga_addr_mask);
+        s = pThisCC->pbVRam + (vram_ofs & s1->vga_addr_mask);
         data = ((uint32_t *)s)[0];
         data &= plane_mask;
@@ -294 +297 @@
  * 16 color mode, dup2 horizontal
  */
-static void RT_CONCAT(vga_draw_line4d2_, DEPTH)(VGAState *s1, uint8_t *d,
+static void RT_CONCAT(vga_draw_line4d2_, DEPTH)(VGAState *s1, PVGASTATER3 pThisCC, uint8_t *d,
                                                 const uint8_t *s, int width)
 {
     uint32_t plane_mask, data, v, *palette;
     int x;
+    RT_NOREF(pThisCC);
 
     palette = s1->last_palette;
@@ -328 +332 @@
  * XXX: add plane_mask support (never used in standard VGA modes)
  */
-static void RT_CONCAT(vga_draw_line8d2_, DEPTH)(VGAState *s1, uint8_t *d,
+static void RT_CONCAT(vga_draw_line8d2_, DEPTH)(VGAState *s1, PVGASTATER3 pThisCC, uint8_t *d,
                                                 const uint8_t *s, int width)
 {
     uint32_t *palette;
     int x;
+    RT_NOREF(pThisCC);
 
     palette = s1->last_palette;
@@ -351 +356 @@
  * XXX: add plane_mask support (never used in standard VGA modes)
  */
-static void RT_CONCAT(vga_draw_line8_, DEPTH)(VGAState *s1, uint8_t *d,
+static void RT_CONCAT(vga_draw_line8_, DEPTH)(VGAState *s1, PVGASTATER3 pThisCC, uint8_t *d,
                                               const uint8_t *s, int width)
 {
     uint32_t *palette;
     int x;
+    RT_NOREF(pThisCC);
 
     palette = s1->last_palette;
@@ -381 +387 @@
  * 15 bit color
  */
-static void RT_CONCAT(vga_draw_line15_, DEPTH)(VGAState *s1, uint8_t *d,
+static void RT_CONCAT(vga_draw_line15_, DEPTH)(VGAState *s1, PVGASTATER3 pThisCC, uint8_t *d,
                                                const uint8_t *s, int width)
 {
+    RT_NOREF(s1, pThisCC);
 #if DEPTH == 15 && defined(WORDS_BIGENDIAN) == defined(TARGET_WORDS_BIGENDIAN)
     memcpy(d, s, width * 2);
@@ -401 +408 @@
     } while (--w != 0);
 #endif
-    NOREF(s1);
 }
 
@@ -407 +413 @@
  * 16 bit color
  */
-static void RT_CONCAT(vga_draw_line16_, DEPTH)(VGAState *s1, uint8_t *d,
+static void RT_CONCAT(vga_draw_line16_, DEPTH)(VGAState *s1, PVGASTATER3 pThisCC, uint8_t *d,
                                                const uint8_t *s, int width)
 {
+    RT_NOREF(s1, pThisCC);
 #if DEPTH == 16 && defined(WORDS_BIGENDIAN) == defined(TARGET_WORDS_BIGENDIAN)
     memcpy(d, s, width * 2);
@@ -427 +434 @@
     } while (--w != 0);
 #endif
-    NOREF(s1);
 }
 
@@ -433 +439 @@
  * 24 bit color
  */
-static void RT_CONCAT(vga_draw_line24_, DEPTH)(VGAState *s1, uint8_t *d,
+static void RT_CONCAT(vga_draw_line24_, DEPTH)(VGAState *s1, PVGASTATER3 pThisCC, uint8_t *d,
                                                const uint8_t *s, int width)
 {
     int w;
     uint32_t r, g, b;
-    NOREF(s1);
+    RT_NOREF(s1, pThisCC);
 
     w = width;
@@ -460 +466 @@
  * 32 bit color
  */
-static void RT_CONCAT(vga_draw_line32_, DEPTH)(VGAState *s1, uint8_t *d,
+static void RT_CONCAT(vga_draw_line32_, DEPTH)(VGAState *s1, PVGASTATER3 pThisCC, uint8_t *d,
                                                const uint8_t *s, int width)
 {
+    RT_NOREF(s1, pThisCC);
 #if DEPTH == 32 && defined(WORDS_BIGENDIAN) == defined(TARGET_WORDS_BIGENDIAN)
     memcpy(d, s, width * 4);
@@ -485 +492 @@
     } while (--w != 0);
 #endif
-    NOREF(s1);
 }
 

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

@@ -383 +383 @@
 }
 
-static int vbvaFlushProcess(unsigned uScreenId, PVGASTATE pVGAState, VBVADATA *pVBVAData)
+static int vbvaFlushProcess(PVGASTATECC pThisCC, VBVADATA *pVBVAData, unsigned uScreenId)
 {
     LOGVBVABUFFER(("uScreenId %d, indexRecordFirst = %d, indexRecordFree = %d, off32Data = %d, off32Free = %d\n",
                    uScreenId, pVBVAData->indexRecordFirst, pVBVAData->guest.pVBVA->indexRecordFree,
                    pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
-    struct {
+    struct
+    {
         /* The rectangle that includes all dirty rectangles. */
         int32_t xLeft;
@@ -430 +431 @@
             if (!fUpdate)
             {
-                pVGAState->pDrv->pfnVBVAUpdateBegin(pVGAState->pDrv, uScreenId);
+                pThisCC->pDrv->pfnVBVAUpdateBegin(pThisCC->pDrv, uScreenId);
                 fUpdate = true;
             }
 
             /* Updates the rectangle and sends the command to the VRDP server. */
-            pVGAState->pDrv->pfnVBVAUpdateProcess(pVGAState->pDrv, uScreenId, pHdr, cbCmd);
+            pThisCC->pDrv->pfnVBVAUpdateProcess(pThisCC->pDrv, uScreenId, pHdr, cbCmd);
 
             int32_t xRight  = pHdr->x + pHdr->w;
@@ -492 +493 @@
                      dirtyRect.yTop, dirtyRect.xRight - dirtyRect.xLeft,
                      dirtyRect.yBottom - dirtyRect.yTop));
-            pVGAState->pDrv->pfnVBVAUpdateEnd(pVGAState->pDrv, uScreenId, dirtyRect.xLeft, dirtyRect.yTop,
+            pThisCC->pDrv->pfnVBVAUpdateEnd(pThisCC->pDrv, uScreenId, dirtyRect.xLeft, dirtyRect.yTop,
                                               dirtyRect.xRight - dirtyRect.xLeft, dirtyRect.yBottom - dirtyRect.yTop);
         }
         else
         {
-            pVGAState->pDrv->pfnVBVAUpdateEnd(pVGAState->pDrv, uScreenId, 0, 0, 0, 0);
+            pThisCC->pDrv->pfnVBVAUpdateEnd(pThisCC->pDrv, uScreenId, 0, 0, 0, 0);
         }
     }
@@ -504 +505 @@
 }
 
-static int vbvaFlush(PVGASTATE pVGAState, VBVACONTEXT *pCtx)
+static int vbvaFlush(PVGASTATE pThis, PVGASTATECC pThisCC, VBVACONTEXT *pCtx)
 {
     int rc = VINF_SUCCESS;
@@ -514 +515 @@
         if (pVBVAData->guest.pVBVA)
         {
-            rc = vbvaFlushProcess(uScreenId, pVGAState, pVBVAData);
+            rc = vbvaFlushProcess(pThisCC, pVBVAData, uScreenId);
             if (RT_FAILURE(rc))
                 break;
@@ -524 +525 @@
         /* Turn off VBVA processing. */
         LogRel(("VBVA: Disabling (%Rrc)\n", rc));
-        pVGAState->fGuestCaps = 0;
-        pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
+        pThis->fGuestCaps = 0;
+        pThisCC->pDrv->pfnVBVAGuestCapabilityUpdate(pThisCC->pDrv, pThis->fGuestCaps);
         for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
         {
@@ -532 +533 @@
             {
                 vbvaDataCleanup(pVBVAData);
-                pVGAState->pDrv->pfnVBVADisable(pVGAState->pDrv, uScreenId);
+                pThisCC->pDrv->pfnVBVADisable(pThisCC->pDrv, uScreenId);
             }
         }
@@ -540 +541 @@
 }
 
-static int vbvaResize(PVGASTATE pVGAState, VBVAVIEW *pView, const VBVAINFOSCREEN *pNewScreen, bool fResetInputMapping)
+static int vbvaResize(PVGASTATECC pThisCC, VBVAVIEW *pView, const VBVAINFOSCREEN *pNewScreen, bool fResetInputMapping)
 {
     /* Callers ensure that pNewScreen contains valid data. */
@@ -547 +548 @@
     pView->screen = *pNewScreen;
 
-    uint8_t *pu8VRAM = pVGAState->vram_ptrR3 + pView->view.u32ViewOffset;
-    return pVGAState->pDrv->pfnVBVAResize (pVGAState->pDrv, &pView->view, &pView->screen, pu8VRAM, fResetInputMapping);
-}
-
-static int vbvaEnable(unsigned uScreenId, PVGASTATE pVGAState, VBVACONTEXT *pCtx,
+    uint8_t *pbVRam = pThisCC->pbVRam + pView->view.u32ViewOffset;
+    return pThisCC->pDrv->pfnVBVAResize(pThisCC->pDrv, &pView->view, &pView->screen, pbVRam, fResetInputMapping);
+}
+
+static int vbvaEnable(PVGASTATE pThis, PVGASTATECC pThisCC, VBVACONTEXT *pCtx, unsigned uScreenId,
                       VBVABUFFER RT_UNTRUSTED_VOLATILE_GUEST *pVBVA, uint32_t u32Offset, bool fRestored)
 {
@@ -563 +564 @@
     uint32_t const cbVBVABuffer = RT_UOFFSETOF(VBVABUFFER, au8Data) + VbgaSafe.cbData;
     ASSERT_GUEST_RETURN(   VbgaSafe.cbData <= UINT32_MAX - RT_UOFFSETOF(VBVABUFFER, au8Data)
-                        && cbVBVABuffer <= pVGAState->vram_size
-                        && u32Offset <= pVGAState->vram_size - cbVBVABuffer,
+                        && cbVBVABuffer <= pThis->vram_size
+                        && u32Offset <= pThis->vram_size - cbVBVABuffer,
                         VERR_INVALID_PARAMETER);
     if (!fRestored)
@@ -582 +583 @@
      */
     int rc;
-    if (pVGAState->pDrv->pfnVBVAEnable)
+    if (pThisCC->pDrv->pfnVBVAEnable)
     {
         pVBVA->hostFlags.u32HostEvents      = 0;
         pVBVA->hostFlags.u32SupportedOrders = 0;
-        rc = pVGAState->pDrv->pfnVBVAEnable(pVGAState->pDrv, uScreenId, &pVBVA->hostFlags);
+        rc = pThisCC->pDrv->pfnVBVAEnable(pThisCC->pDrv, uScreenId, &pVBVA->hostFlags);
         if (RT_SUCCESS(rc))
         {
@@ -623 +624 @@
 }
 
-static int vbvaDisable (unsigned uScreenId, PVGASTATE pVGAState, VBVACONTEXT *pCtx)
+static int vbvaDisable(PVGASTATE pThis, PVGASTATECC pThisCC, VBVACONTEXT *pCtx, unsigned idScreen)
 {
     /* Process any pending orders and empty the VBVA ring buffer. */
-    vbvaFlush (pVGAState, pCtx);
-
-    VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
+    vbvaFlush(pThis, pThisCC, pCtx);
+
+    AssertReturn(idScreen < RT_ELEMENTS(pCtx->aViews), VERR_OUT_OF_RANGE);
+    VBVADATA *pVBVAData = &pCtx->aViews[idScreen].vbva;
     vbvaDataCleanup(pVBVAData);
 
-    if (uScreenId == 0)
-    {
-        pVGAState->fGuestCaps = 0;
-        pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
-    }
-    pVGAState->pDrv->pfnVBVADisable(pVGAState->pDrv, uScreenId);
+    if (idScreen == 0)
+    {
+        pThis->fGuestCaps = 0;
+        pThisCC->pDrv->pfnVBVAGuestCapabilityUpdate(pThisCC->pDrv, pThis->fGuestCaps);
+    }
+    pThisCC->pDrv->pfnVBVADisable(pThisCC->pDrv, idScreen);
     return VINF_SUCCESS;
 }
 
-bool VBVAIsEnabled(PVGASTATE pVGAState)
-{
-    PHGSMIINSTANCE pHGSMI = pVGAState->pHGSMI;
+#ifdef UNUSED_FUNCTION
+bool VBVAIsEnabled(PVGASTATECC pThisCC)
+{
+    PHGSMIINSTANCE pHGSMI = pThisCC->pHGSMI;
     if (pHGSMI)
     {
@@ -658 +661 @@
     return false;
 }
+#endif
 
 #ifdef DEBUG_sunlover
@@ -677 +681 @@
 #endif
 
-static int vbvaUpdateMousePointerShape(PVGASTATE pVGAState, VBVAMOUSESHAPEINFO *pMouseShapeInfo, bool fShape)
-{
-    LogFlowFunc(("pVGAState %p, pMouseShapeInfo %p, fShape %d\n",
-                  pVGAState, pMouseShapeInfo, fShape));
+static int vbvaUpdateMousePointerShape(PVGASTATECC pThisCC, VBVAMOUSESHAPEINFO *pMouseShapeInfo, bool fShape)
+{
+    LogFlowFunc(("pThisCC %p, pMouseShapeInfo %p, fShape %d\n", pThisCC, pMouseShapeInfo, fShape));
 #ifdef DEBUG_sunlover
     dumpMouseShapeInfo(pMouseShapeInfo);
 #endif
 
-    if (pVGAState->pDrv->pfnVBVAMousePointerShape == NULL)
-    {
+    if (pThisCC->pDrv->pfnVBVAMousePointerShape == NULL)
         return VERR_NOT_SUPPORTED;
-    }
 
     int rc;
     if (fShape && pMouseShapeInfo->pu8Shape != NULL)
-    {
-        rc = pVGAState->pDrv->pfnVBVAMousePointerShape (pVGAState->pDrv,
-                                                        pMouseShapeInfo->fVisible,
-                                                        pMouseShapeInfo->fAlpha,
-                                                        pMouseShapeInfo->u32HotX,
-                                                        pMouseShapeInfo->u32HotY,
-                                                        pMouseShapeInfo->u32Width,
-                                                        pMouseShapeInfo->u32Height,
-                                                        pMouseShapeInfo->pu8Shape);
-    }
+        rc = pThisCC->pDrv->pfnVBVAMousePointerShape(pThisCC->pDrv,
+                                                     pMouseShapeInfo->fVisible,
+                                                     pMouseShapeInfo->fAlpha,
+                                                     pMouseShapeInfo->u32HotX,
+                                                     pMouseShapeInfo->u32HotY,
+                                                     pMouseShapeInfo->u32Width,
+                                                     pMouseShapeInfo->u32Height,
+                                                     pMouseShapeInfo->pu8Shape);
     else
-    {
-        rc = pVGAState->pDrv->pfnVBVAMousePointerShape (pVGAState->pDrv,
-                                                        pMouseShapeInfo->fVisible,
-                                                        false,
-                                                        0, 0,
-                                                        0, 0,
-                                                        NULL);
-    }
-
+        rc = pThisCC->pDrv->pfnVBVAMousePointerShape(pThisCC->pDrv,
+                                                     pMouseShapeInfo->fVisible,
+                                                     false,
+                                                     0, 0,
+                                                     0, 0,
+                                                     NULL);
     return rc;
 }
 
-static int vbvaMousePointerShape(PVGASTATE pVGAState, VBVACONTEXT *pCtx,
+static int vbvaMousePointerShape(PVGASTATECC pThisCC, VBVACONTEXT *pCtx,
                                  const VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *pShape, HGSMISIZE cbShape)
 {
@@ -790 +786 @@
     }
 
-    return vbvaUpdateMousePointerShape(pVGAState, &pCtx->mouseShapeInfo, fShape);
+    return vbvaUpdateMousePointerShape(pThisCC, &pCtx->mouseShapeInfo, fShape);
 }
 
@@ -855 +851 @@
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
+
 static void vbvaVHWAHHCommandReinit(VBOXVHWACMD* pHdr, VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay)
 {
@@ -887 +884 @@
 }
 
-static void vbvaVHWACommandComplete(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
+static void vbvaVHWACommandComplete(PVGASTATECC pThisCC, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
 {
     if (fAsyncCommand)
     {
         Assert(pCommand->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
-        vbvaR3VHWACommandCompleteAsync(&pVGAState->IVBVACallbacks, pCommand);
+        vbvaR3VHWACommandCompleteAsync(&pThisCC->IVBVACallbacks, pCommand);
     }
     else
@@ -902 +899 @@
 }
 
-static void vbvaVHWACommandCompleteAllPending(PVGASTATE pVGAState, int rc)
-{
-    if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
+static void vbvaVHWACommandCompleteAllPending(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, int rc)
+{
+    if (!ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending))
         return;
 
-    PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
+    PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
 
     VBOX_VHWA_PENDINGCMD *pIter, *pNext;
-    RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
+    RTListForEachSafe(&pThis->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
     {
         pIter->pCommand->rc = rc;
-        vbvaVHWACommandComplete(pVGAState, pIter->pCommand, true);
+        vbvaVHWACommandComplete(pThisCC, pIter->pCommand, true);
 
         /* the command is submitted/processed, remove from the pend list */
         RTListNodeRemove(&pIter->Node);
-        ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
+        ASMAtomicDecU32(&pThis->pendingVhwaCommands.cPending);
         RTMemFree(pIter);
     }
 
-    PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
-}
-
-static void vbvaVHWACommandClearAllPending(PVGASTATE pVGAState)
-{
-    if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
+    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
+}
+
+static void vbvaVHWACommandClearAllPending(PPDMDEVINS pDevIns, PVGASTATE pThis)
+{
+    if (!ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending))
         return;
 
-    PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
+    PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
 
     VBOX_VHWA_PENDINGCMD *pIter, *pNext;
-    RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
+    RTListForEachSafe(&pThis->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
     {
         RTListNodeRemove(&pIter->Node);
-        ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
+        ASMAtomicDecU32(&pThis->pendingVhwaCommands.cPending);
         RTMemFree(pIter);
     }
 
-    PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
-}
-
-static void vbvaVHWACommandPend(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand)
+    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
+}
+
+static void vbvaVHWACommandPend(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
+                                VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand)
 {
     int rc = VERR_BUFFER_OVERFLOW;
 
-    if (ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
+    if (ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
     {
         VBOX_VHWA_PENDINGCMD *pPend = (VBOX_VHWA_PENDINGCMD *)RTMemAlloc(sizeof(*pPend));
@@ -953 +951 @@
             pCommand->Flags |= VBOXVHWACMD_FLAG_HG_ASYNCH;
             pPend->pCommand = pCommand;
-            PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
-            if (ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
-            {
-                RTListAppend(&pVGAState->pendingVhwaCommands.PendingList, &pPend->Node);
-                ASMAtomicIncU32(&pVGAState->pendingVhwaCommands.cPending);
-                PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
+            PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
+            if (ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
+            {
+                RTListAppend(&pThis->pendingVhwaCommands.PendingList, &pPend->Node);
+                ASMAtomicIncU32(&pThis->pendingVhwaCommands.cPending);
+                PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
                 return;
             }
-            PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
+            PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
             LogRel(("VBVA: Pending command count has reached its threshold.. completing them all.."));
             RTMemFree(pPend);
@@ -971 +969 @@
         LogRel(("VBVA: Pending command count has reached its threshold, completing them all.."));
 
-    vbvaVHWACommandCompleteAllPending(pVGAState, rc);
+    vbvaVHWACommandCompleteAllPending(pDevIns, pThis, pThisCC, rc);
 
     pCommand->rc = rc;
 
-    vbvaVHWACommandComplete(pVGAState, pCommand, false);
+    vbvaVHWACommandComplete(pThisCC, pCommand, false);
 }
 
@@ -993 +991 @@
 }
 
-static int vbvaVHWACommandSavePending(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM)
-{
-    int rc = pHlp->pfnSSMPutU32(pSSM, pVGAState->pendingVhwaCommands.cPending);
+static int vbvaVHWACommandSavePending(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PVGASTATECC pThisCC, PSSMHANDLE pSSM)
+{
+    int rc = pHlp->pfnSSMPutU32(pSSM, pThis->pendingVhwaCommands.cPending);
     AssertRCReturn(rc, rc);
 
     VBOX_VHWA_PENDINGCMD *pIter;
-    RTListForEach(&pVGAState->pendingVhwaCommands.PendingList, pIter, VBOX_VHWA_PENDINGCMD, Node)
-    {
-        AssertContinue((uintptr_t)pIter->pCommand - (uintptr_t)pVGAState->vram_ptrR3 < pVGAState->vram_size);
-        rc = pHlp->pfnSSMPutU32(pSSM, (uint32_t)(((uint8_t *)pIter->pCommand) - ((uint8_t *)pVGAState->vram_ptrR3)));
+    RTListForEach(&pThis->pendingVhwaCommands.PendingList, pIter, VBOX_VHWA_PENDINGCMD, Node)
+    {
+        AssertContinue((uintptr_t)pIter->pCommand - (uintptr_t)pThisCC->pbVRam < pThis->vram_size);
+        rc = pHlp->pfnSSMPutU32(pSSM, (uint32_t)(((uint8_t *)pIter->pCommand) - ((uint8_t *)pThisCC->pbVRam)));
         AssertRCReturn(rc, rc);
     }
@@ -1008 +1006 @@
 }
 
-static int vbvaVHWACommandLoadPending(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM, uint32_t u32Version)
+static int vbvaVHWACommandLoadPending(PPDMDEVINS pDevIns, PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PVGASTATECC pThisCC,
+                                      PSSMHANDLE pSSM, uint32_t u32Version)
 {
     if (u32Version < VGA_SAVEDSTATE_VERSION_WITH_PENDVHWA)
@@ -1022 +1021 @@
         AssertRCReturn(rc, rc);
         VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand
-            = (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)((uint8_t volatile *)pVGAState->vram_ptrR3 + off32);
-        vbvaVHWACommandPend(pVGAState, pCommand);
+            = (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)((uint8_t volatile *)pThisCC->pbVRam + off32);
+        vbvaVHWACommandPend(pDevIns, pThis, pThisCC, pCommand);
     }
     return rc;
@@ -1030 +1029 @@
 
 /** Worker for vbvaVHWACommandSubmit. */
-static bool vbvaVHWACommandSubmitInner(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool *pfPending)
+static bool vbvaVHWACommandSubmitInner(PVGASTATE pThis, PVGASTATECC pThisCC,
+                                       VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool *pfPending)
 {
     *pfPending = false;
@@ -1040 +1040 @@
     RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
 
-    bool fGuestCmd = (uintptr_t)pCommand - (uintptr_t)pVGAState->vram_ptrR3 < pVGAState->vram_size;
+    bool fGuestCmd = (uintptr_t)pCommand - (uintptr_t)pThisCC->pbVRam < pThis->vram_size;
     ASSERT_GUEST_LOGREL_MSG_STMT_RETURN(   !fGuestCmd
                                         || (   enmCmd != VBOXVHWACMD_TYPE_HH_CONSTRUCT
@@ -1053 +1053 @@
                                         pCommand->rc = VERR_INVALID_PARAMETER,
                                         true);
-    ASSERT_GUEST_STMT_RETURN(pVGAState->pDrv->pfnVHWACommandProcess, pCommand->rc = VERR_INVALID_STATE, true);
+    ASSERT_GUEST_STMT_RETURN(pThisCC->pDrv->pfnVHWACommandProcess, pCommand->rc = VERR_INVALID_STATE, true);
     RT_UNTRUSTED_VALIDATED_FENCE();
 
@@ -1060 +1060 @@
      */
     Log(("VGA Command >>> %#p, %d\n", pCommand, enmCmd));
-    int rc = pVGAState->pDrv->pfnVHWACommandProcess(pVGAState->pDrv, enmCmd, fGuestCmd, pCommand);
+    int rc = pThisCC->pDrv->pfnVHWACommandProcess(pThisCC->pDrv, enmCmd, fGuestCmd, pCommand);
     if (rc == VINF_CALLBACK_RETURN)
     {
@@ -1089 +1089 @@
 
 
-static bool vbvaVHWACommandSubmit(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
+static bool vbvaVHWACommandSubmit(PVGASTATE pThis, PVGASTATECC pThisCC,
+                                  VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
 {
     bool fPending = false;
-    bool fRet = vbvaVHWACommandSubmitInner(pVGAState, pCommand, &fPending);
+    bool fRet = vbvaVHWACommandSubmitInner(pThis, pThisCC, pCommand, &fPending);
     if (!fPending)
-        vbvaVHWACommandComplete(pVGAState, pCommand, fAsyncCommand);
+        vbvaVHWACommandComplete(pThisCC, pCommand, fAsyncCommand);
     return fRet;
 }
@@ -1102 +1103 @@
  * @returns false if commands are pending, otherwise true.
  */
-static bool vbvaVHWACheckPendingCommands(PVGASTATE pVGAState)
-{
-    if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
+static bool vbvaVHWACheckPendingCommands(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
+{
+    if (!ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending))
         return true;
 
-    PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
+    PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
 
     VBOX_VHWA_PENDINGCMD *pIter, *pNext;
-    RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
-    {
-        if (!vbvaVHWACommandSubmit(pVGAState, pIter->pCommand, true))
-        {
-            PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
+    RTListForEachSafe(&pThis->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
+    {
+        if (!vbvaVHWACommandSubmit(pThis, pThisCC, pIter->pCommand, true))
+        {
+            PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
             return false; /* the command should be still pending */
         }
@@ -1120 +1121 @@
         /* the command is submitted/processed, remove from the pend list */
         RTListNodeRemove(&pIter->Node);
-        ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
+        ASMAtomicDecU32(&pThis->pendingVhwaCommands.cPending);
         RTMemFree(pIter);
     }
 
-    PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
+    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
 
     return true;
 }
 
-void vbvaTimerCb(PVGASTATE pVGAState)
-{
-    vbvaVHWACheckPendingCommands(pVGAState);
-}
-
-static void vbvaVHWAHandleCommand(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
-{
-    if (vbvaVHWACheckPendingCommands(pVGAState))
-    {
-        if (vbvaVHWACommandSubmit(pVGAState, pCmd, false))
+void vbvaTimerCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
+{
+    vbvaVHWACheckPendingCommands(pDevIns, pThis, pThisCC);
+}
+
+static void vbvaVHWAHandleCommand(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
+                                  VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
+{
+    if (vbvaVHWACheckPendingCommands(pDevIns, pThis, pThisCC))
+    {
+        if (vbvaVHWACommandSubmit(pThis, pThisCC, pCmd, false))
             return;
     }
 
-    vbvaVHWACommandPend(pVGAState, pCmd);
+    vbvaVHWACommandPend(pDevIns, pThis, pThisCC, pCmd);
 }
 
@@ -1150 +1152 @@
 }
 
-static int vbvaVHWAHHCommandPost(PVGASTATE pVGAState, VBOXVHWACMD *pCmd)
+static int vbvaVHWAHHCommandPost(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, VBOXVHWACMD *pCmd)
 {
     RTSEMEVENT hComplEvent;
@@ -1161 +1163 @@
 
         VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandSetEventCallback, (void *)hComplEvent);
-        vbvaVHWAHandleCommand(pVGAState, pCmd);
+        vbvaVHWAHandleCommand(pDevIns, pThis, pThisCC, pCmd);
 
         if ((ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags) & VBOXVHWACMD_FLAG_HG_ASYNCH) != 0)
@@ -1176 +1178 @@
 }
 
-int vbvaVHWAConstruct(PVGASTATE pVGAState)
-{
-    pVGAState->pendingVhwaCommands.cPending = 0;
-    RTListInit(&pVGAState->pendingVhwaCommands.PendingList);
+int vbvaVHWAConstruct(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
+{
+    pThis->pendingVhwaCommands.cPending = 0;
+    RTListInit(&pThis->pendingVhwaCommands.PendingList);
 
     VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_CONSTRUCT, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
@@ -1189 +1191 @@
         VBOXVHWACMD_HH_CONSTRUCT *pBody = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
 
-        do
+        for (;;)
         {
             memset(pBody, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
 
-            PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
             PVM pVM = PDMDevHlpGetVM(pDevIns);
 
             pBody->pVM = pVM;
-            pBody->pvVRAM = pVGAState->vram_ptrR3;
-            pBody->cbVRAM = pVGAState->vram_size;
-
-            rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
+            pBody->pvVRAM = pThisCC->pbVRam;
+            pBody->cbVRAM = pThis->vram_size;
+
+            rc = vbvaVHWAHHCommandPost(pDevIns, pThis, pThisCC, pCmd);
             ASMCompilerBarrier();
 
@@ -1210 +1211 @@
                 if(rc == VERR_NOT_IMPLEMENTED)
                 {
-                    /** @todo set some flag in pVGAState indicating VHWA is not supported */
+                    /** @todo set some flag in pThis indicating VHWA is not supported */
                     /* VERR_NOT_IMPLEMENTED is not a failure, we just do not support it */
                     rc = VINF_SUCCESS;
@@ -1222 +1223 @@
 
             ++iDisplay;
-            if (iDisplay >= pVGAState->cMonitors)
+            if (iDisplay >= pThis->cMonitors)
                 break;
             vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_CONSTRUCT, (int32_t)iDisplay);
-        } while (true);
+        }
 
         vbvaVHWAHHCommandRelease(pCmd);
@@ -1234 +1235 @@
 }
 
-int vbvaVHWAReset(PVGASTATE pVGAState)
-{
-    vbvaVHWACommandClearAllPending(pVGAState);
+static int vbvaVHWAReset(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
+{
+    vbvaVHWACommandClearAllPending(pDevIns, pThis);
 
     /* ensure we have all pending cmds processed and h->g cmds disabled */
@@ -1248 +1249 @@
         do
         {
-            rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
+            rc = vbvaVHWAHHCommandPost(pDevIns, pThis, pThisCC, pCmd);
             AssertRC(rc);
             if(RT_SUCCESS(rc))
@@ -1262 +1263 @@
 
             ++iDisplay;
-            if (iDisplay >= pVGAState->cMonitors)
+            if (iDisplay >= pThis->cMonitors)
                 break;
             vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_RESET, (int32_t)iDisplay);
@@ -1275 +1276 @@
 }
 
-typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPRECB(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext);
+typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPRECB(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, VBOXVHWACMD *pCmd,
+                                                uint32_t iDisplay, void *pvContext);
 typedef FNVBOXVHWAHHCMDPRECB *PFNVBOXVHWAHHCMDPRECB;
 
-typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPOSTCB(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext);
+typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPOSTCB(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, VBOXVHWACMD *pCmd,
+                                                 uint32_t iDisplay, int rc, void *pvContext);
 typedef FNVBOXVHWAHHCMDPOSTCB *PFNVBOXVHWAHHCMDPOSTCB;
 
-int vbvaVHWAHHPost(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, PFNVBOXVHWAHHCMDPRECB pfnPre, PFNVBOXVHWAHHCMDPOSTCB pfnPost, void *pvContext)
+static int vbvaVHWAHHPost(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, VBOXVHWACMD *pCmd,
+                          PFNVBOXVHWAHHCMDPRECB pfnPre, PFNVBOXVHWAHHCMDPOSTCB pfnPost, void *pvContext)
 {
     const VBOXVHWACMD_TYPE enmType = pCmd->enmCmd;
@@ -1289 +1293 @@
     do
     {
-        if (!pfnPre || pfnPre(pVGAState, pCmd, iDisplay, pvContext))
-        {
-            rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
+        if (!pfnPre || pfnPre(pDevIns, pThis, pThisCC, pCmd, iDisplay, pvContext))
+        {
+            rc = vbvaVHWAHHCommandPost(pDevIns, pThis, pThisCC, pCmd);
             AssertRC(rc);
             if (pfnPost)
             {
-                if (!pfnPost(pVGAState, pCmd, iDisplay, rc, pvContext))
+                if (!pfnPost(pDevIns, pThis, pThisCC, pCmd, iDisplay, rc, pvContext))
                 {
                     rc = VINF_SUCCESS;
@@ -1317 +1321 @@
 
         ++iDisplay;
-        if (iDisplay >= pVGAState->cMonitors)
+        if (iDisplay >= pThis->cMonitors)
             break;
         vbvaVHWAHHCommandReinit(pCmd, enmType, (int32_t)iDisplay);
@@ -1326 +1330 @@
 
 /** @todo call this also on reset? */
-int vbvaVHWAEnable (PVGASTATE pVGAState, bool bEnable)
+static int vbvaVHWAEnable(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, bool bEnable)
 {
     const VBOXVHWACMD_TYPE enmType = bEnable ? VBOXVHWACMD_TYPE_HH_ENABLE : VBOXVHWACMD_TYPE_HH_DISABLE;
@@ -1333 +1337 @@
     if(pCmd)
     {
-        int rc = vbvaVHWAHHPost (pVGAState, pCmd, NULL, NULL, NULL);
+        int rc = vbvaVHWAHHPost(pDevIns, pThis, pThisCC, pCmd, NULL, NULL, NULL);
         vbvaVHWAHHCommandRelease(pCmd);
         return rc;
@@ -1343 +1347 @@
 {
     /* ensure we have no pending commands */
-    return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), false);
+    return vbvaVHWAEnable(pDevIns, PDMDEVINS_2_DATA(pDevIns, PVGASTATE), PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC), false);
 }
 
@@ -1349 +1353 @@
 {
     /* ensure we have no pending commands */
-    return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), true);
-}
+    return vbvaVHWAEnable(pDevIns, PDMDEVINS_2_DATA(pDevIns, PVGASTATE), PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC), true);
+}
+
 
 /**
@@ -1358 +1363 @@
                                                  VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
 {
-    PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface);
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IVBVACallbacks);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     int rc;
+
     Log(("VGA Command <<< Async rc %d %#p, %d\n", pCmd->rc, pCmd, pCmd->enmCmd));
 
-    if ((uintptr_t)pCmd - (uintptr_t)pVGAState->vram_ptrR3 < pVGAState->vram_size)
-    {
-        PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
+    if ((uintptr_t)pCmd - (uintptr_t)pThisCC->pbVRam < pThis->vram_size)
+    {
+        PHGSMIINSTANCE pIns = pThisCC->pHGSMI;
         Assert(!(pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD));
         Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
 #ifdef VBOX_WITH_WDDM
-        if (pVGAState->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD)
+        if (pThis->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD)
         {
             rc = HGSMICompleteGuestCommand(pIns, pCmd, !!(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
@@ -1449 +1457 @@
 } VBOXVBVASAVEDSTATECBDATA, *PVBOXVBVASAVEDSTATECBDATA;
 
-static DECLCALLBACK(bool) vboxVBVASaveStateBeginPostCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay,
-                                                       int rc, void *pvContext)
-{
-    RT_NOREF(pVGAState, pCmd);
+/**
+ * @callback_method_impl{FNVBOXVHWAHHCMDPOSTCB}
+ */
+static DECLCALLBACK(bool) vboxVBVASaveStateBeginPostCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
+                                                       VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext)
+{
+    RT_NOREF(pDevIns, pThis, pThisCC, pCmd);
     PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
     if (RT_FAILURE(pData->rc))
@@ -1483 +1494 @@
 }
 
-static DECLCALLBACK(bool)
-vboxVBVASaveStatePerformPreCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
-{
-    RT_NOREF(pVGAState, pCmd);
+/**
+ * @callback_method_impl{FNVBOXVHWAHHCMDPRECB}
+ */
+static DECLCALLBACK(bool) vboxVBVASaveStatePerformPreCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
+                                                        VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
+{
+    RT_NOREF(pThis, pThisCC, pCmd);
     PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
     if (RT_FAILURE(pData->rc))
@@ -1499 +1513 @@
 
     int rc;
-    PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
+    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
 
     if (pData->ab2DOn[iDisplay])
@@ -1522 +1536 @@
 }
 
-static DECLCALLBACK(bool) vboxVBVASaveStateEndPreCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
-{
-    RT_NOREF(pVGAState, pCmd);
+/**
+ * @callback_method_impl{FNVBOXVHWAHHCMDPOSTCB}
+ */
+static DECLCALLBACK(bool) vboxVBVASaveStateEndPreCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
+                                                    VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
+{
+    RT_NOREF(pDevIns, pThis, pThisCC, pCmd);
     PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
     Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
     if (pData->ab2DOn[iDisplay])
-    {
         return true;
-    }
-
     return false;
 }
 
-static DECLCALLBACK(bool)
-vboxVBVALoadStatePerformPostCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext)
-{
-    RT_NOREF(pVGAState, pCmd);
+/**
+ * @callback_method_impl{FNVBOXVHWAHHCMDPOSTCB}
+ */
+static DECLCALLBACK(bool) vboxVBVALoadStatePerformPostCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
+                                                         VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext)
+{
+    RT_NOREF(pThis, pThisCC, pCmd);
     PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
     if (RT_FAILURE(pData->rc))
@@ -1555 +1573 @@
     }
 
-    PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
+    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
     Assert(RT_SUCCESS(pCmd->rc) || pCmd->rc == VERR_NOT_IMPLEMENTED);
     if (pCmd->rc == VERR_NOT_IMPLEMENTED)
@@ -1572 +1590 @@
 }
 
-static DECLCALLBACK(bool)
-vboxVBVALoadStatePerformPreCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
-{
-    RT_NOREF(pVGAState, pCmd);
+/**
+ * @callback_method_impl{FNVBOXVHWAHHCMDPOSTCB}
+ */
+static DECLCALLBACK(bool) vboxVBVALoadStatePerformPreCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
+                                                        VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
+{
+    RT_NOREF(pThis, pThisCC, pCmd);
     PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
     if (RT_FAILURE(pData->rc))
@@ -1587 +1608 @@
     }
 
-    PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
+    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
     int rc;
     uint32_t u32;
@@ -1610 +1631 @@
     }
 }
-#endif /* #ifdef VBOX_WITH_VIDEOHWACCEL */
-
-int vboxVBVASaveDevStateExec(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM)
-{
-    PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
+
+#endif /* VBOX_WITH_VIDEOHWACCEL */
+
+static int vboxVBVASaveDevStateExec(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PVGASTATECC pThisCC, PSSMHANDLE pSSM)
+{
+    PHGSMIINSTANCE pIns = pThisCC->pHGSMI;
     int rc = HGSMIHostSaveStateExec(pHlp, pIns, pSSM);
     if (RT_SUCCESS(rc))
@@ -1713 +1735 @@
             rc = pHlp->pfnSSMPutU32(pSSM, 4);
             AssertRCReturn(rc, rc);
-            rc = pHlp->pfnSSMPutU32(pSSM, pVGAState->fGuestCaps);
+            rc = pHlp->pfnSSMPutU32(pSSM, pThis->fGuestCaps);
             AssertRCReturn(rc, rc);
 #else
@@ -1737 +1759 @@
 int vboxVBVASaveStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
-    PVGASTATE       pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
-    PCPDMDEVHLPR3   pHlp      = pDevIns->pHlpR3;
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
     int rc;
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -1746 +1769 @@
     VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN, 0, cbCmd);
     Assert(pCmd);
-    if(pCmd)
-    {
-        vbvaVHWAHHPost(pVGAState, pCmd, NULL, vboxVBVASaveStateBeginPostCb, &VhwaData);
+    if (pCmd)
+    {
+        vbvaVHWAHHPost(pDevIns, pThis, pThisCC, pCmd, NULL, vboxVBVASaveStateBeginPostCb, &VhwaData);
         rc = VhwaData.rc;
         AssertRC(rc);
@@ -1754 +1777 @@
         {
 #endif
-            rc = vboxVBVASaveDevStateExec(pHlp, pVGAState, pSSM);
+            rc = vboxVBVASaveDevStateExec(pHlp, pThis, pThisCC, pSSM);
             AssertRC(rc);
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -1762 +1785 @@
                 VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM);
                 pSave->pSSM = pSSM;
-                vbvaVHWAHHPost(pVGAState, pCmd, vboxVBVASaveStatePerformPreCb, NULL, &VhwaData);
+                vbvaVHWAHHPost(pDevIns, pThis, pThisCC, pCmd, vboxVBVASaveStatePerformPreCb, NULL, &VhwaData);
                 rc = VhwaData.rc;
                 AssertRC(rc);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = vbvaVHWACommandSavePending(pHlp, pVGAState, pSSM);
+                    rc = vbvaVHWACommandSavePending(pHlp, pThis, pThisCC, pSSM);
                     AssertRCReturn(rc, rc);
 
                     vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND, 0);
-                    vbvaVHWAHHPost(pVGAState, pCmd, vboxVBVASaveStateEndPreCb, NULL, &VhwaData);
+                    vbvaVHWAHHPost(pDevIns, pThis, pThisCC, pCmd, vboxVBVASaveStateEndPreCb, NULL, &VhwaData);
                     rc = VhwaData.rc;
                     AssertRC(rc);
@@ -1785 +1808 @@
     if (RT_SUCCESS(rc))
     {
-        for (uint32_t i = 0; i < pVGAState->cMonitors; ++i)
+        for (uint32_t i = 0; i < pThis->cMonitors; ++i)
         {
             rc = pHlp->pfnSSMPutU32(pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC);
@@ -1806 +1829 @@
     }
 
-    PVGASTATE       pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
-    PHGSMIINSTANCE  pIns      = pVGAState->pHGSMI;
-    PCPDMDEVHLPR3   pHlp      = pDevIns->pHlpR3;
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    PHGSMIINSTANCE  pIns    = pThisCC->pHGSMI;
+    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
     int rc = HGSMIHostLoadStateExec(pHlp, pIns, pSSM, uVersion);
     if (RT_SUCCESS(rc))
@@ -1941 +1965 @@
                 if (cbExtra >= 4)
                 {
-                    rc = pHlp->pfnSSMGetU32 (pSSM, &pVGAState->fGuestCaps);
+                    rc = pHlp->pfnSSMGetU32 (pSSM, &pThis->fGuestCaps);
                     AssertRCReturn(rc, rc);
-                    pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
+                    pThisCC->pDrv->pfnVBVAGuestCapabilityUpdate(pThisCC->pDrv, pThis->fGuestCaps);
                     cbExtra -= 4;
                 }
@@ -2001 +2025 @@
                     VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM);
                     pLoad->pSSM = pSSM;
-                    vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVALoadStatePerformPreCb, vboxVBVALoadStatePerformPostCb, &VhwaData);
+                    vbvaVHWAHHPost(pDevIns, pThis, pThisCC, pCmd, vboxVBVALoadStatePerformPreCb,
+                                   vboxVBVALoadStatePerformPostCb, &VhwaData);
                     rc = VhwaData.rc;
                     vbvaVHWAHHCommandRelease(pCmd);
@@ -2008 +2033 @@
                     if (fLoadCommands)
                     {
-                        rc = vbvaVHWACommandLoadPending(pHlp, pVGAState, pSSM, uVersion);
+                        rc = vbvaVHWACommandLoadPending(pDevIns, pHlp, pThis, pThisCC, pSSM, uVersion);
                         AssertRCReturn(rc, rc);
                     }
@@ -2019 +2044 @@
                 uint32_t u32;
 
-                for (uint32_t i = 0; i < pVGAState->cMonitors; ++i)
+                for (uint32_t i = 0; i < pThis->cMonitors; ++i)
                 {
                     rc = pHlp->pfnSSMGetU32(pSSM, &u32);
@@ -2056 +2081 @@
 int vboxVBVALoadStateDone(PPDMDEVINS pDevIns)
 {
-    PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
-    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
     if (pCtx)
     {
@@ -2066 +2092 @@
             if (pView->vbva.guest.pVBVA)
             {
-                int rc = vbvaEnable(iView, pVGAState, pCtx, pView->vbva.guest.pVBVA, pView->vbva.u32VBVAOffset, true /* fRestored */);
+                int rc = vbvaEnable(pThis, pThisCC, pCtx, iView, pView->vbva.guest.pVBVA,
+                                    pView->vbva.u32VBVAOffset, true /* fRestored */);
                 if (RT_SUCCESS(rc))
-                    vbvaResize(pVGAState, pView, &pView->screen, false);
+                    vbvaResize(pThisCC, pView, &pView->screen, false);
                 else
                     LogRel(("VBVA: can not restore: %Rrc\n", rc));
@@ -2075 +2102 @@
 
         if (pCtx->mouseShapeInfo.fSet)
-            vbvaUpdateMousePointerShape(pVGAState, &pCtx->mouseShapeInfo, true);
+            vbvaUpdateMousePointerShape(pThisCC, &pCtx->mouseShapeInfo, true);
     }
 
@@ -2081 +2108 @@
 }
 
-void VBVARaiseIrq(PVGASTATE pVGAState, uint32_t fFlags)
-{
-    PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
-
-    PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSectIRQ, VERR_SEM_BUSY);
-
-    const uint32_t fu32CurrentGuestFlags = HGSMIGetHostGuestFlags(pVGAState->pHGSMI);
+void VBVARaiseIrq(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t fFlags)
+{
+    PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIRQ, VERR_SEM_BUSY);
+
+    const uint32_t fu32CurrentGuestFlags = HGSMIGetHostGuestFlags(pThisCC->pHGSMI);
     if ((fu32CurrentGuestFlags & HGSMIHOSTFLAGS_IRQ) == 0)
     {
         /* No IRQ set yet. */
-        Assert(pVGAState->fu32PendingGuestFlags == 0);
-
-        HGSMISetHostGuestFlags(pVGAState->pHGSMI, HGSMIHOSTFLAGS_IRQ | fFlags);
+        Assert(pThis->fu32PendingGuestFlags == 0);
+
+        HGSMISetHostGuestFlags(pThisCC->pHGSMI, HGSMIHOSTFLAGS_IRQ | fFlags);
 
         /* If VM is not running, the IRQ will be set in VBVAOnResume. */
@@ -2104 +2129 @@
     {
         /* IRQ already set, remember the new flags. */
-        pVGAState->fu32PendingGuestFlags |= HGSMIHOSTFLAGS_IRQ | fFlags;
-    }
-
-    PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSectIRQ);
-}
-
-void VBVAOnResume(PVGASTATE pThis)
-{
-    PPDMDEVINS pDevIns = pThis->pDevInsR3;
-
+        pThis->fu32PendingGuestFlags |= HGSMIHOSTFLAGS_IRQ | fFlags;
+    }
+
+    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSectIRQ);
+}
+
+void VBVAOnResume(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
+{
     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIRQ, VERR_SEM_BUSY);
 
-    if (HGSMIGetHostGuestFlags(pThis->pHGSMI) & HGSMIHOSTFLAGS_IRQ)
+    if (HGSMIGetHostGuestFlags(pThisCC->pHGSMI) & HGSMIHOSTFLAGS_IRQ)
         PDMDevHlpPCISetIrqNoWait(pDevIns, 0, PDM_IRQ_LEVEL_HIGH);
 
@@ -2122 +2145 @@
 }
 
-static int vbvaHandleQueryConf32(PVGASTATE pVGAState, VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *pConf32)
+static int vbvaHandleQueryConf32(PVGASTATECC pThisCC, VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *pConf32)
 {
     uint32_t const idxQuery = pConf32->u32Index;
@@ -2128 +2151 @@
     LogFlowFunc(("VBVA_QUERY_CONF32: u32Index %d, u32Value 0x%x\n", idxQuery, pConf32->u32Value));
 
-    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
+    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
     uint32_t     uValue;
     if (idxQuery == VBOX_VBVA_CONF32_MONITOR_COUNT)
@@ -2173 +2196 @@
 }
 
-static int vbvaHandleInfoHeap(PVGASTATE pVGAState, const VBVAINFOHEAP RT_UNTRUSTED_VOLATILE_GUEST *pInfoHeap)
+static int vbvaHandleInfoHeap(PVGASTATECC pThisCC, const VBVAINFOHEAP RT_UNTRUSTED_VOLATILE_GUEST *pInfoHeap)
 {
     uint32_t const offHeap = pInfoHeap->u32HeapOffset;
@@ -2180 +2203 @@
     LogFlowFunc(("VBVA_INFO_HEAP: offset 0x%x, size 0x%x\n", offHeap, cbHeap));
 
-    return HGSMIHostHeapSetup(pVGAState->pHGSMI, offHeap, cbHeap);
-}
-
-int VBVAInfoView(PVGASTATE pVGAState, const VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST *pView)
+    return HGSMIHostHeapSetup(pThisCC->pHGSMI, offHeap, cbHeap);
+}
+
+static int vbvaInfoView(PVGASTATE pThis, PVGASTATER3 pThisCC, const VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST *pView)
 {
     VBVAINFOVIEW view;
@@ -2192 +2215 @@
                  view.u32ViewIndex, view.u32ViewOffset, view.u32ViewSize, view.u32MaxScreenSize));
 
-    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
+    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
     ASSERT_GUEST_LOGREL_MSG_RETURN(   view.u32ViewIndex     < pCtx->cViews
-                                   && view.u32ViewOffset    <= pVGAState->vram_size
-                                   && view.u32ViewSize      <= pVGAState->vram_size
-                                   && view.u32ViewOffset    <= pVGAState->vram_size - view.u32ViewSize
+                                   && view.u32ViewOffset    <= pThis->vram_size
+                                   && view.u32ViewSize      <= pThis->vram_size
+                                   && view.u32ViewOffset    <= pThis->vram_size - view.u32ViewSize
                                    && view.u32MaxScreenSize <= view.u32ViewSize,
                                    ("index %d(%d), offset 0x%x, size 0x%x, max 0x%x, vram size 0x%x\n",
                                     view.u32ViewIndex, pCtx->cViews, view.u32ViewOffset, view.u32ViewSize,
-                                    view.u32MaxScreenSize, pVGAState->vram_size),
+                                    view.u32MaxScreenSize, pThis->vram_size),
                                    VERR_INVALID_PARAMETER);
     RT_UNTRUSTED_VALIDATED_FENCE();
@@ -2208 +2231 @@
 }
 
-int VBVAInfoScreen(PVGASTATE pVGAState, const VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_GUEST *pScreen)
+static int vbvaInfoScreen(PVGASTATECC pThisCC, const VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_GUEST *pScreen)
 {
     /*
@@ -2225 +2248 @@
      */
     /* Allow screen.u16BitsPerPixel == 0 because legacy guest code used it for screen blanking. */
-    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
+    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
     ASSERT_GUEST_LOGREL_MSG_RETURN(screen.u32ViewIndex <  pCtx->cViews,
                                    ("Screen index %#x is out of bound (cViews=%#x)\n", screen.u32ViewIndex, pCtx->cViews),
@@ -2258 +2281 @@
      * Do the job.
      */
-    vbvaResize(pVGAState, &pCtx->aViews[screen.u32ViewIndex], &screen, true);
+    vbvaResize(pThisCC, &pCtx->aViews[screen.u32ViewIndex], &screen, true);
     return VINF_SUCCESS;
 }
 
-int VBVAGetInfoViewAndScreen(PVGASTATE pVGAState, uint32_t u32ViewIndex, VBVAINFOVIEW *pView, VBVAINFOSCREEN *pScreen)
-{
-    if (u32ViewIndex >= pVGAState->cMonitors)
+#ifdef UNUSED_FUNCTION
+int VBVAGetInfoViewAndScreen(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t u32ViewIndex, VBVAINFOVIEW *pView, VBVAINFOSCREEN *pScreen)
+{
+    if (u32ViewIndex >= pThis->cMonitors)
         return VERR_INVALID_PARAMETER;
 
-    PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
+    PHGSMIINSTANCE pIns = pThisCC->pHGSMI;
     VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pIns);
 
@@ -2278 +2302 @@
     return VINF_SUCCESS;
 }
-
-static int vbvaHandleEnable(PVGASTATE pVGAState, uint32_t fEnableFlags, uint32_t offEnable, uint32_t idScreen)
+#endif
+
+static int vbvaHandleEnable(PVGASTATE pThis, PVGASTATER3 pThisCC, uint32_t fEnableFlags, uint32_t offEnable, uint32_t idScreen)
 {
     LogFlowFunc(("VBVA_ENABLE[%u]: fEnableFlags=0x%x offEnable=%#x\n", idScreen, fEnableFlags, offEnable));
-    PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
+    PHGSMIINSTANCE pIns = pThisCC->pHGSMI;
     VBVACONTEXT   *pCtx = (VBVACONTEXT *)HGSMIContext(pIns);
 
@@ -2295 +2320 @@
     if (fEnableFlags & VBVA_F_ENABLE)
     {
-        ASSERT_GUEST_LOGREL_MSG_RETURN(offEnable < pVGAState->vram_size,
-                                       ("offEnable=%#x vram_size=%#x\n", offEnable, pVGAState->vram_size),
+        ASSERT_GUEST_LOGREL_MSG_RETURN(offEnable < pThis->vram_size,
+                                       ("offEnable=%#x vram_size=%#x\n", offEnable, pThis->vram_size),
                                        VERR_INVALID_PARAMETER);
         if (fEnableFlags & VBVA_F_ABSOFFSET)
             /* Offset from VRAM start. */
-            ASSERT_GUEST_LOGREL_MSG_RETURN(   pVGAState->vram_size >= RT_UOFFSETOF(VBVABUFFER, au8Data)
-                                           && offEnable <= pVGAState->vram_size - RT_UOFFSETOF(VBVABUFFER, au8Data),
-                                           ("offEnable=%#x vram_size=%#x\n", offEnable, pVGAState->vram_size),
+            ASSERT_GUEST_LOGREL_MSG_RETURN(   pThis->vram_size >= RT_UOFFSETOF(VBVABUFFER, au8Data)
+                                           && offEnable <= pThis->vram_size - RT_UOFFSETOF(VBVABUFFER, au8Data),
+                                           ("offEnable=%#x vram_size=%#x\n", offEnable, pThis->vram_size),
                                            VERR_INVALID_PARAMETER);
         else
@@ -2309 +2334 @@
             RT_UNTRUSTED_VALIDATED_FENCE();
             const VBVAINFOVIEW *pView = &pCtx->aViews[idScreen].view;
-            ASSERT_GUEST_LOGREL_MSG_RETURN(   pVGAState->vram_size - offEnable >= pView->u32ViewOffset
+            ASSERT_GUEST_LOGREL_MSG_RETURN(   pThis->vram_size - offEnable >= pView->u32ViewOffset
                                            && pView->u32ViewSize >= RT_UOFFSETOF(VBVABUFFER, au8Data)
                                            && offEnable <= pView->u32ViewSize - RT_UOFFSETOF(VBVABUFFER, au8Data),
                                            ("offEnable=%#x vram_size=%#x view: %#x LB %#x\n",
-                                            offEnable, pVGAState->vram_size, pView->u32ViewOffset, pView->u32ViewSize),
+                                            offEnable, pThis->vram_size, pView->u32ViewOffset, pView->u32ViewSize),
                                            VERR_INVALID_PARAMETER);
             offEnable += pView->u32ViewOffset;
@@ -2335 +2360 @@
 
         /* Process any pending orders and empty the VBVA ring buffer. */
-        vbvaFlush(pVGAState, pCtx);
-
-        rc = vbvaEnable(idScreen, pVGAState, pCtx, pVBVA, offEnable, false /* fRestored */);
+        vbvaFlush(pThis, pThisCC, pCtx);
+
+        rc = vbvaEnable(pThis, pThisCC, pCtx, idScreen, pVBVA, offEnable, false /* fRestored */);
         if (RT_FAILURE(rc))
             LogRelMax(8, ("VBVA: can not enable: %Rrc\n", rc));
     }
     else
-        rc = vbvaDisable(idScreen, pVGAState, pCtx);
+        rc = vbvaDisable(pThis, pThisCC, pCtx, idScreen);
     return rc;
 }
 
-static int vbvaHandleQueryModeHints(PVGASTATE pVGAState, VBVAQUERYMODEHINTS volatile *pQueryModeHints, HGSMISIZE cbBuffer)
-{
-    PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
+static int vbvaHandleQueryModeHints(PVGASTATECC pThisCC, VBVAQUERYMODEHINTS volatile *pQueryModeHints, HGSMISIZE cbBuffer)
+{
+    PHGSMIINSTANCE pIns = pThisCC->pHGSMI;
     VBVACONTEXT   *pCtx = (VBVACONTEXT *)HGSMIContext(pIns);
 
@@ -2391 +2416 @@
  */
 
-static DECLCALLBACK(void) vbvaNotifyGuest (void *pvCallback)
+static DECLCALLBACK(void) vbvaNotifyGuest(void *pvCallback)
 {
 #if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM))
-    PVGASTATE pVGAState = (PVGASTATE)pvCallback;
-    VBVARaiseIrq (pVGAState, 0);
+    PPDMDEVINS pDevIns = (PPDMDEVINS)pvCallback;
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    VBVARaiseIrq(pDevIns, pThis, pThisCC, 0);
 #else
     NOREF(pvCallback);
@@ -2422 +2449 @@
     LogFlowFunc(("pvHandler %p, u16ChannelInfo %d, pvBuffer %p, cbBuffer %u\n", pvHandler, u16ChannelInfo, pvBuffer, cbBuffer));
 
-    PVGASTATE       pVGAState = (PVGASTATE)pvHandler;
-    PHGSMIINSTANCE  pIns      = pVGAState->pHGSMI;
-    VBVACONTEXT    *pCtx      = (VBVACONTEXT *)HGSMIContext(pIns);
+    PPDMDEVINS      pDevIns = (PPDMDEVINS)pvHandler;
+    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    PHGSMIINSTANCE  pIns    = pThisCC->pHGSMI;
+    VBVACONTEXT    *pCtx    = (VBVACONTEXT *)HGSMIContext(pIns);
 
     switch (u16ChannelInfo)
@@ -2434 +2463 @@
                 VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_GUEST *pCmd
                     = (VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_GUEST *)VBoxSHGSMIBufferData((VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
-                vboxVDMACommand(pVGAState->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
+                vboxVDMACommand(pThisCC->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
                 rc = VINF_SUCCESS;
             }
@@ -2446 +2475 @@
                 VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_GUEST *pCmd
                     = (VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_GUEST *)VBoxSHGSMIBufferData((VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
-                vboxVDMAControl(pVGAState->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
+                vboxVDMAControl(pThisCC->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
             }
             else
@@ -2455 +2484 @@
         case VBVA_QUERY_CONF32:
             if (cbBuffer >= sizeof(VBVACONF32))
-                rc = vbvaHandleQueryConf32(pVGAState, (VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
+                rc = vbvaHandleQueryConf32(pThisCC, (VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
             else
                 rc = VERR_INVALID_PARAMETER;
@@ -2478 +2507 @@
                      ++pView, cbBuffer -= sizeof(VBVAINFOVIEW))
                 {
-                    rc = VBVAInfoView(pVGAState, pView);
+                    rc = vbvaInfoView(pThis, pThisCC, pView);
                     if (RT_FAILURE(rc))
                         break;
@@ -2487 +2516 @@
         case VBVA_INFO_HEAP:
             if (cbBuffer >= sizeof(VBVAINFOHEAP))
-                rc = vbvaHandleInfoHeap(pVGAState, (VBVAINFOHEAP RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
+                rc = vbvaHandleInfoHeap(pThisCC, (VBVAINFOHEAP RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
             else
                 rc = VERR_INVALID_PARAMETER;
@@ -2494 +2523 @@
         case VBVA_FLUSH:
             if (cbBuffer >= sizeof(VBVAFLUSH))
-                rc = vbvaFlush(pVGAState, pCtx);
+                rc = vbvaFlush(pThis, pThisCC, pCtx);
             else
                 rc = VERR_INVALID_PARAMETER;
@@ -2502 +2531 @@
             rc = VERR_INVALID_PARAMETER;
             if (cbBuffer >= sizeof(VBVAINFOSCREEN))
-                rc = VBVAInfoScreen(pVGAState, (VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
+                rc = vbvaInfoScreen(pThisCC, (VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
             break;
 
@@ -2524 +2553 @@
                     idScreen = vbvaViewFromBufferPtr(pIns, pCtx, pvBuffer);
 
-                rc = vbvaHandleEnable(pVGAState, fEnableFlags, offEnable, idScreen);
+                rc = vbvaHandleEnable(pThis, pThisCC, fEnableFlags, offEnable, idScreen);
                 pVbvaEnable->i32Result = rc;
             }
@@ -2534 +2563 @@
                 VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *pShape
                     = (VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
-                rc = vbvaMousePointerShape(pVGAState, pCtx, pShape, cbBuffer);
+                rc = vbvaMousePointerShape(pThisCC, pCtx, pShape, cbBuffer);
                 pShape->i32Result = rc;
             }
@@ -2546 +2575 @@
             if (cbBuffer >= VBOXVHWACMD_HEADSIZE())
             {
-                vbvaVHWAHandleCommand(pVGAState, (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
+                vbvaVHWAHandleCommand(pDevIns, pThis, pThisCC, (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
                 rc = VINF_SUCCESS;
             }
@@ -2559 +2588 @@
             {
                 VBVACAPS RT_UNTRUSTED_VOLATILE_GUEST *pCaps = (VBVACAPS RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
-                pVGAState->fGuestCaps = pCaps->fCaps;
+                pThis->fGuestCaps = pCaps->fCaps;
                 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
 
-                pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
+                pThisCC->pDrv->pfnVBVAGuestCapabilityUpdate(pThisCC->pDrv, pThis->fGuestCaps);
                 pCaps->rc = rc = VINF_SUCCESS;
             }
@@ -2574 +2603 @@
             {
                 VBVASCANLINECFG RT_UNTRUSTED_VOLATILE_GUEST *pCfg = (VBVASCANLINECFG RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
-                pVGAState->fScanLineCfg = pCfg->fFlags;
+                pThis->fScanLineCfg = pCfg->fFlags;
                 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
 
@@ -2588 +2617 @@
                 VBVAQUERYMODEHINTS RT_UNTRUSTED_VOLATILE_GUEST *pQueryModeHints
                     = (VBVAQUERYMODEHINTS RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
-                rc = vbvaHandleQueryModeHints(pVGAState, pQueryModeHints, cbBuffer);
+                rc = vbvaHandleQueryModeHints(pThisCC, pQueryModeHints, cbBuffer);
                 pQueryModeHints->rc = rc;
             }
@@ -2611 +2640 @@
                 LogRelFlowFunc(("VBVA: ChannelHandler: VBVA_REPORT_INPUT_MAPPING: x=%RI32, y=%RI32, cx=%RU32, cy=%RU32\n",
                                 inputMapping.x, inputMapping.y, inputMapping.cx, inputMapping.cy));
-                pVGAState->pDrv->pfnVBVAInputMappingUpdate(pVGAState->pDrv,
+                pThisCC->pDrv->pfnVBVAInputMappingUpdate(pThisCC->pDrv,
                                                            inputMapping.x, inputMapping.y,
                                                            inputMapping.cx, inputMapping.cy);
@@ -2633 +2662 @@
                                 RT_BOOL(Report.fReportPosition), vbvaViewFromBufferPtr(pIns, pCtx, pvBuffer), Report.x, Report.y));
 
-                pVGAState->pDrv->pfnVBVAReportCursorPosition(pVGAState->pDrv, RT_BOOL(Report.fReportPosition), vbvaViewFromBufferPtr(pIns, pCtx, pvBuffer), Report.x, Report.y);
+                pThisCC->pDrv->pfnVBVAReportCursorPosition(pThisCC->pDrv, RT_BOOL(Report.fReportPosition), vbvaViewFromBufferPtr(pIns, pCtx, pvBuffer), Report.x, Report.y);
                 /* This was only ever briefly used by the guest, and a value
                  * of zero in both was taken to mean "ignore". */
@@ -2652 +2681 @@
 }
 
-/* When VBVA is paused, then VGA device is allowed to work but
+/** When VBVA is paused, the VGA device is allowed to work but
  * no HGSMI etc state is changed.
  */
-void VBVAPause(PVGASTATE pVGAState, bool fPause)
-{
-    if (!pVGAState || !pVGAState->pHGSMI)
-    {
+static void vbvaPause(PVGASTATECC pThisCC, bool fPause)
+{
+    if (!pThisCC || !pThisCC->pHGSMI)
         return;
-    }
-
-    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
-
+
+    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
     if (pCtx)
-    {
         pCtx->fPaused = fPause;
-    }
-}
-
-bool VBVAIsPaused(PVGASTATE pVGAState)
-{
-    if (pVGAState && pVGAState->pHGSMI)
-    {
-        const VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
+}
+
+bool VBVAIsPaused(PVGASTATECC pThisCC)
+{
+    if (pThisCC && pThisCC->pHGSMI)
+    {
+        const VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
         if (pCtx && pCtx->cViews)
         {
@@ -2687 +2711 @@
 }
 
-void VBVAOnVBEChanged(PVGASTATE pVGAState)
+void VBVAOnVBEChanged(PVGASTATE pThis, PVGASTATECC pThisCC)
 {
     /* The guest does not depend on host handling the VBE registers. */
-    if (pVGAState->fGuestCaps & VBVACAPS_USE_VBVA_ONLY)
-    {
+    if (pThis->fGuestCaps & VBVACAPS_USE_VBVA_ONLY)
         return;
-    }
-
-    VBVAPause(pVGAState, (pVGAState->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) == 0);
-}
-
-void VBVAReset (PVGASTATE pVGAState)
-{
-    if (!pVGAState || !pVGAState->pHGSMI)
-    {
+
+    vbvaPause(pThisCC, (pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) == 0);
+}
+
+void VBVAReset(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
+{
+    if (!pThis || !pThisCC->pHGSMI)
         return;
-    }
-
-    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pVGAState->pHGSMI);
+
+    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
-    vbvaVHWAReset (pVGAState);
+    vbvaVHWAReset(pDevIns, pThis, pThisCC);
 #endif
 
-    HGSMIReset(pVGAState->pHGSMI);
+    HGSMIReset(pThisCC->pHGSMI);
     /* Make sure the IRQ is reset. */
-    PDMDevHlpPCISetIrq(pVGAState->pDevInsR3, 0, PDM_IRQ_LEVEL_LOW);
-    pVGAState->fu32PendingGuestFlags = 0;
+    PDMDevHlpPCISetIrq(pDevIns, 0, PDM_IRQ_LEVEL_LOW);
+    pThis->fu32PendingGuestFlags = 0;
 
     if (pCtx)
     {
-        vbvaFlush (pVGAState, pCtx);
-
-        unsigned uScreenId;
-
-        for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
-        {
-            vbvaDisable (uScreenId, pVGAState, pCtx);
-        }
+        vbvaFlush(pThis, pThisCC, pCtx);
+
+        for (unsigned idScreen = 0; idScreen < pCtx->cViews; idScreen++)
+            vbvaDisable(pThis, pThisCC, pCtx, idScreen);
 
         pCtx->mouseShapeInfo.fSet = false;
@@ -2736 +2752 @@
 }
 
-int VBVAUpdateDisplay (PVGASTATE pVGAState)
+int VBVAUpdateDisplay(PVGASTATE pThis, PVGASTATECC pThisCC)
 {
     int rc = VERR_NOT_SUPPORTED; /* Assuming that the VGA device will have to do updates. */
 
-    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pVGAState->pHGSMI);
-
+    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
     if (pCtx)
     {
         if (!pCtx->fPaused)
         {
-            rc = vbvaFlush (pVGAState, pCtx);
-
-            if (RT_SUCCESS (rc))
+            rc = vbvaFlush(pThis, pThisCC, pCtx);
+            if (RT_SUCCESS(rc))
             {
                 if (!pCtx->aViews[0].vbva.guest.pVBVA)
@@ -2762 +2776 @@
 }
 
-static int vbvaSendModeHintWorker(PVGASTATE pThis, uint32_t cx, uint32_t cy,
-                                  uint32_t cBPP, uint32_t iDisplay, uint32_t dx,
+static int vbvaSendModeHintWorker(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
+                                  uint32_t cx, uint32_t cy, uint32_t cBPP, uint32_t iDisplay, uint32_t dx,
                                   uint32_t dy, uint32_t fEnabled,
                                   uint32_t fNotifyGuest)
 {
-    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThis->pHGSMI);
+    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
     /** @note See Display::setVideoModeHint: "It is up to the guest to decide
      *  whether the hint is valid. Therefore don't do any VRAM sanity checks
@@ -2781 +2795 @@
     pCtx->aModeHints[iDisplay].fEnabled = fEnabled;
     if (fNotifyGuest && pThis->fGuestCaps & VBVACAPS_IRQ && pThis->fGuestCaps & VBVACAPS_VIDEO_MODE_HINTS)
-        VBVARaiseIrq(pThis, HGSMIHOSTFLAGS_HOTPLUG);
+        VBVARaiseIrq(pDevIns, pThis, pThisCC, HGSMIHOSTFLAGS_HOTPLUG);
     return VINF_SUCCESS;
 }
 
-/** Converts a display port interface pointer to a vga state pointer. */
-#define IDISPLAYPORT_2_VGASTATE(pInterface) ( (PVGASTATE)((uintptr_t)pInterface - RT_OFFSETOF(VGASTATE, IPort)) )
 
 /**
@@ -2794 +2806 @@
                                          uint32_t iDisplay, uint32_t dx, uint32_t dy, uint32_t fEnabled, uint32_t fNotifyGuest)
 {
-    PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
-    int rc = PDMDevHlpCritSectEnter(pThis->pDevInsR3, &pThis->CritSect, VERR_SEM_BUSY);
+    PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IPort);
+    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     AssertRC(rc);
 
-    rc = vbvaSendModeHintWorker(pThis, cx, cy, cBPP, iDisplay, dx, dy, fEnabled, fNotifyGuest);
-
-    PDMDevHlpCritSectLeave(pThis->pDevInsR3, &pThis->CritSect);
+    rc = vbvaSendModeHintWorker(pDevIns, pThis, pThisCC, cx, cy, cBPP, iDisplay, dx, dy, fEnabled, fNotifyGuest);
+
+    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     return rc;
 }
 
-int VBVAInit(PVGASTATE pVGAState)
-{
-    PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
-
+int VBVAInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
+{
     PVM pVM = PDMDevHlpGetVM(pDevIns);
 
-    int rc = HGSMICreate(&pVGAState->pHGSMI,
+    int rc = HGSMICreate(&pThisCC->pHGSMI,
                          pVM,
                          "VBVA",
                          0,
-                         pVGAState->vram_ptrR3,
-                         pVGAState->vram_size,
+                         pThisCC->pbVRam,
+                         pThis->vram_size,
                          vbvaNotifyGuest,
-                         pVGAState,
+                         pDevIns,
                          sizeof(VBVACONTEXT));
      if (RT_SUCCESS(rc))
      {
-         rc = HGSMIHostChannelRegister(pVGAState->pHGSMI,
+         rc = HGSMIHostChannelRegister(pThisCC->pHGSMI,
                                        HGSMI_CH_VBVA,
                                        vbvaChannelHandler,
-                                       pVGAState);
+                                       pDevIns);
          if (RT_SUCCESS(rc))
          {
-             VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
-             pCtx->cViews = pVGAState->cMonitors;
+             VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
+             pCtx->cViews = pThis->cMonitors;
              pCtx->fPaused = true;
              memset(pCtx->aModeHints, ~0, sizeof(pCtx->aModeHints));
@@ -2838 +2850 @@
 }
 
-void VBVADestroy(PVGASTATE pVGAState)
-{
-    PHGSMIINSTANCE pHgsmi = pVGAState->pHGSMI;
+void VBVADestroy(PVGASTATECC pThisCC)
+{
+    PHGSMIINSTANCE pHgsmi = pThisCC->pHGSMI;
     if (pHgsmi)
     {
@@ -2851 +2863 @@
 
         HGSMIDestroy(pHgsmi);
-        pVGAState->pHGSMI = NULL;
-    }
-}
-
+        pThisCC->pHGSMI = NULL;
+    }
+}
+

trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp

@@ -172 +172 @@
 {
     PHGSMIINSTANCE pHgsmi; /**< Same as VGASTATE::pHgsmi. */
-    PVGASTATE pVGAState;
+    PVGASTATE pThis;
 } VBOXVDMAHOST, *PVBOXVDMAHOST;
 
@@ -186 +186 @@
 
 
-/*********************************************************************************************************************************
-*   Internal Functions                                                                                                           *
-*********************************************************************************************************************************/
 
 
@@ -196 +193 @@
  * @returns VBox status code.
  */
-int vboxVDMAConstruct(PVGASTATE pVGAState, uint32_t cPipeElements)
+int vboxVDMAConstruct(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t cPipeElements)
 {
     RT_NOREF(cPipeElements);
-    int rc;
     PVBOXVDMAHOST pVdma = (PVBOXVDMAHOST)RTMemAllocZ(sizeof(*pVdma));
     Assert(pVdma);
     if (pVdma)
     {
-        pVdma->pHgsmi    = pVGAState->pHGSMI;
-        pVdma->pVGAState = pVGAState;
-
-        rc = VINF_SUCCESS;
-        if (RT_SUCCESS(rc))
-        {
-                        pVGAState->pVdma = pVdma;
-
-                        return VINF_SUCCESS;
-            /* the timer is cleaned up automatically */
-        }
-        RTMemFree(pVdma);
-    }
-    else
-        rc = VERR_OUT_OF_RESOURCES;
-    return rc;
+        pVdma->pHgsmi = pThisCC->pHGSMI;
+        pVdma->pThis  = pThis;
+
+        pThisCC->pVdma = pVdma;
+        return VINF_SUCCESS;
+    }
+    return VERR_NO_MEMORY;
 }