VirtualBox

Changeset 32989 in vbox for trunk/src/VBox/Additions


Ignore:
Timestamp:
Oct 7, 2010 3:47:31 PM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
66499
Message:

Additions/WINNT/Graphics: more refactoring

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Miniport
Files:
7 edited

Legend:

Unmodified
Added
Removed

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

    r32915 r32989  
    20252025      VBoxSetupDisplaysHGSMI((PDEVICE_EXTENSION)HwDeviceExtension, ConfigInfo, AdapterMemorySize);
    20262026
    2027       if (hgsmiFromDeviceExt((PDEVICE_EXTENSION)HwDeviceExtension)->bHGSMI)
     2027      if (commonFromDeviceExt((PDEVICE_EXTENSION)HwDeviceExtension)->bHGSMI)
    20282028      {
    20292029          LogRel(("VBoxVideo: using HGSMI\n"));
    … …  
    20822082                }
    20832083                /* clear the IRQ */
    2084                 HGSMIClearIrq (hgsmiFromDeviceExt(PrimaryExtension));
     2084                HGSMIClearIrq (commonFromDeviceExt(PrimaryExtension));
    20852085                return TRUE;
    20862086            }
    … …  
    26762676            }
    26772677
    2678             if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
     2678            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
    26792679            {
    26802680                RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
    … …  
    26932693            pInfo->u32MinVBVABufferSize = VBVA_MIN_BUFFER_SIZE;
    26942694
    2695             pInfo->IOPortGuestCommand = hgsmiFromDeviceExt(pDevExt)->IOPortGuest;
     2695            pInfo->IOPortGuestCommand = commonFromDeviceExt(pDevExt)->IOPortGuest;
    26962696
    26972697            RequestPacket->StatusBlock->Information = sizeof(QUERYHGSMIRESULT);
    … …  
    27122712            }
    27132713
    2714             if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
     2714            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
    27152715            {
    27162716                RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
    … …  
    27402740            }
    27412741
    2742             if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
     2742            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
    27432743            {
    27442744                RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
    … …  
    27662766            }
    27672767
    2768             if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
     2768            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
    27692769            {
    27702770                RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
    … …  
    27872787        {
    27882788            /* TODO: implement */
    2789             if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
     2789            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
    27902790            {
    27912791                RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
    … …  
    28052805            }
    28062806
    2807             if (!hgsmiFromDeviceExt(pDevExt)->bHGSMI)
     2807            if (!commonFromDeviceExt(pDevExt)->bHGSMI)
    28082808            {
    28092809                RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;

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

    r32915 r32989  
    201201
    202202#ifdef VBOX_WITH_HGSMI
    203 typedef struct HGSMI_GUEST_INFO
     203typedef struct VBOXVIDEO_COMMON
    204204{
    205205    BOOLEAN bHGSMI;                     /* Whether HGSMI is enabled. */
    … …  
    216216    /* The IO Port Number for guest commands. */
    217217    RTIOPORT IOPortGuest;
    218 } HGSMI_GUEST_INFO, *PHGSMI_GUEST_INFO;
     218} VBOXVIDEO_COMMON, *PVBOXVIDEO_COMMON;
    219219#endif
    220220
    … …  
    290290
    291291#ifdef VBOX_WITH_HGSMI
    292            HGSMI_GUEST_INFO hgsmiInfo;
     292           VBOXVIDEO_COMMON hgsmiInfo;
    293293# ifndef VBOX_WITH_WDDM
    294294           /* Video Port API dynamically picked up at runtime for binary backwards compatibility with older NT versions */
    … …  
    344344} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
    345345
    346 static inline PHGSMI_GUEST_INFO hgsmiFromDeviceExt(PDEVICE_EXTENSION pExt)
     346static inline PVBOXVIDEO_COMMON commonFromDeviceExt(PDEVICE_EXTENSION pExt)
    347347{
    348348#ifndef VBOX_WITH_WDDM
    … …  
    798798#endif
    799799
    800 void* vboxHGSMIBufferAlloc(PDEVICE_EXTENSION PrimaryExtension,
     800void* vboxHGSMIBufferAlloc(PVBOXVIDEO_COMMON pCommon,
    801801                         HGSMISIZE cbData,
    802802                         uint8_t u8Ch,
    803803                         uint16_t u16Op);
    804 void vboxHGSMIBufferFree (PDEVICE_EXTENSION PrimaryExtension, void *pvBuffer);
    805 int vboxHGSMIBufferSubmit (PDEVICE_EXTENSION PrimaryExtension, void *pvBuffer);
     804void vboxHGSMIBufferFree (PVBOXVIDEO_COMMON pCommon, void *pvBuffer);
     805int vboxHGSMIBufferSubmit (PVBOXVIDEO_COMMON pCommon, void *pvBuffer);
    806806
    807807BOOLEAN FASTCALL VBoxVideoSetCurrentModePerform(PDEVICE_EXTENSION DeviceExtension,
    … …  
    868868 * Host and Guest port IO helpers.
    869869 */
    870 DECLINLINE(void) VBoxHGSMIHostWrite(PHGSMI_GUEST_INFO pInfo, ULONG data)
    871 {
    872     VBoxVideoCmnPortWriteUlong((PULONG)pInfo->IOPortHost, data);
    873 }
    874 
    875 DECLINLINE(ULONG) VBoxHGSMIHostRead(PHGSMI_GUEST_INFO pInfo)
    876 {
    877     return VBoxVideoCmnPortReadUlong((PULONG)pInfo->IOPortHost);
    878 }
    879 
    880 DECLINLINE(void) VBoxHGSMIGuestWrite(PHGSMI_GUEST_INFO pInfo, ULONG data)
    881 {
    882     VBoxVideoCmnPortWriteUlong((PULONG)pInfo->IOPortGuest, data);
    883 }
    884 
    885 DECLINLINE(ULONG) VBoxHGSMIGuestRead(PHGSMI_GUEST_INFO pInfo)
    886 {
    887     return VBoxVideoCmnPortReadUlong((PULONG)pInfo->IOPortGuest);
     870DECLINLINE(void) VBoxHGSMIHostWrite(PVBOXVIDEO_COMMON pCommon, ULONG data)
     871{
     872    VBoxVideoCmnPortWriteUlong((PULONG)pCommon->IOPortHost, data);
     873}
     874
     875DECLINLINE(ULONG) VBoxHGSMIHostRead(PVBOXVIDEO_COMMON pCommon)
     876{
     877    return VBoxVideoCmnPortReadUlong((PULONG)pCommon->IOPortHost);
     878}
     879
     880DECLINLINE(void) VBoxHGSMIGuestWrite(PVBOXVIDEO_COMMON pCommon, ULONG data)
     881{
     882    VBoxVideoCmnPortWriteUlong((PULONG)pCommon->IOPortGuest, data);
     883}
     884
     885DECLINLINE(ULONG) VBoxHGSMIGuestRead(PVBOXVIDEO_COMMON pCommon)
     886{
     887    return VBoxVideoCmnPortReadUlong((PULONG)pCommon->IOPortGuest);
    888888}
    889889
    … …  
    916916    );
    917917
    918 void HGSMIClearIrq (PHGSMI_GUEST_INFO pInfo);
     918void HGSMIClearIrq (PVBOXVIDEO_COMMON pCommon);
    919919
    920920#endif /* VBOX_WITH_HGSMI */

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

    r32915 r32989  
    3333#define MEM_TAG 'HVBV'
    3434
    35 void HGSMINotifyHostCmdComplete (PHGSMI_GUEST_INFO pInfo, HGSMIOFFSET offt)
    36 {
    37     VBoxHGSMIHostWrite(pInfo, offt);
    38 }
    39 
    40 void HGSMIClearIrq (PHGSMI_GUEST_INFO pInfo)
    41 {
    42     VBoxHGSMIHostWrite(pInfo, HGSMIOFFSET_VOID);
    43 }
    44 
    45 static void HGSMIHostCmdComplete (PHGSMI_GUEST_INFO pInfo, void * pvMem)
    46 {
    47     HGSMIOFFSET offMem = HGSMIPointerToOffset (&pInfo->areaHostHeap, HGSMIBufferHeaderFromData (pvMem));
     35void HGSMINotifyHostCmdComplete (PVBOXVIDEO_COMMON pCommon, HGSMIOFFSET offt)
     36{
     37    VBoxHGSMIHostWrite(pCommon, offt);
     38}
     39
     40void HGSMIClearIrq (PVBOXVIDEO_COMMON pCommon)
     41{
     42    VBoxHGSMIHostWrite(pCommon, HGSMIOFFSET_VOID);
     43}
     44
     45static void HGSMIHostCmdComplete (PVBOXVIDEO_COMMON pCommon, void * pvMem)
     46{
     47    HGSMIOFFSET offMem = HGSMIPointerToOffset (&pCommon->areaHostHeap, HGSMIBufferHeaderFromData (pvMem));
    4848    Assert(offMem != HGSMIOFFSET_VOID);
    4949    if(offMem != HGSMIOFFSET_VOID)
    5050    {
    51         HGSMINotifyHostCmdComplete (pInfo, offMem);
    52     }
    53 }
    54 
    55 static void hgsmiHostCmdProcess(PDEVICE_EXTENSION PrimaryExtension, HGSMIOFFSET offBuffer)
    56 {
    57     int rc = HGSMIBufferProcess (&hgsmiFromDeviceExt(PrimaryExtension)->areaHostHeap,
    58                                 &hgsmiFromDeviceExt(PrimaryExtension)->channels,
     51        HGSMINotifyHostCmdComplete (pCommon, offMem);
     52    }
     53}
     54
     55static void hgsmiHostCmdProcess(PVBOXVIDEO_COMMON pCommon, HGSMIOFFSET offBuffer)
     56{
     57    int rc = HGSMIBufferProcess (&pCommon->areaHostHeap,
     58                                &pCommon->channels,
    5959                                offBuffer);
    6060    Assert(!RT_FAILURE(rc));
    … …  
    6363        /* failure means the command was not submitted to the handler for some reason
    6464         * it's our responsibility to notify its completion in this case */
    65         HGSMINotifyHostCmdComplete(hgsmiFromDeviceExt(PrimaryExtension), offBuffer);
     65        HGSMINotifyHostCmdComplete(pCommon, offBuffer);
    6666    }
    6767    /* if the cmd succeeded it's responsibility of the callback to complete it */
    6868}
    6969
    70 static HGSMIOFFSET hgsmiGetHostBuffer (PDEVICE_EXTENSION PrimaryExtension)
    71 {
    72     return VBoxHGSMIHostRead(hgsmiFromDeviceExt(PrimaryExtension));
    73 }
    74 
    75 static void hgsmiHostCommandQueryProcess (PDEVICE_EXTENSION PrimaryExtension)
    76 {
    77     HGSMIOFFSET offset = hgsmiGetHostBuffer (PrimaryExtension);
     70static HGSMIOFFSET hgsmiGetHostBuffer (PVBOXVIDEO_COMMON pCommon)
     71{
     72    return VBoxHGSMIHostRead(pCommon);
     73}
     74
     75static void hgsmiHostCommandQueryProcess (PVBOXVIDEO_COMMON pCommon)
     76{
     77    HGSMIOFFSET offset = hgsmiGetHostBuffer (pCommon);
    7878    Assert(offset != HGSMIOFFSET_VOID);
    7979    if(offset != HGSMIOFFSET_VOID)
    8080    {
    81         hgsmiHostCmdProcess(PrimaryExtension, offset);
     81        hgsmiHostCmdProcess(pCommon, offset);
    8282    }
    8383}
    … …  
    159159        bProcessing = true;
    160160
    161         hgsmiHostCommandQueryProcess (PrimaryExtension);
     161        hgsmiHostCommandQueryProcess (commonFromDeviceExt(PrimaryExtension));
    162162    } while(true/*!PrimaryExtension->u.primary.bPollingStop*/);
    163163}
    … …  
    182182typedef FNHGSMICALLFINALIZE *PFNHGSMICALLFINALIZE;
    183183
    184 void* vboxHGSMIBufferAlloc(PDEVICE_EXTENSION PrimaryExtension,
     184void* vboxHGSMIBufferAlloc(PVBOXVIDEO_COMMON pCommon,
    185185                         HGSMISIZE cbData,
    186186                         uint8_t u8Ch,
    … …  
    190190    /* @todo: add synchronization */
    191191#endif
    192     return HGSMIHeapAlloc (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, cbData, u8Ch, u16Op);
    193 }
    194 
    195 void vboxHGSMIBufferFree (PDEVICE_EXTENSION PrimaryExtension, void *pvBuffer)
     192    return HGSMIHeapAlloc (&pCommon->hgsmiAdapterHeap, cbData, u8Ch, u16Op);
     193}
     194
     195void vboxHGSMIBufferFree (PVBOXVIDEO_COMMON pCommon, void *pvBuffer)
    196196{
    197197#ifdef VBOX_WITH_WDDM
    198198    /* @todo: add synchronization */
    199199#endif
    200     HGSMIHeapFree (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, pvBuffer);
    201 }
    202 
    203 int vboxHGSMIBufferSubmit (PDEVICE_EXTENSION PrimaryExtension, void *pvBuffer)
     200    HGSMIHeapFree (&pCommon->hgsmiAdapterHeap, pvBuffer);
     201}
     202
     203int vboxHGSMIBufferSubmit (PVBOXVIDEO_COMMON pCommon, void *pvBuffer)
    204204{
    205205    /* Initialize the buffer and get the offset for port IO. */
    206     HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, pvBuffer);
     206    HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&pCommon->hgsmiAdapterHeap, pvBuffer);
    207207
    208208    Assert(offBuffer != HGSMIOFFSET_VOID);
    … …  
    210210    {
    211211        /* Submit the buffer to the host. */
    212         VBoxHGSMIGuestWrite(hgsmiFromDeviceExt(PrimaryExtension), offBuffer);
     212        VBoxHGSMIGuestWrite(pCommon, offBuffer);
    213213        return VINF_SUCCESS;
    214214    }
    … …  
    236236#endif
    237237
    238     void *p = HGSMIHeapAlloc (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, cbData, u8Ch, u16Op);
     238    void *p = HGSMIHeapAlloc (&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, cbData, u8Ch, u16Op);
    239239
    240240    if (!p)
    … …  
    253253        {
    254254            /* Initialize the buffer and get the offset for port IO. */
    255             HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap,
     255            HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap,
    256256                                                           p);
    257257
    258258            /* Submit the buffer to the host. */
    259             VBoxHGSMIGuestWrite(hgsmiFromDeviceExt(PrimaryExtension), offBuffer);
     259            VBoxHGSMIGuestWrite(commonFromDeviceExt(PrimaryExtension), offBuffer);
    260260
    261261            if (pfnFinalize)
    … …  
    271271
    272272        /* Free the IO buffer. */
    273         HGSMIHeapFree (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, p);
     273        HGSMIHeapFree (&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap, p);
    274274    }
    275275
    … …  
    743743    PrimaryExtension->u.primary.pHostFlags               = NULL;
    744744    PrimaryExtension->u.primary.ulMaxFrameBufferSize     = 0;
    745     hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI         = VBoxHGSMIIsSupported (PrimaryExtension);
    746     VBoxVideoCmnMemZero(&hgsmiFromDeviceExt(PrimaryExtension)->areaHostHeap, sizeof(HGSMIAREA));
     745    commonFromDeviceExt(PrimaryExtension)->bHGSMI         = VBoxHGSMIIsSupported (PrimaryExtension);
     746    VBoxVideoCmnMemZero(&commonFromDeviceExt(PrimaryExtension)->areaHostHeap, sizeof(HGSMIAREA));
    747747    VBoxVideoCmnMemZero(&PrimaryExtension->areaDisplay, sizeof(HGSMIAREA));
    748748
    749     if (hgsmiFromDeviceExt(PrimaryExtension)->IOPortGuest == 0)
    750     {
    751         hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = false;
    752     }
    753 
    754     if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
     749    if (commonFromDeviceExt(PrimaryExtension)->IOPortGuest == 0)
     750    {
     751        commonFromDeviceExt(PrimaryExtension)->bHGSMI = false;
     752    }
     753
     754    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
    755755    {
    756756        /* Map the adapter information. It will be needed for HGSMI IO. */
    … …  
    765765                     rc));
    766766
    767             hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
     767            commonFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
    768768        }
    769769        else
    770770        {
    771771            /* Setup a HGSMI heap within the adapter information area. */
    772             rc = HGSMIHeapSetup (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap,
     772            rc = HGSMIHeapSetup (&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap,
    773773                                 PrimaryExtension->u.primary.pvAdapterInformation,
    774774                                 VBVA_ADAPTER_INFORMATION_SIZE - sizeof(HGSMIHOSTFLAGS),
    … …  
    781781                         rc));
    782782
    783                 hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
     783                commonFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
    784784            }
    785785            else
    … …  
    792792
    793793    /* Setup the host heap and the adapter memory. */
    794     if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
     794    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
    795795    {
    796796        /* The miniport heap is used for the host buffers. */
    … …  
    836836                PrimaryExtension->u.primary.pvMiniportHeap = NULL;
    837837                PrimaryExtension->u.primary.cbMiniportHeap = 0;
    838                 hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
     838                commonFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
    839839            }
    840840            else
    … …  
    845845
    846846                /* Init the host hap area. Buffers from the host will be placed there. */
    847                 HGSMIAreaInitialize (&hgsmiFromDeviceExt(PrimaryExtension)->areaHostHeap,
     847                HGSMIAreaInitialize (&commonFromDeviceExt(PrimaryExtension)->areaHostHeap,
    848848                                     PrimaryExtension->u.primary.pvMiniportHeap,
    849849                                     PrimaryExtension->u.primary.cbMiniportHeap,
    … …  
    860860
    861861    /* Check whether the guest supports multimonitors. */
    862     if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
     862    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
    863863    {
    864864#ifndef VBOX_WITH_WDDM
    … …  
    939939#endif
    940940
    941     if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
     941    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
    942942    {
    943943        /* Setup the information for the host. */
    … …  
    946946        if (RT_FAILURE (rc))
    947947        {
    948             hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
     948            commonFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
    949949        }
    950950    }
    951951
    952952#ifdef VBOX_WITH_WDDM
    953     if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
     953    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
    954954    {
    955955        ULONG ulAvailable = PrimaryExtension->u.primary.cbVRAM
    … …  
    10401040
    10411041        if (RT_FAILURE(rc))
    1042             hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
    1043     }
    1044 #endif
    1045 
    1046     if (!hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
     1042            commonFromDeviceExt(PrimaryExtension)->bHGSMI = FALSE;
     1043    }
     1044#endif
     1045
     1046    if (!commonFromDeviceExt(PrimaryExtension)->bHGSMI)
    10471047    {
    10481048        /* Unmap the memory if VBoxVideo is not supported. */
    … …  
    10501050        VBoxUnmapAdapterInformation (PrimaryExtension);
    10511051
    1052         HGSMIHeapDestroy (&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap);
    1053     }
    1054 
    1055     if (hgsmiFromDeviceExt(PrimaryExtension)->bHGSMI)
     1052        HGSMIHeapDestroy (&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap);
     1053    }
     1054
     1055    if (commonFromDeviceExt(PrimaryExtension)->bHGSMI)
    10561056    {
    10571057        VBoxVideoCmnSpinLockCreate(PrimaryExtension, &PrimaryExtension->u.primary.pSynchLock);
    … …  
    10991099*/
    11001100            {
    1101                 HGSMIHeapDestroy(&hgsmiFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap);
     1101                HGSMIHeapDestroy(&commonFromDeviceExt(PrimaryExtension)->hgsmiAdapterHeap);
    11021102
    11031103                /* Map the adapter information. It will be needed for HGSMI IO. */
    … …  
    13531353{
    13541354    PDEVICE_EXTENSION PrimaryExtension = ((PDEVICE_EXTENSION)hHGSMI)->pPrimary;
    1355     HGSMIHostCmdComplete (hgsmiFromDeviceExt(PrimaryExtension), pCmd);
     1355    HGSMIHostCmdComplete (commonFromDeviceExt(PrimaryExtension), pCmd);
    13561356}
    13571357
    … …  
    13691369    VBoxVideoHGSMIDpc(PrimaryExtension, NULL);
    13701370
    1371     HGSMICHANNEL * pChannel = HGSMIChannelFindById (&hgsmiFromDeviceExt(PrimaryExtension)->channels, u8Channel);
     1371    HGSMICHANNEL * pChannel = HGSMIChannelFindById (&commonFromDeviceExt(PrimaryExtension)->channels, u8Channel);
    13721372    if(pChannel)
    13731373    {
    … …  
    14671467                            VBVAHOSTCMD * pNext = pCur->u.pNext;
    14681468                            pCur->u.pNext = NULL;
    1469                             HGSMIHostCmdComplete(hgsmiFromDeviceExt(pCallbacks->PrimaryExtension), pCur);
     1469                            HGSMIHostCmdComplete(commonFromDeviceExt(pCallbacks->PrimaryExtension), pCur);
    14701470                            pCur = pNext;
    14711471                            Assert(!pCur);
    … …  
    15361536    }
    15371537    /* no handlers were found, need to complete the command here */
    1538     HGSMIHostCmdComplete(hgsmiFromDeviceExt(pCallbacks->PrimaryExtension), pvBuffer);
     1538    HGSMIHostCmdComplete(commonFromDeviceExt(pCallbacks->PrimaryExtension), pvBuffer);
    15391539    return VINF_SUCCESS;
    15401540}
    … …  
    15471547{
    15481548    VBVA_CHANNELCONTEXTS * pContexts;
    1549     HGSMICHANNEL * pChannel = HGSMIChannelFindById (&hgsmiFromDeviceExt(PrimaryExtension)->channels, u8Channel);
     1549    HGSMICHANNEL * pChannel = HGSMIChannelFindById (&commonFromDeviceExt(PrimaryExtension)->channels, u8Channel);
    15501550    if(!pChannel)
    15511551    {
    … …  
    15841584            if(!pChannel)
    15851585            {
    1586                 rc = HGSMIChannelRegister (&hgsmiFromDeviceExt(PrimaryExtension)->channels,
     1586                rc = HGSMIChannelRegister (&commonFromDeviceExt(PrimaryExtension)->channels,
    15871587                                           u8Channel,
    15881588                                           "VGA Miniport HGSMI channel",

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

    r31763 r32989  
    2222{
    2323    int rc = VERR_NO_MEMORY;
    24     void *p = vboxHGSMIBufferAlloc (pDevExt,
     24    void *p = vboxHGSMIBufferAlloc (commonFromDeviceExt(pDevExt),
    2525                                  sizeof (VBVAENABLE_EX),
    2626                                  HGSMI_CH_VBVA,
    … …  
    4343        pEnable->i32Result = VERR_NOT_SUPPORTED;
    4444
    45         vboxHGSMIBufferSubmit (pDevExt, p);
     45        vboxHGSMIBufferSubmit (commonFromDeviceExt(pDevExt), p);
    4646
    4747        if (bEnable)
    … …  
    5353            rc = VINF_SUCCESS;
    5454
    55         vboxHGSMIBufferFree (pDevExt, p);
     55        vboxHGSMIBufferFree (commonFromDeviceExt(pDevExt), p);
    5656    }
    5757    return rc;
    … …  
    151151{
    152152    /* Issue the flush command. */
    153     void *p = vboxHGSMIBufferAlloc (pDevExt,
     153    void *p = vboxHGSMIBufferAlloc (commonFromDeviceExt(pDevExt),
    154154                              sizeof (VBVAFLUSH),
    155155                              HGSMI_CH_VBVA,
    … …  
    166166        pFlush->u32Reserved = 0;
    167167
    168         vboxHGSMIBufferSubmit (pDevExt, p);
    169 
    170         vboxHGSMIBufferFree (pDevExt, p);
     168        vboxHGSMIBufferSubmit (commonFromDeviceExt(pDevExt), p);
     169
     170        vboxHGSMIBufferFree (commonFromDeviceExt(pDevExt), p);
    171171    }
    172172

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

    r32889 r32989  
    10021002static int vboxWddmVdmaSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, HGSMIOFFSET offDr)
    10031003{
    1004     VBoxHGSMIGuestWrite(hgsmiFromDeviceExt(pDevExt), offDr);
     1004    VBoxHGSMIGuestWrite(commonFromDeviceExt(pDevExt), offDr);
    10051005    return VINF_SUCCESS;
    10061006}
    … …  
    10121012    int rc = VINF_SUCCESS;
    10131013
    1014     PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
     1014    PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
    10151015    if (pCmd)
    10161016    {
    … …  
    10191019        pCmd->i32Result = VERR_NOT_SUPPORTED;
    10201020
    1021         const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
     1021        const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
    10221022        Assert(pHdr);
    10231023        if (pHdr)
    … …  
    10251025            do
    10261026            {
    1027                 HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
     1027                HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
    10281028                Assert(offCmd != HGSMIOFFSET_VOID);
    10291029                if (offCmd != HGSMIOFFSET_VOID)
    … …  
    10331033                    if (RT_SUCCESS(rc))
    10341034                    {
    1035                         rc = VBoxSHGSMICommandDoneSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
     1035                        rc = VBoxSHGSMICommandDoneSynch(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
    10361036                        AssertRC(rc);
    10371037                        if (RT_SUCCESS(rc))
    … …  
    10461046                    rc = VERR_INVALID_PARAMETER;
    10471047                /* fail to submit, cancel it */
    1048                 VBoxSHGSMICommandCancelSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
     1048                VBoxSHGSMICommandCancelSynch(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
    10491049            } while (0);
    10501050        }
    10511051
    1052         VBoxSHGSMICommandFree (&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
     1052        VBoxSHGSMICommandFree (&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
    10531053    }
    10541054    else

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

    r32823 r32989  
    4545    if(!cRefs)
    4646    {
    47         vboxHGSMIBufferFree(pDevExt, pCmd);
     47        vboxHGSMIBufferFree(commonFromDeviceExt(pDevExt), pCmd);
    4848    }
    4949}
    … …  
    6161    vbvaVhwaCommandRetain(pDevExt, pCmd);
    6262
    63     vboxHGSMIBufferSubmit(pDevExt, pCmd);
     63    vboxHGSMIBufferSubmit(commonFromDeviceExt(pDevExt), pCmd);
    6464
    6565    if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH)
    … …  
    100100                              VBVA_VHWA_CMD);
    101101#else
    102     VBOXVHWACMD* pHdr = (VBOXVHWACMD*)vboxHGSMIBufferAlloc(pDevExt,
     102    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)vboxHGSMIBufferAlloc(commonFromDeviceExt(pDevExt),
    103103                              cbCmd + VBOXVHWACMD_HEADSIZE(),
    104104                              HGSMI_CH_VBVA,

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

    r32930 r32989  
    107107NTSTATUS vboxWddmGhDisplayPostInfoScreenBySDesc (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SURFACE_DESC pDesc, POINT * pVScreenPos, uint16_t fFlags)
    108108{
    109     void *p = vboxHGSMIBufferAlloc (pDevExt,
     109    void *p = vboxHGSMIBufferAlloc (commonFromDeviceExt(pDevExt),
    110110                                      sizeof (VBVAINFOSCREEN),
    111111                                      HGSMI_CH_VBVA,
    … …  
    126126        pScreen->u16Flags        = fFlags;
    127127
    128         vboxHGSMIBufferSubmit (pDevExt, p);
    129 
    130         vboxHGSMIBufferFree (pDevExt, p);
     128        vboxHGSMIBufferSubmit (commonFromDeviceExt(pDevExt), p);
     129
     130        vboxHGSMIBufferFree (commonFromDeviceExt(pDevExt), p);
    131131    }
    132132
    … …  
    150150
    151151    /* Issue the screen info command. */
    152     void *p = vboxHGSMIBufferAlloc (pDevExt,
     152    void *p = vboxHGSMIBufferAlloc (commonFromDeviceExt(pDevExt),
    153153                                      sizeof (VBVAINFOVIEW),
    154154                                      HGSMI_CH_VBVA,
    … …  
    165165        pView->u32MaxScreenSize = pView->u32ViewSize;
    166166
    167         vboxHGSMIBufferSubmit (pDevExt, p);
    168 
    169         vboxHGSMIBufferFree (pDevExt, p);
     167        vboxHGSMIBufferSubmit (commonFromDeviceExt(pDevExt), p);
     168
     169        vboxHGSMIBufferFree (commonFromDeviceExt(pDevExt), p);
    170170    }
    171171
    … …  
    268268        return &pDevExt->u.primary.Vdma.CmdHeap;
    269269#endif
    270     if (HGSMIAreaContainsOffset(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap.area, offCmd))
    271         return &hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap;
     270    if (HGSMIAreaContainsOffset(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap.area, offCmd))
     271        return &commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap;
    272272    return NULL;
    273273}
    … …  
    288288        return VBOXWDDM_HGSMICMD_TYPE_DMACMD;
    289289#endif
    290     if (HGSMIAreaContainsOffset(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap.area, offCmd))
     290    if (HGSMIAreaContainsOffset(&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap.area, offCmd))
    291291        return VBOXWDDM_HGSMICMD_TYPE_CTL;
    292292    return VBOXWDDM_HGSMICMD_TYPE_UNDEFINED;
    … …  
    421421       if (VBoxHGSMIIsSupported (pContext))
    422422       {
    423            hgsmiFromDeviceExt(pContext)->IOPortHost = (RTIOPORT)VGA_PORT_HGSMI_HOST;
    424            hgsmiFromDeviceExt(pContext)->IOPortGuest = (RTIOPORT)VGA_PORT_HGSMI_GUEST;
     423           commonFromDeviceExt(pContext)->IOPortHost = (RTIOPORT)VGA_PORT_HGSMI_HOST;
     424           commonFromDeviceExt(pContext)->IOPortGuest = (RTIOPORT)VGA_PORT_HGSMI_GUEST;
    425425
    426426           PCM_RESOURCE_LIST pRcList = pDeviceInfo->TranslatedResourceList;
    … …  
    580580                 */
    581581                VBoxSetupDisplaysHGSMI(pContext, AdapterMemorySize);
    582                 if (hgsmiFromDeviceExt(pContext)->bHGSMI)
     582                if (commonFromDeviceExt(pContext)->bHGSMI)
    583583                {
    584584                    drprintf(("VBoxVideoWddm: using HGSMI\n"));
    … …  
    794794            {
    795795                /* read the command offset */
    796                 HGSMIOFFSET offCmd = VBoxHGSMIGuestRead(hgsmiFromDeviceExt(pDevExt));
     796                HGSMIOFFSET offCmd = VBoxHGSMIGuestRead(commonFromDeviceExt(pDevExt));
    797797                Assert(offCmd != HGSMIOFFSET_VOID);
    798798                if (offCmd != HGSMIOFFSET_VOID)
    … …  
    811811                        case VBOXWDDM_HGSMICMD_TYPE_CTL:
    812812                            pList = &CtlList;
    813                             pHeap = &hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap;
     813                            pHeap = &commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap;
    814814                            break;
    815815                        default:
    … …  
    888888        if (bOur)
    889889        {
    890             HGSMIClearIrq (hgsmiFromDeviceExt(pDevExt));
     890            HGSMIClearIrq (commonFromDeviceExt(pDevExt));
    891891#ifdef DEBUG_misha
    892892            /* this is not entirely correct since host may concurrently complete some commands and raise a new IRQ while we are here,
    … …  
    974974    if (!vboxSHGSMIListIsEmpty(&context.data.CtlList))
    975975    {
    976         int rc = VBoxSHGSMICommandPostprocessCompletion (&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, &context.data.CtlList);
     976        int rc = VBoxSHGSMICommandPostprocessCompletion (&commonFromDeviceExt(pDevExt)->hgsmiAdapterHeap, &context.data.CtlList);
    977977        AssertRC(rc);
    978978    }
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette