自学教程：C++ EngDeviceIoControl函数代码示例

DWORD XenVesaMapVideoMemory(PPDEV pDev){    DWORD dwRet, dwRetBytes;    VIDEO_MEMORY videoMem;    VIDEO_MEMORY_INFORMATION videoMemInfo;    videoMem.RequestedVirtualAddress = 0;    dwRet = EngDeviceIoControl(pDev->hDriver,                                IOCTL_VIDEO_MAP_VIDEO_MEMORY, 			       &videoMem, sizeof(VIDEO_MEMORY),                               &videoMemInfo, 			       sizeof(VIDEO_MEMORY_INFORMATION), &dwRetBytes);    if (dwRet != 0 )    {         XenVesaDebugPrint(DEBUG_LEVEL_ERROR, 	                   "Unable to map video memory!  Error - %d/n",			   dwRet);	 pDev->pFrameBuffer = (PULONG) NULL;         return dwRet;    }    pDev->pFrameBuffer = (PULONG) videoMemInfo.FrameBufferBase;    return dwRet;}

DWORD XenVesaGetNumModesFromMiniport(HANDLE hDrv, PDWORD pNumModes,                                      PDWORD pModeInfoSize){    DWORD dwRet, dwRetBytes;    VIDEO_NUM_MODES videoNumModes;    if ( pNumModes == NULL || pModeInfoSize == NULL )    {        XenVesaDebugPrint(DEBUG_LEVEL_ERROR,	                  "GetNumModesFromMiniport: Invalid input!/n");        return -1;    }    dwRet = EngDeviceIoControl(hDrv, IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES,                                NULL, 0, &videoNumModes, 			       sizeof(VIDEO_NUM_MODES), &dwRetBytes);    if ( dwRet != 0 )    {        XenVesaDebugPrint(DEBUG_LEVEL_ERROR,                    "Unable to query number of available modes.  Error - %d/n",                    dwRet);        return dwRet;    }    *pModeInfoSize = videoNumModes.ModeInformationLength;    *pNumModes = videoNumModes.NumModes;    return dwRet;}

DWORD XenVesaGetModesFromMiniport(HANDLE hDrv,                                   PVIDEO_MODE_INFORMATION pModeInfo,                                  DWORD dwModeInfoSize, DWORD dwNumModes){    DWORD dwRet, dwRetBytes, dwTotalModeInfoSize;    if ( dwModeInfoSize == 0 || dwNumModes == 0 || pModeInfo == NULL )    {        XenVesaDebugPrint(DEBUG_LEVEL_ERROR,	                  "XenVesaGetModesFromMiniport: Invalid input!/n");        return -1;    }    dwTotalModeInfoSize = dwModeInfoSize * dwNumModes;    dwRet = EngDeviceIoControl(hDrv, IOCTL_VIDEO_QUERY_AVAIL_MODES,                                NULL, 0, pModeInfo, 			       dwTotalModeInfoSize, &dwRetBytes);     if ( dwRet != 0 )    {        XenVesaDebugPrint(DEBUG_LEVEL_ERROR,	                  "Unable to query available modes! Error - %d/n",			  dwRet);        return dwRet;    }    return dwRet;}

