Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp	(revision 32988)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp	(revision 32989)
@@ -2025,5 +2025,5 @@
       VBoxSetupDisplaysHGSMI((PDEVICE_EXTENSION)HwDeviceExtension, ConfigInfo, AdapterMemorySize);
 
-      if (hgsmiFromDeviceExt((PDEVICE_EXTENSION)HwDeviceExtension)->bHGSMI)
+      if (commonFromDeviceExt((PDEVICE_EXTENSION)HwDeviceExtension)->bHGSMI)
       {
           LogRel(("VBoxVideo: using HGSMI\n"));
@@ -2082,5 +2082,5 @@
                 }
                 /* clear the IRQ */
-                HGSMIClearIrq (hgsmiFromDeviceExt(PrimaryExtension));
+                HGSMIClearIrq (commonFromDeviceExt(PrimaryExtension));
                 return TRUE;
             }
@@ -2676,5 +2676,5 @@
             }
 
-            if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
+            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
             {
                 RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
@@ -2693,5 +2693,5 @@
             pInfo->u32MinVBVABufferSize = VBVA_MIN_BUFFER_SIZE;
 
-            pInfo->IOPortGuestCommand = hgsmiFromDeviceExt(pDevExt)->IOPortGuest;
+            pInfo->IOPortGuestCommand = commonFromDeviceExt(pDevExt)->IOPortGuest;
 
             RequestPacket->StatusBlock->Information = sizeof(QUERYHGSMIRESULT);
@@ -2712,5 +2712,5 @@
             }
 
-            if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
+            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
             {
                 RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
@@ -2740,5 +2740,5 @@
             }
 
-            if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
+            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
             {
                 RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
@@ -2766,5 +2766,5 @@
             }
 
-            if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
+            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
             {
                 RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
@@ -2787,5 +2787,5 @@
         {
             /* TODO: implement */
-            if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
+            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
             {
                 RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
@@ -2805,5 +2805,5 @@
             }
 
-            if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
+            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
             {
                 RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h	(revision 32988)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h	(revision 32989)
@@ -201,5 +201,5 @@
 
 #ifdef VBOX_WITH_HGSMI
-typedef struct HGSMI_GUEST_INFO
+typedef struct VBOXVIDEO_COMMON
 {
     BOOLEAN bHGSMI;                     /* Whether HGSMI is enabled. */
@@ -216,5 +216,5 @@
     /* The IO Port Number for guest commands. */
     RTIOPORT IOPortGuest;
-} HGSMI_GUEST_INFO, *PHGSMI_GUEST_INFO;
+} VBOXVIDEO_COMMON, *PVBOXVIDEO_COMMON;
 #endif
 
@@ -290,5 +290,5 @@
 
 #ifdef VBOX_WITH_HGSMI
-           HGSMI_GUEST_INFO hgsmiInfo;
+           VBOXVIDEO_COMMON hgsmiInfo;
 # ifndef VBOX_WITH_WDDM
            /* Video Port API dynamically picked up at runtime for binary backwards compatibility with older NT versions */
@@ -344,5 +344,5 @@
 } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
 
-static inline PHGSMI_GUEST_INFO hgsmiFromDeviceExt(PDEVICE_EXTENSION pExt)
+static inline PVBOXVIDEO_COMMON commonFromDeviceExt(PDEVICE_EXTENSION pExt)
 {
 #ifndef VBOX_WITH_WDDM
@@ -798,10 +798,10 @@
 #endif
 
-void* vboxHGSMIBufferAlloc(PDEVICE_EXTENSION PrimaryExtension,
+void* vboxHGSMIBufferAlloc(PVBOXVIDEO_COMMON pCommon,
                          HGSMISIZE cbData,
                          uint8_t u8Ch,
                          uint16_t u16Op);
-void vboxHGSMIBufferFree (PDEVICE_EXTENSION PrimaryExtension, void *pvBuffer);
-int vboxHGSMIBufferSubmit (PDEVICE_EXTENSION PrimaryExtension, void *pvBuffer);
+void vboxHGSMIBufferFree (PVBOXVIDEO_COMMON pCommon, void *pvBuffer);
+int vboxHGSMIBufferSubmit (PVBOXVIDEO_COMMON pCommon, void *pvBuffer);
 
 BOOLEAN FASTCALL VBoxVideoSetCurrentModePerform(PDEVICE_EXTENSION DeviceExtension,
@@ -868,22 +868,22 @@
  * Host and Guest port IO helpers.
  */
-DECLINLINE(void) VBoxHGSMIHostWrite(PHGSMI_GUEST_INFO pInfo, ULONG data)
-{
-    VBoxVideoCmnPortWriteUlong((PULONG)pInfo->IOPortHost, data);
-}
-
-DECLINLINE(ULONG) VBoxHGSMIHostRead(PHGSMI_GUEST_INFO pInfo)
-{
-    return VBoxVideoCmnPortReadUlong((PULONG)pInfo->IOPortHost);
-}
-
-DECLINLINE(void) VBoxHGSMIGuestWrite(PHGSMI_GUEST_INFO pInfo, ULONG data)
-{
-    VBoxVideoCmnPortWriteUlong((PULONG)pInfo->IOPortGuest, data);
-}
-
-DECLINLINE(ULONG) VBoxHGSMIGuestRead(PHGSMI_GUEST_INFO pInfo)
-{
-    return VBoxVideoCmnPortReadUlong((PULONG)pInfo->IOPortGuest);
+DECLINLINE(void) VBoxHGSMIHostWrite(PVBOXVIDEO_COMMON pCommon, ULONG data)
+{
+    VBoxVideoCmnPortWriteUlong((PULONG)pCommon->IOPortHost, data);
+}
+
+DECLINLINE(ULONG) VBoxHGSMIHostRead(PVBOXVIDEO_COMMON pCommon)
+{
+    return VBoxVideoCmnPortReadUlong((PULONG)pCommon->IOPortHost);
+}
+
+DECLINLINE(void) VBoxHGSMIGuestWrite(PVBOXVIDEO_COMMON pCommon, ULONG data)
+{
+    VBoxVideoCmnPortWriteUlong((PULONG)pCommon->IOPortGuest, data);
+}
+
+DECLINLINE(ULONG) VBoxHGSMIGuestRead(PVBOXVIDEO_COMMON pCommon)
+{
+    return VBoxVideoCmnPortReadUlong((PULONG)pCommon->IOPortGuest);
 }
 
@@ -916,5 +916,5 @@
     );
 
-void HGSMIClearIrq (PHGSMI_GUEST_INFO pInfo);
+void HGSMIClearIrq (PVBOXVIDEO_COMMON pCommon);
 
 #endif /* VBOX_WITH_HGSMI */
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp	(revision 32988)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp	(revision 32989)
@@ -33,28 +33,28 @@
 #define MEM_TAG 'HVBV'
 
-void HGSMINotifyHostCmdComplete (PHGSMI_GUEST_INFO pInfo, HGSMIOFFSET offt)
-{
-    VBoxHGSMIHostWrite(pInfo, offt);
-}
-
-void HGSMIClearIrq (PHGSMI_GUEST_INFO pInfo)
-{
-    VBoxHGSMIHostWrite(pInfo, HGSMIOFFSET_VOID);
-}
-
-static void HGSMIHostCmdComplete (PHGSMI_GUEST_INFO pInfo, void * pvMem)
-{
-    HGSMIOFFSET offMem = HGSMIPointerToOffset (&pInfo->areaHostHeap, HGSMIBufferHeaderFromData (pvMem));
+void HGSMINotifyHostCmdComplete (PVBOXVIDEO_COMMON pCommon, HGSMIOFFSET offt)
+{
+    VBoxHGSMIHostWrite(pCommon, offt);
+}
+
+void HGSMIClearIrq (PVBOXVIDEO_COMMON pCommon)
+{
+    VBoxHGSMIHostWrite(pCommon, HGSMIOFFSET_VOID);
+}
+
+static void HGSMIHostCmdComplete (PVBOXVIDEO_COMMON pCommon, void * pvMem)
+{
+    HGSMIOFFSET offMem = HGSMIPointerToOffset (&pCommon->areaHostHeap, HGSMIBufferHeaderFromData (pvMem));
     Assert(offMem != HGSMIOFFSET_VOID);
     if(offMem != HGSMIOFFSET_VOID)
     {
-        HGSMINotifyHostCmdComplete (pInfo, offMem);
-    }
-}
-
-static void hgsmiHostCmdProcess(PDEVICE_EXTENSION PrimaryExtension, HGSMIOFFSET offBuffer)
-{
-    int rc = HGSMIBufferProcess (&hgsmiFromDeviceExt(PrimaryExtension)->areaHostHeap,
-                                &hgsmiFromDeviceExt(PrimaryExtension)->channels,
+        HGSMINotifyHostCmdComplete (pCommon, offMem);
+    }
+}
+
+static void hgsmiHostCmdProcess(PVBOXVIDEO_COMMON pCommon, HGSMIOFFSET offBuffer)
+{
+    int rc = HGSMIBufferProcess (&pCommon->areaHostHeap,
+                                &pCommon->channels,
                                 offBuffer);
     Assert(!RT_FAILURE(rc));
@@ -63,21 +63,21 @@
         /* failure means the command was not submitted to the handler for some reason
          * it's our responsibility to notify its completion in this case */
-        HGSMINotifyHostCmdComplete(hgsmiFromDeviceExt(PrimaryExtension), offBuffer);
+        HGSMINotifyHostCmdComplete(pCommon, offBuffer);
     }
     /* if the cmd succeeded it's responsibility of the callback to complete it */
 }
 
-static HGSMIOFFSET hgsmiGetHostBuffer (PDEVICE_EXTENSION PrimaryExtension)
-{
-    return VBoxHGSMIHostRead(hgsmiFromDeviceExt(PrimaryExtension));
-}
-
-static void hgsmiHostCommandQueryProcess (PDEVICE_EXTENSION PrimaryExtension)
-{
-    HGSMIOFFSET offset = hgsmiGetHostBuffer (PrimaryExtension);
+static HGSMIOFFSET hgsmiGetHostBuffer (PVBOXVIDEO_COMMON pCommon)
+{
+    return VBoxHGSMIHostRead(pCommon);
+}
+
+static void hgsmiHostCommandQueryProcess (PVBOXVIDEO_COMMON pCommon)
+{
+    HGSMIOFFSET offset = hgsmiGetHostBuffer (pCommon);
     Assert(offset != HGSMIOFFSET_VOID);
     if(offset != HGSMIOFFSET_VOID)
     {
-        hgsmiHostCmdProcess(PrimaryExtension, offset);
+        hgsmiHostCmdProcess(pCommon, offset);
     }
 }
@@ -159,5 +159,5 @@
         bProcessing = true;
 
-        hgsmiHostCommandQueryProcess (PrimaryExtension);
+        hgsmiHostCommandQueryProcess (commonFromDeviceExt(PrimaryExtension));
     } while(true/*!PrimaryExtension->u.primary.bPollingStop*/);
 }
@@ -182,5 +182,5 @@
 typedef FNHGSMICALLFINALIZE *PFNHGSMICALLFINALIZE;
 
-void* vboxHGSMIBufferAlloc(PDEVICE_EXTENSION PrimaryExtension,
+void* vboxHGSMIBufferAlloc(PVBOXVIDEO_COMMON pCommon,
                          HGSMISIZE cbData,
                          uint8_t u8Ch,
@@ -190,19 +190,19 @@
     /* @todo: add synchronization */
 #endif
-    return HGSMIHeapAlloc (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, cbData, u8Ch, u16Op);
-}
-
-void vboxHGSMIBufferFree (PDEVICE_EXTENSION PrimaryExtension, void *pvBuffer)
+    return HGSMIHeapAlloc (&pCommon->hgsmiAdapterHeap, cbData, u8Ch, u16Op);
+}
+
+void vboxHGSMIBufferFree (PVBOXVIDEO_COMMON pCommon, void *pvBuffer)
 {
 #ifdef VBOX_WITH_WDDM
     /* @todo: add synchronization */
 #endif
-    HGSMIHeapFree (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, pvBuffer);
-}
-
-int vboxHGSMIBufferSubmit (PDEVICE_EXTENSION PrimaryExtension, void *pvBuffer)
+    HGSMIHeapFree (&pCommon->hgsmiAdapterHeap, pvBuffer);
+}
+
+int vboxHGSMIBufferSubmit (PVBOXVIDEO_COMMON pCommon, void *pvBuffer)
 {
     /* Initialize the buffer and get the offset for port IO. */
-    HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, pvBuffer);
+    HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&pCommon->hgsmiAdapterHeap, pvBuffer);
 
     Assert(offBuffer != HGSMIOFFSET_VOID);
@@ -210,5 +210,5 @@
     {
         /* Submit the buffer to the host. */
-        VBoxHGSMIGuestWrite(hgsmiFromDeviceExt(PrimaryExtension), offBuffer);
+        VBoxHGSMIGuestWrite(pCommon, offBuffer);
         return VINF_SUCCESS;
     }
@@ -236,5 +236,5 @@
 #endif
 
-    void *p = HGSMIHeapAlloc (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, cbData, u8Ch, u16Op);
+    void *p = HGSMIHeapAlloc (&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, cbData, u8Ch, u16Op);
 
     if (!p)
@@ -253,9 +253,9 @@
         {
             /* Initialize the buffer and get the offset for port IO. */
-            HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap,
+            HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap,
                                                            p);
 
             /* Submit the buffer to the host. */
-            VBoxHGSMIGuestWrite(hgsmiFromDeviceExt(PrimaryExtension), offBuffer);
+            VBoxHGSMIGuestWrite(commonFromDeviceExt(PrimaryExtension), offBuffer);
 
             if (pfnFinalize)
@@ -271,5 +271,5 @@
 
         /* Free the IO buffer. */
-        HGSMIHeapFree (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, p);
+        HGSMIHeapFree (&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, p);
     }
 