BOOL NTAPI bInitPointer(PPDEV ppdev, DEVINFO *pdevinfo){    DWORD    returnedDataLength;    ppdev->pPointerAttributes = (PVIDEO_POINTER_ATTRIBUTES) NULL;    ppdev->cjPointerAttributes = 0; // initialized in screen.c    //    // Ask the miniport whether it provides pointer support.    //    if (EngDeviceIoControl(ppdev->hDriver,                           IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES,                           NULL,                           0,                           &ppdev->PointerCapabilities,                           sizeof(ppdev->PointerCapabilities),                           &returnedDataLength))    {         return(FALSE);    }    //    // If neither mono nor color hardware pointer is supported, there's no    // hardware pointer support and we're done.    //    if ((!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_MONO_POINTER)) &&        (!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_COLOR_POINTER)))    {        return(TRUE);    }    //    // Note: The buffer itself is allocated after we set the    // mode. At that time we know the pixel depth and we can    // allocate the correct size for the color pointer if supported.    //    //    // Set the asynchronous support status (async means miniport is capable of    // drawing the Pointer at any time, with no interference with any ongoing    // drawing operation)    //    if (ppdev->PointerCapabilities.Flags & VIDEO_MODE_ASYNC_POINTER)    {       pdevinfo->flGraphicsCaps |= GCAPS_ASYNCMOVE;    }    else    {       pdevinfo->flGraphicsCaps &= ~GCAPS_ASYNCMOVE;    }    return(TRUE);}

int VBoxDispMPDisablePointer(HANDLE hDriver){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_DISABLE_POINTER, NULL, 0, NULL, 0, &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

int VBoxDispMPResetDevice(HANDLE hDriver){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_RESET_DEVICE, NULL, 0, NULL, 0, &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

int VBoxDispMPSetColorRegisters(HANDLE hDriver, PVIDEO_CLUT pClut, DWORD cbClut){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_SET_COLOR_REGISTERS, pClut, cbClut, NULL, 0, &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

BOOL bInit256ColorPalette(PPDEV ppdev){    BYTE        ajClutSpace[MAX_CLUT_SIZE];    PVIDEO_CLUT pScreenClut;    ULONG       ulReturnedDataLength;    ULONG       cColors;    PVIDEO_CLUTDATA pScreenClutData;    if (ppdev->ulBitCount == 8)    {        //        // Fill in pScreenClut header info:        //        pScreenClut             = (PVIDEO_CLUT) ajClutSpace;        pScreenClut->NumEntries = 256;        pScreenClut->FirstEntry = 0;        //        // Copy colours in:        //        cColors = 256;        pScreenClutData = (PVIDEO_CLUTDATA) (&(pScreenClut->LookupTable[0]));        while(cColors--)        {            pScreenClutData[cColors].Red =    ppdev->pPal[cColors].peRed >>                                              ppdev->cPaletteShift;            pScreenClutData[cColors].Green =  ppdev->pPal[cColors].peGreen >>                                              ppdev->cPaletteShift;            pScreenClutData[cColors].Blue =   ppdev->pPal[cColors].peBlue >>                                              ppdev->cPaletteShift;            pScreenClutData[cColors].Unused = 0;        }        //        // Set palette registers:        //        if (EngDeviceIoControl(ppdev->hDriver,                               IOCTL_VIDEO_SET_COLOR_REGISTERS,                               pScreenClut,                               MAX_CLUT_SIZE,                               NULL,                               0,                               &ulReturnedDataLength))        {            DISPDBG((0, "Failed bEnablePalette"));            return(FALSE);        }    }

BOOL DrvSetPalette (DHPDEV dhpdev,                    PALOBJ *ppalo,                    FLONG  fl,                    ULONG  iStart,                    ULONG  cColors){    BYTE ajClutSpace[MAX_CLUT_SIZE];    PVIDEO_CLUT pScreenClut = (PVIDEO_CLUT) ajClutSpace;    PPALETTEENTRY pape;    ULONG ulTemp = 256;    UNREFERENCED_PARAMETER (fl);    DISPBLTDBG ((1, "TGA.DLL!DrvSetPalette - Entry/n"));    DISPBLTDBG ((2, "TGA.DLL!DrvSetPalette - ppalo [%x], fl [%x], iStart [%d], cColors [%d]/n", ppalo, fl, iStart, cColors));    // Fill in pScreenClut header info    pScreenClut->NumEntries = (USHORT)cColors;    pScreenClut->FirstEntry = (USHORT)iStart;    pape = (PPALETTEENTRY) (pScreenClut->LookupTable);    if (cColors != PALOBJ_cGetColors (ppalo, iStart, cColors, (PULONG) pape))    {        RIP ("DISP DrvSetPalette failed PALOBJ_cGetColors/n");        return FALSE;    }    // Set the high reserved byte in each palette entry to 0.    while (cColors--)        pape[cColors].peFlags = 0;    // Set palette registers    if (EngDeviceIoControl (((PPDEV)(dhpdev))->hDriver,                           IOCTL_VIDEO_SET_COLOR_REGISTERS,                           pScreenClut,                           MAX_CLUT_SIZE,                           NULL,                           0,                          &cColors))    {        RIP ("DISP DrvSetPalette failed EngDeviceIoControl/n");        return FALSE;    }    DISPBLTDBG ((1, "TGA.DLL!DrvSetPalette - Exit/n"));    return TRUE;}

int VBoxDispMPSetPointerPosition(HANDLE hDriver, PVIDEO_POINTER_POSITION pPos){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_SET_POINTER_POSITION, pPos, sizeof(VIDEO_POINTER_POSITION),                              NULL, 0, &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

DWORD XenVesaResetDevice(PPDEV pDev){    DWORD dwRet, dwRetBytes;    dwRet = EngDeviceIoControl(pDev->hDriver, IOCTL_VIDEO_RESET_DEVICE,                               0, 0, 0, 0, &dwRetBytes);    if ( dwRet != 0)        XenVesaDebugPrint(DEBUG_LEVEL_ERROR,                          "Reset device failed with error - %d/n",                          dwRet);    return dwRet;}

int VBoxDispMPSetVisibleRegion(HANDLE hDriver, PRTRECT pRects, DWORD cRects){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_VBOX_SETVISIBLEREGION, pRects, cRects*sizeof(RTRECT),                              NULL, 0, &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

int VBoxDispMPUnshareVideoMemory(HANDLE hDriver, PVIDEO_SHARE_MEMORY pSMem){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY, pSMem, sizeof(VIDEO_SHARE_MEMORY),                              NULL, 0, &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

/* Set device mode */int VBoxDispMPSetCurrentMode(HANDLE hDriver, ULONG ulMode){    DWORD dwrc;    ULONG cbReturned;    VIDEO_MODE mode;    LOGF_ENTER();    mode.RequestedMode = ulMode;    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_SET_CURRENT_MODE, &mode, sizeof(VIDEO_MODE), NULL, 0, &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

int VBoxDispMPShareVideoMemory(HANDLE hDriver, PVIDEO_SHARE_MEMORY pSMem, PVIDEO_SHARE_MEMORY_INFORMATION pSMemInfo){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_SHARE_VIDEO_MEMORY, pSMem, sizeof(VIDEO_SHARE_MEMORY),                              pSMemInfo, sizeof(VIDEO_SHARE_MEMORY_INFORMATION), &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_SHARE_VIDEO_MEMORY", cbReturned,                            sizeof(VIDEO_SHARE_MEMORY_INFORMATION), VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

int VBoxDispMPHGSMIQueryPortProcs(HANDLE hDriver, HGSMIQUERYCPORTPROCS *pPortProcs){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    memset(pPortProcs, 0, sizeof(HGSMIQUERYCPORTPROCS));    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_HGSMI_QUERY_PORTPROCS, NULL, 0,                              pPortProcs, sizeof(HGSMIQUERYCPORTPROCS), &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_HGSMI_QUERY_PORTPROCS", cbReturned, sizeof(HGSMIQUERYCPORTPROCS), VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

int VBoxDispMPSetPointerAttrs(PVBOXDISPDEV pDev){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    Assert(pDev->pointer.pAttrs);    dwrc = EngDeviceIoControl(pDev->hDriver, IOCTL_VIDEO_SET_POINTER_ATTR, pDev->pointer.pAttrs, pDev->pointer.cbAttrs,                              NULL, 0, &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

int VBoxDispMPVHWAQueryInfo(HANDLE hDriver, VHWAQUERYINFO *pInfo){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    memset(pInfo, 0, sizeof(VHWAQUERYINFO));    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_VHWA_QUERY_INFO, NULL, 0,                              pInfo, sizeof(VHWAQUERYINFO), &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_VHWA_QUERY_INFO", cbReturned, sizeof(VHWAQUERYINFO), VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

int VBoxDispMPQueryHGSMICallbacks(HANDLE hDriver, HGSMIQUERYCALLBACKS *pCallbacks){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    memset(pCallbacks, 0, sizeof(HGSMIQUERYCALLBACKS));    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS, NULL, 0,                              pCallbacks, sizeof(HGSMIQUERYCALLBACKS), &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS", cbReturned, sizeof(HGSMIQUERYCALLBACKS), VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

DWORD XenVesaSetCurrentDisplayMode(PPDEV pDev){    DWORD dwRet, dwRetBytes;    VIDEO_MODE vMode;    vMode.RequestedMode = pDev->ulMode;    dwRet =  EngDeviceIoControl(pDev->hDriver,                                 IOCTL_VIDEO_SET_CURRENT_MODE, &vMode,				sizeof(VIDEO_MODE), 0, 0, &dwRetBytes);    if (dwRet != 0 )        XenVesaDebugPrint(DEBUG_LEVEL_ERROR,                           "Unable to set current display mode! Error - %d/n",                          dwRet);    return dwRet;}

int VBoxDispMPUnmapMemory(PVBOXDISPDEV pDev){    DWORD dwrc;    ULONG cbReturned;    VIDEO_MEMORY vMem;    LOGF_ENTER();    vMem.RequestedVirtualAddress = pDev->memInfo.VideoRamBase;    dwrc = EngDeviceIoControl(pDev->hDriver, IOCTL_VIDEO_UNMAP_VIDEO_MEMORY, &vMem, sizeof(vMem), NULL, 0, &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    memset(&pDev->memInfo, 0, sizeof(VIDEO_MEMORY_INFORMATION));    LOGF_LEAVE();    return VINF_SUCCESS;}

/* Query miniport for mouse pointer caps */int VBoxDispMPGetPointerCaps(HANDLE hDriver, PVIDEO_POINTER_CAPABILITIES pCaps){    DWORD dwrc;    ULONG cbReturned;    LOGF_ENTER();    memset(pCaps, 0, sizeof(VIDEO_POINTER_CAPABILITIES));    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES, NULL, 0,                              pCaps, sizeof(VIDEO_POINTER_CAPABILITIES), &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES", cbReturned, sizeof(VIDEO_POINTER_CAPABILITIES), VERR_DEV_IO_ERROR);    LOGF_LEAVE();    return VINF_SUCCESS;}

BOOL bEnablePalette(PDEV* ppdev){    BYTE        ajClutSpace[MAX_CLUT_SIZE];    PVIDEO_CLUT pScreenClut;    ULONG       ulReturnedDataLength;    PALETTEENTRY* ppalFrom;    PALETTEENTRY* ppalTo;    PALETTEENTRY* ppalEnd;    if (ppdev->iBitmapFormat == BMF_8BPP)    {        // Fill in pScreenClut header info:        pScreenClut             = (PVIDEO_CLUT) ajClutSpace;        pScreenClut->NumEntries = 256;        pScreenClut->FirstEntry = 0;        // Copy Colors in.        ppalFrom = ppdev->pPal;        ppalTo   = (PALETTEENTRY*) pScreenClut->LookupTable;        ppalEnd  = &ppalTo[256];        for (; ppalTo < ppalEnd; ppalFrom++, ppalTo++)        {            ppalTo->peRed   = ppalFrom->peRed   >> 2;            ppalTo->peGreen = ppalFrom->peGreen >> 2;            ppalTo->peBlue  = ppalFrom->peBlue  >> 2;            ppalTo->peFlags = 0;        }        // Set palette registers:        if (EngDeviceIoControl(ppdev->hDriver,                             IOCTL_VIDEO_SET_COLOR_REGISTERS,                             pScreenClut,                             MAX_CLUT_SIZE,                             NULL,                             0,                             &ulReturnedDataLength))        {            DISPDBG((0, "Failed bEnablePalette"));            return(FALSE);        }    }

VOID NTAPI vDisableSURF(PPDEV ppdev){    DWORD returnedDataLength;    VIDEO_MEMORY videoMemory;    videoMemory.RequestedVirtualAddress = (PVOID) ppdev->pjScreen;    if (EngDeviceIoControl(ppdev->hDriver,                           IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,                           &videoMemory,                           sizeof(VIDEO_MEMORY),                           NULL,                           0,                           &returnedDataLength))    {        RIP("DISP vDisableSURF failed IOCTL_VIDEO_UNMAP/n");    }}

int VBoxDispMPQueryRegistryFlags(HANDLE hDriver, ULONG *pulFlags){    DWORD dwrc;    ULONG cbReturned;    ULONG ulInfoLevel;    LOGF_ENTER();    *pulFlags = 0;    ulInfoLevel = VBOXVIDEO_INFO_LEVEL_REGISTRY_FLAGS;    dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_QUERY_VBOXVIDEO_INFO, &ulInfoLevel, sizeof(DWORD),                              pulFlags, sizeof(DWORD), &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_QUERY_INFO", cbReturned, sizeof(DWORD), VERR_DEV_IO_ERROR);    if (*pulFlags != 0)        LogRel(("VBoxDisp: video flags 0x%08X/n", *pulFlags));    LOGF_LEAVE();    return VINF_SUCCESS;}

DWORD XenVesaUnmapVideoMemory(PPDEV pDev){    DWORD dwRet, dwRetBytes;    VIDEO_MEMORY videoMem;    if ( pDev->pFrameBuffer == NULL )        return 0;    videoMem.RequestedVirtualAddress = pDev->pFrameBuffer;    dwRet = EngDeviceIoControl(pDev->hDriver,                               IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,                               &videoMem, sizeof(VIDEO_MEMORY),                               0, 0, &dwRetBytes);    pDev->pFrameBuffer = (PULONG) NULL;    if (dwRet != 0 )         XenVesaDebugPrint(DEBUG_LEVEL_ERROR,                           "Unable to unmap video memory!  Error - %d/n",                           dwRet);    return dwRet;}

BOOL DeinitVGA(PPDEV ppdev){    VIDEO_MEMORY VideoMemory;    ULONG ReturnedDataLength;    VideoMemory.RequestedVirtualAddress = (PVOID)ppdev->fbScreen;    if (EngDeviceIoControl(ppdev->KMDriver,                           IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,                           (PVOID)&VideoMemory,                           sizeof(VIDEO_MEMORY),                           NULL,                           0,                           &ReturnedDataLength))    {        DPRINT1("Failed to unmap video memory./n");        EngDebugBreak();        return FALSE;    }    return TRUE;}

BOOL DrvAssertMode(DHPDEV dhpdev,BOOL bEnable){    PPDEV   ppdev = (PPDEV) dhpdev;    ULONG   ulReturn;    if (bEnable)    {        //        // The screen must be reenabled, reinitialize the device to clean state.        //        return (bInitSURF(ppdev, FALSE));    }    else    {        //        // We must give up the display.        // Call the kernel driver to reset the device to a known state.        //        if (EngDeviceIoControl(ppdev->hDriver,                               IOCTL_VIDEO_RESET_DEVICE,                               NULL,                               0,                               NULL,                               0,                               &ulReturn))        {            RIP("DISP DrvAssertMode failed IOCTL");            return FALSE;        }        else        {            return TRUE;        }    }}

/* Map device framebuffer and VRAM to our virtual address space */int VBoxDispMPMapMemory(PVBOXDISPDEV pDev, PVIDEO_MEMORY_INFORMATION pMemInfo){    DWORD dwrc;    ULONG cbReturned;    VIDEO_MEMORY vMem;    VIDEO_MEMORY_INFORMATION vMemInfo;    LOGF_ENTER();    Assert(!pDev->memInfo.FrameBufferBase && !pDev->memInfo.VideoRamBase);    vMem.RequestedVirtualAddress = NULL;    dwrc = EngDeviceIoControl(pDev->hDriver, IOCTL_VIDEO_MAP_VIDEO_MEMORY, &vMem, sizeof(vMem), &vMemInfo, sizeof(vMemInfo), &cbReturned);    VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);    VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_MAP_VIDEO_MEMORY", cbReturned, sizeof(vMemInfo), VERR_DEV_IO_ERROR);    if (vMemInfo.FrameBufferBase != vMemInfo.VideoRamBase)    {        WARN(("FrameBufferBase!=VideoRamBase."));        return VERR_GENERAL_FAILURE;    }    /* Check if we can access mapped memory */    uint32_t magic = (*(ULONG *)vMemInfo.FrameBufferBase == 0xDEADF00D) ? 0xBAADF00D : 0xDEADF00D;    ASMAtomicWriteU32((uint32_t *)vMemInfo.FrameBufferBase, magic);    if (ASMAtomicReadU32((uint32_t *)vMemInfo.FrameBufferBase) != magic)    {        WARN(("can't write to framebuffer memory!"));        return VERR_GENERAL_FAILURE;    }    memcpy(pMemInfo, &vMemInfo, sizeof(vMemInfo));    LOGF_LEAVE();    return VINF_SUCCESS;}