@@ -743,14 +743,14 @@
     PrimaryExtension->u.primary.pHostFlags               = NULL;
     PrimaryExtension->u.primary.ulMaxFrameBufferSize     = 0;
-    hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI         = VBoxHGSMIIsSupported (PrimaryExtension);
-    VBoxVideoCmnMemZero(&hgsmiFromDeviceExt(PrimaryExtension)->areaHostHeap, sizeof(HGSMIAREA));
+    commonFromDeviceExt(PrimaryExtension)->bHGSMI         = VBoxHGSMIIsSupported (PrimaryExtension);
+    VBoxVideoCmnMemZero(&commonFromDeviceExt(PrimaryExtension)->areaHostHeap, sizeof(HGSMIAREA));
     VBoxVideoCmnMemZero(&PrimaryExtension->areaDisplay, sizeof(HGSMIAREA));
 
-    if (hgsmiFromDeviceExt(PrimaryExtension)->IOPortGuest == 0)
-    {
-        hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = false;
-    }
-
-    if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
+    if (commonFromDeviceExt(PrimaryExtension)->IOPortGuest == 0)
+    {
+        commonFromDeviceExt(PrimaryExtension)->bHGSMI = false;
+    }
+
+    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
     {
         /* Map the adapter information. It will be needed for HGSMI IO. */
@@ -765,10 +765,10 @@
                      rc));
 
-            hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
+            commonFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
         }
         else
         {
             /* Setup a HGSMI heap within the adapter information area. */
-            rc = HGSMIHeapSetup (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap,
+            rc = HGSMIHeapSetup (&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap,
                                  PrimaryExtension->u.primary.pvAdapterInformation,
                                  VBVA_ADAPTER_INFORMATION_SIZE - sizeof(HGSMIHOSTFLAGS),
@@ -781,5 +781,5 @@
                          rc));
 
-                hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
+                commonFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
             }
             else
@@ -792,5 +792,5 @@
 
     /* Setup the host heap and the adapter memory. */
-    if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
+    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
     {
         /* The miniport heap is used for the host buffers. */
@@ -836,5 +836,5 @@
                 PrimaryExtension->u.primary.pvMiniportHeap = NULL;
                 PrimaryExtension->u.primary.cbMiniportHeap = 0;
-                hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
+                commonFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
             }
             else
@@ -845,5 +845,5 @@
 
                 /* Init the host hap area. Buffers from the host will be placed there. */
-                HGSMIAreaInitialize (&hgsmiFromDeviceExt(PrimaryExtension)->areaHostHeap,
+                HGSMIAreaInitialize (&commonFromDeviceExt(PrimaryExtension)->areaHostHeap,
                                      PrimaryExtension->u.primary.pvMiniportHeap,
                                      PrimaryExtension->u.primary.cbMiniportHeap,
@@ -860,5 +860,5 @@
 
     /* Check whether the guest supports multimonitors. */
-    if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
+    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
     {
 #ifndef VBOX_WITH_WDDM
@@ -939,5 +939,5 @@
 #endif
 
-    if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
+    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
     {
         /* Setup the information for the host. */
@@ -946,10 +946,10 @@
         if (RT_FAILURE (rc))
         {
-            hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
+            commonFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
         }
     }
 
 #ifdef VBOX_WITH_WDDM
-    if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
+    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
     {
         ULONG ulAvailable = PrimaryExtension->u.primary.cbVRAM
@@ -1040,9 +1040,9 @@
 
         if (RT_FAILURE(rc))
-            hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
-    }
-#endif
-
-    if (!hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
+            commonFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
+    }
+#endif
+
+    if (!commonFromDeviceExt(PrimaryExtension)->bHGSMI)
     {
         /* Unmap the memory if VBoxVideo is not supported. */
@@ -1050,8 +1050,8 @@
         VBoxUnmapAdapterInformation (PrimaryExtension);
 
-        HGSMIHeapDestroy (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap);
-    }
-
-    if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
+        HGSMIHeapDestroy (&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap);
+    }
+
+    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
     {
         VBoxVideoCmnSpinLockCreate(PrimaryExtension, &PrimaryExtension->u.primary.pSynchLock);
@@ -1099,5 +1099,5 @@
 */
             {
-                HGSMIHeapDestroy(&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap);
+                HGSMIHeapDestroy(&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap);
 
                 /* Map the adapter information. It will be needed for HGSMI IO. */
@@ -1353,5 +1353,5 @@
 {
     PDEVICE_EXTENSION PrimaryExtension = ((PDEVICE_EXTENSION)hHGSMI)->pPrimary;
-    HGSMIHostCmdComplete (hgsmiFromDeviceExt(PrimaryExtension), pCmd);
+    HGSMIHostCmdComplete (commonFromDeviceExt(PrimaryExtension), pCmd);
 }
 
@@ -1369,5 +1369,5 @@
     VBoxVideoHGSMIDpc(PrimaryExtension, NULL);
 
-    HGSMICHANNEL * pChannel = HGSMIChannelFindById (&hgsmiFromDeviceExt(PrimaryExtension)->channels, u8Channel);
+    HGSMICHANNEL * pChannel = HGSMIChannelFindById (&commonFromDeviceExt(PrimaryExtension)->channels, u8Channel);
     if(pChannel)
     {
@@ -1467,5 +1467,5 @@
                             VBVAHOSTCMD * pNext = pCur->u.pNext;
                             pCur->u.pNext = NULL;
-                            HGSMIHostCmdComplete(hgsmiFromDeviceExt(pCallbacks->PrimaryExtension), pCur);
+                            HGSMIHostCmdComplete(commonFromDeviceExt(pCallbacks->PrimaryExtension), pCur);
                             pCur = pNext;
                             Assert(!pCur);
@@ -1536,5 +1536,5 @@
     }
     /* no handlers were found, need to complete the command here */
-    HGSMIHostCmdComplete(hgsmiFromDeviceExt(pCallbacks->PrimaryExtension), pvBuffer);
+    HGSMIHostCmdComplete(commonFromDeviceExt(pCallbacks->PrimaryExtension), pvBuffer);
     return VINF_SUCCESS;
 }
@@ -1547,5 +1547,5 @@
 {
     VBVA_CHANNELCONTEXTS * pContexts;
-    HGSMICHANNEL * pChannel = HGSMIChannelFindById (&hgsmiFromDeviceExt(PrimaryExtension)->channels, u8Channel);
+    HGSMICHANNEL * pChannel = HGSMIChannelFindById (&commonFromDeviceExt(PrimaryExtension)->channels, u8Channel);
     if(!pChannel)
     {
@@ -1584,5 +1584,5 @@
             if(!pChannel)
             {
-                rc = HGSMIChannelRegister (&hgsmiFromDeviceExt(PrimaryExtension)->channels,
+                rc = HGSMIChannelRegister (&commonFromDeviceExt(PrimaryExtension)->channels,
                                            u8Channel,
                                            "VGA Miniport HGSMI channel",
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVbva.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVbva.cpp	(revision 32988)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVbva.cpp	(revision 32989)
@@ -22,5 +22,5 @@
 {
     int rc = VERR_NO_MEMORY;
-    void *p = vboxHGSMIBufferAlloc (pDevExt,
+    void *p = vboxHGSMIBufferAlloc (commonFromDeviceExt(pDevExt),
                                   sizeof (VBVAENABLE_EX),
                                   HGSMI_CH_VBVA,
@@ -43,5 +43,5 @@
         pEnable->i32Result = VERR_NOT_SUPPORTED;
 
-        vboxHGSMIBufferSubmit (pDevExt, p);
+        vboxHGSMIBufferSubmit (commonFromDeviceExt(pDevExt), p);
 
         if (bEnable)
@@ -53,5 +53,5 @@
             rc = VINF_SUCCESS;
 
-        vboxHGSMIBufferFree (pDevExt, p);
+        vboxHGSMIBufferFree (commonFromDeviceExt(pDevExt), p);
     }
     return rc;
@@ -151,5 +151,5 @@
 {
     /* Issue the flush command. */
-    void *p = vboxHGSMIBufferAlloc (pDevExt,
+    void *p = vboxHGSMIBufferAlloc (commonFromDeviceExt(pDevExt),
                               sizeof (VBVAFLUSH),
                               HGSMI_CH_VBVA,
@@ -166,7 +166,7 @@
         pFlush->u32Reserved = 0;
 
-        vboxHGSMIBufferSubmit (pDevExt, p);
-
-        vboxHGSMIBufferFree (pDevExt, p);
+        vboxHGSMIBufferSubmit (commonFromDeviceExt(pDevExt), p);
+
+        vboxHGSMIBufferFree (commonFromDeviceExt(pDevExt), p);
     }
 
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.cpp	(revision 32988)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.cpp	(revision 32989)
@@ -1002,5 +1002,5 @@
 static int vboxWddmVdmaSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, HGSMIOFFSET offDr)
 {
-    VBoxHGSMIGuestWrite(hgsmiFromDeviceExt(pDevExt), offDr);
+    VBoxHGSMIGuestWrite(commonFromDeviceExt(pDevExt), offDr);
     return VINF_SUCCESS;
 }
@@ -1012,5 +1012,5 @@
     int rc = VINF_SUCCESS;
 
-    PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
+    PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
     if (pCmd)
     {
@@ -1019,5 +1019,5 @@
         pCmd->i32Result = VERR_NOT_SUPPORTED;
 
-        const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
+        const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
         Assert(pHdr);
         if (pHdr)
@@ -1025,5 +1025,5 @@
             do
             {
-                HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
+                HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
                 Assert(offCmd != HGSMIOFFSET_VOID);
                 if (offCmd != HGSMIOFFSET_VOID)
@@ -1033,5 +1033,5 @@
                     if (RT_SUCCESS(rc))
                     {
-                        rc = VBoxSHGSMICommandDoneSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
+                        rc = VBoxSHGSMICommandDoneSynch(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
                         AssertRC(rc);
                         if (RT_SUCCESS(rc))
@@ -1046,9 +1046,9 @@
                     rc = VERR_INVALID_PARAMETER;
                 /* fail to submit, cancel it */
-                VBoxSHGSMICommandCancelSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
+                VBoxSHGSMICommandCancelSynch(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
             } while (0);
         }
 
-        VBoxSHGSMICommandFree (&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
+        VBoxSHGSMICommandFree (&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
     }
     else
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp	(revision 32988)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp	(revision 32989)
@@ -45,5 +45,5 @@
     if(!cRefs)
     {
-        vboxHGSMIBufferFree(pDevExt, pCmd);
+        vboxHGSMIBufferFree(commonFromDeviceExt(pDevExt), pCmd);
     }
 }
@@ -61,5 +61,5 @@
     vbvaVhwaCommandRetain(pDevExt, pCmd);
 
-    vboxHGSMIBufferSubmit(pDevExt, pCmd);
+    vboxHGSMIBufferSubmit(commonFromDeviceExt(pDevExt), pCmd);
 
     if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH)
@@ -100,5 +100,5 @@
                               VBVA_VHWA_CMD);
 #else
-    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)vboxHGSMIBufferAlloc(pDevExt,
+    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)vboxHGSMIBufferAlloc(commonFromDeviceExt(pDevExt),
                               cbCmd + VBOXVHWACMD_HEADSIZE(),
                               HGSMI_CH_VBVA,
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp	(revision 32988)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp	(revision 32989)
@@ -107,5 +107,5 @@
 NTSTATUS vboxWddmGhDisplayPostInfoScreenBySDesc (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SURFACE_DESC pDesc, POINT * pVScreenPos, uint16_t fFlags)
 {
-    void *p = vboxHGSMIBufferAlloc (pDevExt,
+    void *p = vboxHGSMIBufferAlloc (commonFromDeviceExt(pDevExt),
                                       sizeof (VBVAINFOSCREEN),
                                       HGSMI_CH_VBVA,
@@ -126,7 +126,7 @@
         pScreen->u16Flags        = fFlags;
 
-        vboxHGSMIBufferSubmit (pDevExt, p);
-
-        vboxHGSMIBufferFree (pDevExt, p);
+        vboxHGSMIBufferSubmit (commonFromDeviceExt(pDevExt), p);
+
+        vboxHGSMIBufferFree (commonFromDeviceExt(pDevExt), p);
     }
 
@@ -150,5 +150,5 @@
 
     /* Issue the screen info command. */
-    void *p = vboxHGSMIBufferAlloc (pDevExt,
+    void *p = vboxHGSMIBufferAlloc (commonFromDeviceExt(pDevExt),
                                       sizeof (VBVAINFOVIEW),
                                       HGSMI_CH_VBVA,
@@ -165,7 +165,7 @@
         pView->u32MaxScreenSize = pView->u32ViewSize;
 
-        vboxHGSMIBufferSubmit (pDevExt, p);
-
-        vboxHGSMIBufferFree (pDevExt, p);
+        vboxHGSMIBufferSubmit (commonFromDeviceExt(pDevExt), p);
+
+        vboxHGSMIBufferFree (commonFromDeviceExt(pDevExt), p);
     }
 
@@ -268,6 +268,6 @@
         return &pDevExt->u.primary.Vdma.CmdHeap;
 #endif
-    if (HGSMIAreaContainsOffset(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap.area, offCmd))
-        return &hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap;
+    if (HGSMIAreaContainsOffset(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap.area, offCmd))
+        return &commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap;
     return NULL;
 }
@@ -288,5 +288,5 @@
         return VBOXWDDM_HGSMICMD_TYPE_DMACMD;
 #endif
-    if (HGSMIAreaContainsOffset(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap.area, offCmd))
+    if (HGSMIAreaContainsOffset(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap.area, offCmd))
         return VBOXWDDM_HGSMICMD_TYPE_CTL;
     return VBOXWDDM_HGSMICMD_TYPE_UNDEFINED;
@@ -421,6 +421,6 @@
        if (VBoxHGSMIIsSupported (pContext))
        {
-           hgsmiFromDeviceExt(pContext)->IOPortHost = (RTIOPORT)VGA_PORT_HGSMI_HOST;
-           hgsmiFromDeviceExt(pContext)->IOPortGuest = (RTIOPORT)VGA_PORT_HGSMI_GUEST;
+           commonFromDeviceExt(pContext)->IOPortHost = (RTIOPORT)VGA_PORT_HGSMI_HOST;
+           commonFromDeviceExt(pContext)->IOPortGuest = (RTIOPORT)VGA_PORT_HGSMI_GUEST;
 
            PCM_RESOURCE_LIST pRcList = pDeviceInfo->TranslatedResourceList;
@@ -580,5 +580,5 @@
                  */
                 VBoxSetupDisplaysHGSMI(pContext, AdapterMemorySize);
-                if (hgsmiFromDeviceExt(pContext)->bHGSMI)
+                if (commonFromDeviceExt(pContext)->bHGSMI)
                 {
                     drprintf(("VBoxVideoWddm: using HGSMI\n"));
@@ -794,5 +794,5 @@
             {
                 /* read the command offset */
-                HGSMIOFFSET offCmd = VBoxHGSMIGuestRead(hgsmiFromDeviceExt(pDevExt));
+                HGSMIOFFSET offCmd = VBoxHGSMIGuestRead(commonFromDeviceExt(pDevExt));
                 Assert(offCmd != HGSMIOFFSET_VOID);
                 if (offCmd != HGSMIOFFSET_VOID)
@@ -811,5 +811,5 @@
                         case VBOXWDDM_HGSMICMD_TYPE_CTL:
                             pList = &CtlList;
-                            pHeap = &hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap;
+                            pHeap = &commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap;
                             break;
                         default:
@@ -888,5 +888,5 @@
         if (bOur)
         {
-            HGSMIClearIrq (hgsmiFromDeviceExt(pDevExt));
+            HGSMIClearIrq (commonFromDeviceExt(pDevExt));
 #ifdef DEBUG_misha
             /* this is not entirely correct since host may concurrently complete some commands and raise a new IRQ while we are here,
@@ -974,5 +974,5 @@
     if (!vboxSHGSMIListIsEmpty(&context.data.CtlList))
     {
-        int rc = VBoxSHGSMICommandPostprocessCompletion (&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, &context.data.CtlList);
+        int rc = VBoxSHGSMICommandPostprocessCompletion (&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, &context.data.CtlList);
         AssertRC(rc);
     }