VBoxVideo.cpp revision 9bd6fee3d1017cb014d0de810b8ff269b7a12f2e
/*
*
* Based on DDK sample code.
*
* Copyright (C) 2006-2007 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#include "VBoxVideo-win.h"
#include "Helper.h"
#ifdef VBOX_WITH_WDDM
#include "wddm/VBoxVideoMisc.h"
#endif
#include <VBox/VBoxGuest.h>
#include <VBox/VBoxVideo.h>
#include <VBox/VBoxGuestLib.h>
#include <VBoxDisplay.h>
#define _INC_SWPRINTF_INL_
#endif
#include <wchar.h>
#include "vboxioctl.h"
VIDEO_ACCESS_RANGE VGARanges[] = {
{ 0x000003B0, 0x00000000, 0x0000000C, 1, 1, 1, 0 }, /* 0x3B0-0x3BB */
{ 0x000003C0, 0x00000000, 0x00000020, 1, 1, 1, 0 }, /* 0x3C0-0x3DF */
{ 0x000A0000, 0x00000000, 0x00020000, 0, 0, 1, 0 }, /* 0xA0000-0xBFFFF */
};
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
#ifndef VBOX_WITH_WDDM
typedef struct _DEVICE_EXTENSION * VBOXCMNREG;
#else
typedef HANDLE VBOXCMNREG;
#endif
/*******************************************************************************
* Internal Functions *
*******************************************************************************/
static VP_STATUS VBoxVideoFindAdapter(
static BOOLEAN VBoxVideoStartIO(
#ifdef VBOX_WITH_VIDEOHWACCEL
#endif
static BOOLEAN VBoxVideoResetHW(
static VP_STATUS VBoxVideoGetPowerState(
static VP_STATUS VBoxVideoSetPowerState(
static VP_STATUS VBoxVideoGetChildDescriptor(
#ifndef VBOX_WITH_WDDM
/*+++
Routine Description:
This routine is used to read back various registry values.
Arguments:
HwDeviceExtension
Supplies a pointer to the miniport's device extension.
Context
Context value passed to the get registry parameters routine.
If this is not null assume it's a ULONG* and save the data value in it.
ValueName
Name of the value requested.
ValueData
Pointer to the requested data.
ValueLength
Length of the requested data.
Return Value:
If the variable doesn't exist return an error,
else if a context is supplied assume it's a PULONG and fill in the value
and return no error, else if the value is non-zero return an error.
---*/
{
//dprintf(("VBoxVideo::VBoxRegistryCallback: Context: %p, ValueName: %S, ValueData: %p, ValueLength: %d\n",
// Context, ValueName, ValueData, ValueLength));
if (ValueLength)
{
if (Context)
return ERROR_INVALID_PARAMETER;
return NO_ERROR;
}
else
return ERROR_INVALID_PARAMETER;
}
#endif /* #ifndef VBOX_WITH_WDDM */
{
#ifndef VBOX_WITH_WDDM
#else
if(!Reg)
return ERROR_INVALID_PARAMETER;
#endif
}
{
#ifndef VBOX_WITH_WDDM
#else
if(!Reg)
return ERROR_INVALID_PARAMETER;
#endif
}
{
#ifndef VBOX_WITH_WDDM
return NO_ERROR;
#else
if (Status == STATUS_SUCCESS)
{
if(Status == STATUS_SUCCESS)
return NO_ERROR;
}
/* fall-back to make the subsequent VBoxVideoCmnRegXxx calls treat the fail accordingly
* basically needed to make as less modifications to the current XPDM code as possible */
return ERROR_INVALID_PARAMETER;
#endif
}
{
#ifndef VBOX_WITH_WDDM
return NO_ERROR;
#else
if(!Reg)
return ERROR_INVALID_PARAMETER;
#endif
}
{
#ifndef VBOX_WITH_WDDM
pEvent);
#else
#endif
}
#define MEM_TAG 'HVBV'
{
#ifndef VBOX_WITH_WDDM
return PrimaryExtension->u.primary.VideoPortProcs.pfnAllocatePool(PrimaryExtension, (VBOXVP_POOL_TYPE)VpNonPagedPool, cb, Tag);
#else
#endif
}
{
#ifndef VBOX_WITH_WDDM
pv);
#else
ExFreePool(pv);
#endif
}
{
#ifndef VBOX_WITH_WDDM
#else
#endif
}
#ifndef VBOX_WITH_WDDM
{
#ifdef VBOX_WITH_VIDEOHWACCEL
#else
#endif
// nowhere documented but without the following line, NT4 SP0 will choke
// report legacy VGA resource ranges
// our DDK is at the Win2k3 level so we have to take special measures
// for backwards compatibility
switch (vboxQueryWinVersion())
{
case WINNT4:
dprintf(("VBoxVideo::DriverEntry: WINNT4\n"));
break;
case WIN2K:
dprintf(("VBoxVideo::DriverEntry: WIN2K\n"));
break;
}
return rc;
}
#endif
static void initVideoModeInformation(VIDEO_MODE_INFORMATION *pVideoMode, ULONG xres, ULONG yres, ULONG bpp, ULONG index, ULONG yoffset)
{
/*
* Build mode entry.
*/
switch (bpp)
{
#ifdef VBOX_WITH_8BPP_MODES
case 8:
pVideoMode->RedMask = 0;
pVideoMode->GreenMask = 0;
pVideoMode->BlueMask = 0;
break;
#endif
case 16:
break;
case 24:
break;
case 32:
break;
}
#ifdef VBOX_WITH_8BPP_MODES
if (bpp == 8)
#endif
}
/* builds a g_VBoxWddmVideoResolutions given VideoModes info */
static int vboxVideoBuildResolutionTable(VIDEO_MODE_INFORMATION *VideoModes, uint32_t cNumVideoModes, SIZE *pResolutions, uint32_t * pcResolutions)
{
uint32_t cResolutions = 0;
int rc = VINF_SUCCESS;
/* we don't care about the efficiency at this time */
for (uint32_t i = 0; i < cNumVideoModes; ++i)
{
bool bFound = false;
for (uint32_t j = 0; j < cResolutions; ++j)
{
{
bFound = true;
break;
}
}
if (!bFound)
{
if (cResolutions >= cResolutionsArray)
{
break;
}
++cResolutions;
}
}
return rc;
}
/* On the driver startup this is initialized from registry (replaces gCustom*). */
static bool vboxVideoIsVideoModeSupported(PDEVICE_EXTENSION DeviceExtension, int iDisplay, ULONG vramSize,
{
static uint32_t xresNoVRAM = 0;
static uint32_t yresNoVRAM = 0;
if (!(( xres
&& yres
&& ( (bpp == 16)
#ifdef VBOX_WITH_8BPP_MODES
|| (bpp == 8)
#endif
|| (bpp == 24)
|| (bpp == 32)))
{
dprintf(("VBoxVideo: invalid parameters for special mode: (xres = %d, yres = %d, bpp = %d, vramSize = %d)\n",
{
LogRel(("VBoxVideo: not enough VRAM for video mode %dx%dx%dbpp. Available: %d bytes. Required: more than %d bytes.\n",
xresNoVRAM = xres;
yresNoVRAM = yres;
}
return false;
}
/* does the host like that mode? */
{
dprintf(("VBoxVideo: host does not like special mode: (xres = %d, yres = %d, bpp = %d)\n",
return false;
}
return true;
}
/*
* @return index for the changed mode, or -1 of none
*/
{
return -1;
return -1;
#ifndef VBOX_WITH_WDDM
dprintf(("VBoxVideo: adding custom video mode as #%d, current mode: %d \n", gNumVideoModes + 1, DeviceExtension->CurrentMode));
/* handle the startup case */
if (DeviceExtension->CurrentMode == 0)
#else
if (!commonFromDeviceExt(DeviceExtension)->cDisplays || !DeviceExtension->aSources[0].pPrimaryAllocation)
#endif
{
/* Use the stored custom resolution values only if nothing was read from host.
* The custom mode might be not valid anymore and would block any hints from host.
*/
if (!xres)
if (!yres)
if (!bpp)
}
/* round down to multiple of 8 if necessary */
if (!DeviceExtension->fAnyX) {
xres &= 0xfff8;
}
/* take the current values for the fields that are not set */
#ifndef VBOX_WITH_WDDM
if (DeviceExtension->CurrentMode != 0)
{
if (!xres)
if (!yres)
if (!bpp)
}
#else
if (commonFromDeviceExt(DeviceExtension)->cDisplays && DeviceExtension->aSources[0].pPrimaryAllocation)
{
if (!xres)
if (!yres)
if (!bpp)
}
#endif
/* Use a default value. */
if (!bpp)
bpp = 32;
#ifndef VBOX_WITH_WDDM
#else
/* at least two surfaces will be needed: primary & shadow */
#endif
{
return -1;
}
dprintf(("VBoxVideo: setting special mode to xres = %d, yres = %d, bpp = %d, display = %d\n", xres, yres, bpp, display));
/*
* Build mode entry.
* Note that we do not apply the y offset for the custom mode. It is
* only used for the predefined modes that the user can configure in
* the display properties dialog.
*/
CustomVideoModes[display].ModeIndex = display + 1; /* ensure it is not zero, zero means the mode is loaded from registry and needs verification */
switch (bpp)
{
#ifdef VBOX_WITH_8BPP_MODES
case 8:
break;
#endif
case 16:
break;
case 24:
break;
case 32:
break;
}
CustomVideoModes[display].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
#ifdef VBOX_WITH_8BPP_MODES
if (bpp == 8)
#endif
/* Save the custom mode for this display. */
if (display)
{
/* Name without a suffix */
}
else
{
wchar_t keyname[32];
}
return display;
}
#ifdef VBOX_WITH_WDDM
static bool vboxVideoModesMatch(const VIDEO_MODE_INFORMATION *pMode1, const VIDEO_MODE_INFORMATION *pMode2)
{
}
int vboxVideoModeFind(const VIDEO_MODE_INFORMATION *pModes, int cModes, const VIDEO_MODE_INFORMATION *pM)
{
for (int i = 0; i < cModes; ++i)
{
return i;
}
return -1;
}
static DECLINLINE(int) vboxVideoCheckModeAdd(VIDEO_MODE_INFORMATION *pModes, int *pcNumModes, int *piPreferred)
{
const int cNumModes = *pcNumModes;
for (int i = 0; i < cNumModes; ++i)
{
{
{
*piPreferred = i;
}
return i;
}
}
++(*pcNumModes);
return cNumModes;
}
static bool vboxVideoModeAdjustCheckSupported(PDEVICE_EXTENSION pDevExt, int iDisplay, VIDEO_MODE_INFORMATION *pMode)
{
/* round down to multiple of 8 if necessary */
dprintf(("VBoxVideo: rounding down xres from %d to %d\n", pMode->VisScreenWidth, pMode->VisScreenWidth & 0xfff8));
}
if (vboxLikesVideoMode(iDisplay, pMode->VisScreenWidth, pMode->VisScreenHeight, pMode->BitsPerPlane))
return true;
return false;
}
static int vboxVideoModeAdd(VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, uint32_t *pcNumModes, const VIDEO_MODE_INFORMATION *pMode)
{
{
{
return (int)i;
}
}
{
++(*pcNumModes);
return (int)cNumModes;
}
return -1;
}
# define VBOXVIDEOMODE_ADDED(_aModes, _pcModes, _piPreferred) vboxVideoCheckModeAdd(_aModes, _pcModes, _piPreferred)
#else
#endif
static void vboxVideoInitMode(VIDEO_MODE_INFORMATION *pVideoMode, ULONG xres, ULONG yres, ULONG bpp, ULONG index, ULONG yoffset)
{
/*
* Build mode entry.
*/
switch (bpp)
{
#ifdef VBOX_WITH_8BPP_MODES
case 8:
pVideoMode->RedMask = 0;
pVideoMode->GreenMask = 0;
pVideoMode->BlueMask = 0;
break;
#endif
case 16:
break;
case 24:
break;
case 32:
break;
}
#ifdef VBOX_WITH_8BPP_MODES
if (bpp == 8)
#endif
}
{
int iPreferredVideoMode = 0;
int cNumVideoModes = 0;
int cModesTable = *pcVideoModes;
int rc = VINF_SUCCESS;
/* the resolution matrix */
struct
{
} resolutionMatrix[] =
{
/* standard modes */
{ 640, 480 },
{ 800, 600 },
{ 1024, 768 },
{ 1152, 864 },
{ 1280, 960 },
{ 1280, 1024 },
{ 1400, 1050 },
{ 1600, 1200 },
{ 1920, 1440 },
#ifndef VBOX_WITH_WDDM
/* multi screen modes with 1280x1024 */
{ 2560, 1024 },
{ 3840, 1024 },
{ 5120, 1024 },
/* multi screen modes with 1600x1200 */
{ 3200, 1200 },
{ 4800, 1200 },
{ 6400, 1200 },
#endif
};
/* there are 4 color depths: 8, 16, 24 and 32bpp and we reserve 50% of the modes for other sources */
/* size of the VRAM in bytes */
#ifndef VBOX_WITH_WDDM
#else
/* at least two surfaces will be needed: primary & shadow */
#endif
do
{
/* Always add 800x600 video modes. Windows XP+ needs at least 800x600 resolution
* and fallbacks to 800x600x4bpp VGA mode if the driver did not report suitable modes.
* This resolution could be rejected by a low resolution host (netbooks, etc).
*/
int cBytesPerPixel;
{
#ifndef VBOX_WITH_8BPP_MODES
if (cBitsPerPixel == 8)
{
continue;
}
#endif /* !VBOX_WITH_8BPP_MODES */
/* does the mode fit into the VRAM? */
{
continue;
}
if (cModesTable <= cNumVideoModes)
{
break;
}
switch (cBytesPerPixel)
{
case 1:
{
VideoModes[cNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN |
} break;
case 2:
{
VideoModes[cNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
} break;
case 3:
{
VideoModes[cNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
} break;
default:
case 4:
{
VideoModes[cNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
} break;
}
/* a new mode has been filled in */
}
if (RT_FAILURE(rc))
break;
/*
* Query the y-offset from the host
*/
#ifdef VBOX_WITH_8BPP_MODES
/*
* 8 bit video modes
*/
matrixIndex = 0;
{
/* are there any modes left in the matrix? */
if (matrixIndex >= matrixSize)
break;
/* does the mode fit into the VRAM? */
{
++matrixIndex;
continue;
}
if (yOffset == 0 && resolutionMatrix[matrixIndex].xRes == 800 && resolutionMatrix[matrixIndex].yRes == 600)
{
/* This mode was already added. */
++matrixIndex;
continue;
}
/* does the host like that mode? */
if (!vboxLikesVideoMode(iDisplay, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 8))
{
++matrixIndex;
continue;
}
if (cModesTable <= cNumVideoModes)
{
break;
}
VideoModes[cNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN |
/* a new mode has been filled in */
/* advance to the next mode matrix entry */
++matrixIndex;
}
if (RT_FAILURE(rc))
break;
#endif /* VBOX_WITH_8BPP_MODES */
/*
* 16 bit video modes
*/
matrixIndex = 0;
{
/* are there any modes left in the matrix? */
if (matrixIndex >= matrixSize)
break;
/* does the mode fit into the VRAM? */
{
++matrixIndex;
continue;
}
if (yOffset == 0 && resolutionMatrix[matrixIndex].xRes == 800 && resolutionMatrix[matrixIndex].yRes == 600)
{
/* This mode was already added. */
++matrixIndex;
continue;
}
/* does the host like that mode? */
if (!vboxLikesVideoMode(iDisplay, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 16))
{
++matrixIndex;
continue;
}
if (cModesTable <= cNumVideoModes)
{
break;
}
VideoModes[cNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
/* a new mode has been filled in */
/* advance to the next mode matrix entry */
++matrixIndex;
}
if (RT_FAILURE(rc))
break;
/*
* 24 bit video modes
*/
matrixIndex = 0;
{
/* are there any modes left in the matrix? */
if (matrixIndex >= matrixSize)
break;
/* does the mode fit into the VRAM? */
{
++matrixIndex;
continue;
}
if (yOffset == 0 && resolutionMatrix[matrixIndex].xRes == 800 && resolutionMatrix[matrixIndex].yRes == 600)
{
/* This mode was already added. */
++matrixIndex;
continue;
}
/* does the host like that mode? */
if (!vboxLikesVideoMode(iDisplay, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 24))
{
++matrixIndex;
continue;
}
if (cModesTable <= cNumVideoModes)
{
break;
}
VideoModes[cNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
/* a new mode has been filled in */
/* advance to the next mode matrix entry */
++matrixIndex;
}
if (RT_FAILURE(rc))
break;
/*
* 32 bit video modes
*/
matrixIndex = 0;
{
/* are there any modes left in the matrix? */
if (matrixIndex >= matrixSize)
break;
/* does the mode fit into the VRAM? */
{
++matrixIndex;
continue;
}
if (yOffset == 0 && resolutionMatrix[matrixIndex].xRes == 800 && resolutionMatrix[matrixIndex].yRes == 600)
{
/* This mode was already added. */
++matrixIndex;
continue;
}
/* does the host like that mode? */
if (!vboxLikesVideoMode(iDisplay, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 32))
{
++matrixIndex;
continue;
}
if (cModesTable <= cNumVideoModes)
{
break;
}
VideoModes[cNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
/* a new mode has been filled in */
/* advance to the next mode matrix entry */
++matrixIndex;
}
if (RT_FAILURE(rc))
break;
/*
* Next, check the registry for additional modes
*/
int curKeyNo = 0;
int fPreferredSet = 0;
do
{
wchar_t keyname[24];
/* upon the first error, we give up */
break;
/* upon the first error, we give up */
break;
/* upon the first error, we give up */
break;
dprintf(("VBoxVideo: custom mode %u returned: xres = %u, yres = %u, bpp = %u\n",
/* first test: do the values make sense? */
|| ( (bpp != 16)
&& (bpp != 24)
&& (bpp != 32)))
break;
/* round down width to be a multiple of 8 if necessary */
if (!DeviceExtension->fAnyX)
xres &= 0xFFF8;
/* second test: does it fit within our VRAM? */
break;
/* third test: does the host like the video mode? */
break;
if (cModesTable <= cNumVideoModes)
{
break;
}
dprintf(("VBoxVideo: adding mode from registry: xres = %d, yres = %d, bpp = %d\n", xres, yres, bpp));
if (!fPreferredSet)
{
fPreferredSet = 1;
}
/*
* Build mode entry.
* Note that we have to apply the y offset for the custom mode.
*/
switch (bpp)
{
case 16:
break;
case 24:
break;
case 32:
/* 32-bit mode is more preferable, select it if not yet */
if (fPreferredSet < 2)
{
fPreferredSet = 2;
}
break;
}
VideoModes[cNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
/* next run */
curKeyNo++;
/* only support 128 modes for now */
if (curKeyNo >= 128)
break;
} while(1);
if (RT_FAILURE(rc))
break;
/*
* Now we ask the host for a display change request. If there's one,
* this will be appended as a special mode so that it can be used by
* the Additions service process. The mode table is guaranteed to have
* two spare entries for this mode (alternating index thus 2).
*
* ... or ...
*
* Also we check if we got an user-stored custom resolution in the adapter
* registry key add it to the modes table.
*/
/* Add custom resolutions for each display and then for the display change request, if exists.
*/
/* check if the mode is verified */
{
/* the mode is loaded from registry and not verified yet */
{
}
}
{
if (cModesTable <= cNumVideoModes)
{
break;
}
{
if (cModesTable <= cNumVideoModes)
{
break;
}
{
i /* bpp*/ ,
cNumVideoModes /* index*/,
0 /* yoffset*/);
}
}
}
} while(0);
return rc;
}
#else /* if !(defined VBOX_WITH_GENERIC_MULTIMONITOR) */
/*
* Global list of supported standard video modes. It will be
* filled dynamically.
*/
#define MAX_VIDEO_MODES 128
/*
* Additional space is reserved for custom video modes for 64 guest monitors.
* The custom video mode index is alternating and 2 indexes are reserved for the last custom mode.
*/
/*
* The last custom resolution set for each display. This is important
* for system startup so that we report the last currently set
* custom resolution and Windows can use it again.
* On the driver startup this is initialized from registry.
*/
/* number of available video modes, set by VBoxBuildModesTable */
static uint32_t gNumVideoModes = 0;
/* Remember which video mode was not set because there was no enough VRAM.
* So repeated entries will be not written to the guest log.
*/
/**
* Helper function to dynamically build our table of standard video
* modes. We take the amount of VRAM and create modes with standard
* geometries until we've either reached the maximum number of modes
* or the available VRAM does not allow for additional modes.
*/
{
/* we need this static counter to always have a new mode index for our */
/* custom video mode, otherwise Windows thinks there is no mode switch */
static int gInvocationCounter = 0;
/* the resolution matrix */
struct
{
} resolutionMatrix[] =
{
/* standard modes */
{ 640, 480 },
{ 800, 600 },
{ 1024, 768 },
{ 1152, 864 },
{ 1280, 960 },
{ 1280, 1024 },
{ 1400, 1050 },
{ 1600, 1200 },
{ 1920, 1440 },
#ifndef VBOX_WITH_WDDM
/* multi screen modes with 1280x1024 */
{ 2560, 1024 },
{ 3840, 1024 },
{ 5120, 1024 },
/* multi screen modes with 1600x1200 */
{ 3200, 1200 },
{ 4800, 1200 },
{ 6400, 1200 },
#endif
};
/* there are 4 color depths: 8, 16, 24 and 32bpp and we reserve 50% of the modes for other sources */
/* size of the VRAM in bytes */
#ifndef VBOX_WITH_WDDM
#else
/* at least two surfaces will be needed: primary & shadow */
gPreferredVideoMode = 0;
#endif
gNumVideoModes = 0;
/* Always add 800x600 video modes. Windows XP+ needs at least 800x600 resolution
* and fallbacks to 800x600x4bpp VGA mode if the driver did not report suitable modes.
* This resolution could be rejected by a low resolution host (netbooks, etc).
*/
int cBytesPerPixel;
{
#ifndef VBOX_WITH_8BPP_MODES
if (cBitsPerPixel == 8)
{
continue;
}
#endif /* !VBOX_WITH_8BPP_MODES */
/* does the mode fit into the VRAM? */
{
continue;
}
switch (cBytesPerPixel)
{
case 1:
{
VideoModes[gNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN |
} break;
case 2:
{
VideoModes[gNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
} break;
case 3:
{
VideoModes[gNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
} break;
default:
case 4:
{
VideoModes[gNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
#ifdef VBOX_WITH_WDDM
#endif
} break;
}
/* a new mode has been filled in */
}
/*
* Query the y-offset from the host
*/
#ifdef VBOX_WITH_8BPP_MODES
/*
* 8 bit video modes
*/
matrixIndex = 0;
{
/* are there any modes left in the matrix? */
if (matrixIndex >= matrixSize)
break;
/* does the mode fit into the VRAM? */
{
++matrixIndex;
continue;
}
if (yOffset == 0 && resolutionMatrix[matrixIndex].xRes == 800 && resolutionMatrix[matrixIndex].yRes == 600)
{
/* This mode was already added. */
++matrixIndex;
continue;
}
/* does the host like that mode? */
#ifndef VBOX_WITH_WDDM
if (!vboxLikesVideoMode(DeviceExtension->iDevice, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 8))
#else
if (!vboxLikesVideoMode(0 /* @todo: */, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 8))
#endif
{
++matrixIndex;
continue;
}
VideoModes[gNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN |
/* a new mode has been filled in */
/* advance to the next mode matrix entry */
++matrixIndex;
}
#endif /* VBOX_WITH_8BPP_MODES */
/*
* 16 bit video modes
*/
matrixIndex = 0;
{
/* are there any modes left in the matrix? */
if (matrixIndex >= matrixSize)
break;
/* does the mode fit into the VRAM? */
{
++matrixIndex;
continue;
}
if (yOffset == 0 && resolutionMatrix[matrixIndex].xRes == 800 && resolutionMatrix[matrixIndex].yRes == 600)
{
/* This mode was already added. */
++matrixIndex;
continue;
}
/* does the host like that mode? */
#ifndef VBOX_WITH_WDDM
if (!vboxLikesVideoMode(DeviceExtension->iDevice, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 16))
#else
if (!vboxLikesVideoMode(0 /* @todo: */, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 16))
#endif
{
++matrixIndex;
continue;
}
VideoModes[gNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
/* a new mode has been filled in */
/* advance to the next mode matrix entry */
++matrixIndex;
}
/*
* 24 bit video modes
*/
matrixIndex = 0;
{
/* are there any modes left in the matrix? */
if (matrixIndex >= matrixSize)
break;
/* does the mode fit into the VRAM? */
{
++matrixIndex;
continue;
}
if (yOffset == 0 && resolutionMatrix[matrixIndex].xRes == 800 && resolutionMatrix[matrixIndex].yRes == 600)
{
/* This mode was already added. */
++matrixIndex;
continue;
}
/* does the host like that mode? */
#ifndef VBOX_WITH_WDDM
if (!vboxLikesVideoMode(DeviceExtension->iDevice, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 24))
#else
if (!vboxLikesVideoMode(0, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 24))
#endif
{
++matrixIndex;
continue;
}
VideoModes[gNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
/* a new mode has been filled in */
/* advance to the next mode matrix entry */
++matrixIndex;
}
/*
* 32 bit video modes
*/
matrixIndex = 0;
{
/* are there any modes left in the matrix? */
if (matrixIndex >= matrixSize)
break;
/* does the mode fit into the VRAM? */
{
++matrixIndex;
continue;
}
if (yOffset == 0 && resolutionMatrix[matrixIndex].xRes == 800 && resolutionMatrix[matrixIndex].yRes == 600)
{
/* This mode was already added. */
++matrixIndex;
continue;
}
/* does the host like that mode? */
#ifndef VBOX_WITH_WDDM
if (!vboxLikesVideoMode(DeviceExtension->iDevice, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 32))
#else
if (!vboxLikesVideoMode(0, resolutionMatrix[matrixIndex].xRes, resolutionMatrix[matrixIndex].yRes - yOffset, 32))
#endif
{
++matrixIndex;
continue;
}
VideoModes[gNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
/* a new mode has been filled in */
/* advance to the next mode matrix entry */
++matrixIndex;
}
/*
* Next, check the registry for additional modes
*/
int curKeyNo = 0;
#ifdef VBOX_WITH_WDDM
int fPreferredSet = 0;
#endif
do
{
/* check if there is space in the mode list */
if (gNumVideoModes >= MAX_VIDEO_MODES)
break;
wchar_t keyname[24];
/* upon the first error, we give up */
break;
/* upon the first error, we give up */
break;
/* upon the first error, we give up */
break;
dprintf(("VBoxVideo: custom mode %u returned: xres = %u, yres = %u, bpp = %u\n",
/* first test: do the values make sense? */
|| ( (bpp != 16)
&& (bpp != 24)
&& (bpp != 32)))
break;
/* round down width to be a multiple of 8 if necessary */
if (!DeviceExtension->fAnyX)
xres &= 0xFFF8;
/* second test: does it fit within our VRAM? */
break;
/* third test: does the host like the video mode? */
#ifndef VBOX_WITH_WDDM
#else
#endif
break;
dprintf(("VBoxVideo: adding mode from registry: xres = %d, yres = %d, bpp = %d\n", xres, yres, bpp));
#ifdef VBOX_WITH_WDDM
if (!fPreferredSet)
{
fPreferredSet = 1;
}
#endif
/*
* Build mode entry.
* Note that we have to apply the y offset for the custom mode.
*/
switch (bpp)
{
case 16:
break;
case 24:
break;
case 32:
#ifdef VBOX_WITH_WDDM
/* 32-bit mode is more preferable, select it if not yet */
if (fPreferredSet < 2)
{
fPreferredSet = 2;
}
#endif
break;
}
VideoModes[gNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
/* next run */
curKeyNo++;
/* only support 128 modes for now */
if (curKeyNo >= 128)
break;
} while(1);
/*
* Now we ask the host for a display change request. If there's one,
* this will be appended as a special mode so that it can be used by
* the Additions service process. The mode table is guaranteed to have
* two spare entries for this mode (alternating index thus 2).
*
* ... or ...
*
* Also we check if we got an user-stored custom resolution in the adapter
* registry key add it to the modes table.
*/
/* Add custom resolutions for each display and then for the display change request, if exists.
*/
{
/* There is a pending display change request. */
}
{
}
{
/* No need to go through the custom mode logic. And no need to clear the custom mode
* entry in the next 'for' loop.
*/
}
/*
* Reinsert custom video modes for all displays.
*/
int iCustomMode;
{
{
/* Do not keep info for this display, which received a video mode hint, to make sure that
* the new mode will be taken from the alternating index entries actually.
*/
}
else
{
}
#ifdef LOG_ENABLED
dprintf(("Custom mode for %2d: %4d x %4d @ %2d\n",
#endif
}
{
/* The display change is for another monitor. Just add 2 standard modes to the table
* to make enough entries. This is not necessary if it is a first mode set (CurrentMode == 0),
* because these 2 entries will be added by "if (fDisplayChangeRequest || DeviceExtension->CurrentMode == 0)"
* code branch.
*/
if (DeviceExtension->CurrentMode != 0)
{
dprintf(("Filling custom mode entries.\n"));
}
}
{
#ifndef VBOX_WITH_WDDM
dprintf(("VBoxVideo: adding custom video mode as #%d, current mode: %d \n", gNumVideoModes + 1, DeviceExtension->CurrentMode));
/* handle the startup case */
if (DeviceExtension->CurrentMode == 0)
#else
if (!commonFromDeviceExt(DeviceExtension)->cDisplays || !DeviceExtension->aSources[0].pPrimaryAllocation)
#endif
{
/* Use the stored custom resolution values only if nothing was read from host.
* The custom mode might be not valid anymore and would block any hints from host.
*/
if (!xres)
if (!yres)
if (!bpp)
dprintf(("VBoxVideo: using stored custom resolution %dx%dx%d for %d\n", xres, yres, bpp, DeviceExtension->iDevice));
}
/* round down to multiple of 8 if necessary */
if (!DeviceExtension->fAnyX) {
xres &= 0xfff8;
}
/* take the current values for the fields that are not set */
#ifndef VBOX_WITH_WDDM
if (DeviceExtension->CurrentMode != 0)
{
if (!xres)
if (!yres)
if (!bpp)
}
#else
if (commonFromDeviceExt(DeviceExtension)->cDisplays && DeviceExtension->aSources[0].pPrimaryAllocation)
{
if (!xres)
if (!yres)
if (!bpp)
}
#endif
/* Use a default value. */
if (!bpp)
bpp = 32;
/* does the host like that mode? */
#ifndef VBOX_WITH_WDDM
#else
#endif
{
/* we must have a valid video mode by now and it must fit within the VRAM */
if ( ( xres
&& yres
&& ( (bpp == 16)
#ifdef VBOX_WITH_8BPP_MODES
|| (bpp == 8)
#endif
|| (bpp == 24)
|| (bpp == 32)))
{
/* We need an alternating index so the guest will recognoize the mode as a new one.
* However only alternate index if the new custom mode differs from the last one
* (only resolution and bpp changes are important, a display change does not matter).
* Always add 2 last entries to the mode array, so number of video modes
* do not change.
*/
static uint32_t sPrev_xres = 0;
static uint32_t sPrev_yres = 0;
if ( sPrev_xres != xres
|| sPrev_yres != yres
{
sPrev_xres = xres;
sPrev_yres = yres;
}
#ifndef VBOX_WITH_WDDM
if (DeviceExtension->CurrentMode != 0)
#else
if (commonFromDeviceExt(DeviceExtension)->cDisplays && DeviceExtension->aSources[0].pPrimaryAllocation)
#endif
{
if (fNewInvocation)
if (gInvocationCounter % 2)
{
}
}
else
{
}
dprintf(("VBoxVideo: setting special mode to xres = %d, yres = %d, bpp = %d, display = %d\n", xres, yres, bpp, display));
dprintf(("VBoxVideo: fNewInvocation = %d, fAlternatedIndex = %d\n", fNewInvocation, fAlternatedIndex));
#ifdef VBOX_WITH_WDDM
/* assign host-supplied as the most preferable */
#endif
/*
* Build mode entry.
* Note that we do not apply the y offset for the custom mode. It is
* only used for the predefined modes that the user can configure in
* the display properties dialog.
*/
switch (bpp)
{
#ifdef VBOX_WITH_8BPP_MODES
case 8:
break;
#endif
case 16:
break;
case 24:
break;
case 32:
break;
}
VideoModes[gNumVideoModes].AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN;
#ifdef VBOX_WITH_8BPP_MODES
if (bpp == 8)
VideoModes[gNumVideoModes].AttributeFlags |= VIDEO_MODE_PALETTE_DRIVEN | VIDEO_MODE_MANAGED_PALETTE;
#endif
/* Save the mode in the list of custom modes for this display. */
/* for the startup case, we need this mode twice due to the alternating mode number */
#ifndef VBOX_WITH_WDDM
if (DeviceExtension->CurrentMode == 0)
#else
if (!commonFromDeviceExt(DeviceExtension)->cDisplays || !DeviceExtension->aSources[0].pPrimaryAllocation)
#endif
{
memcpy(&VideoModes[gNumVideoModes], &VideoModes[gNumVideoModes - 1], sizeof(VIDEO_MODE_INFORMATION));
}
else if (!fAlternatedIndex)
{
}
/* Save the custom mode for this display. */
if (DeviceExtension->iDevice == 0)
{
/* Name without a suffix */
}
else
{
wchar_t keyname[32];
}
}
else
{
dprintf(("VBoxVideo: invalid parameters for special mode: (xres = %d, yres = %d, bpp = %d, vramSize = %d)\n",
{
LogRel(("VBoxVideo: not enough VRAM for video mode %dx%dx%dbpp. Available: %d bytes. Required: more than %d bytes.\n",
g_xresNoVRAM = xres;
g_yresNoVRAM = yres;
g_bppNoVRAM = bpp;
}
}
}
else
dprintf(("VBoxVideo: host does not like special mode: (xres = %d, yres = %d, bpp = %d)\n",
}
#if defined(LOG_ENABLED)
{
int i;
#ifndef VBOX_WITH_WDDM
dprintf(("VBoxVideo: VideoModes (CurrentMode = %d, last #%d)\n", DeviceExtension->CurrentMode, gNumVideoModes));
#endif
for (i = 0; i < RT_ELEMENTS(VideoModes); i++)
{
if ( VideoModes[i].VisScreenWidth
|| VideoModes[i].VisScreenHeight
|| VideoModes[i].BitsPerPlane)
{
dprintf((" %2d: #%d %4d x %4d @ %2d\n",
}
}
}
#endif
#ifdef VBOX_WITH_WDDM
#endif
}
#endif
#ifdef VBOX_WITH_WDDM
/**
* Helper function to dynamically build our table of standard video
* modes. We take the amount of VRAM and create modes with standard
* geometries until we've either reached the maximum number of modes
* or the available VRAM does not allow for additional modes.
*/
static VOID vboxWddmBuildVideoModesInfo(PDEVICE_EXTENSION DeviceExtension, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId,
{
vboxVideoBuildModesTable(DeviceExtension, VidPnTargetId, pModes->aModes, &pModes->cModes, &pModes->iPreferredMode);
for (UINT i = 0; i < cAddlModes; ++i)
{
{
int iDx = vboxVideoModeAdd(pModes->aModes, RT_ELEMENTS(pModes->aModes), &pModes->cModes, &paAddlModes[i]);
if (iDx >= 0)
}
}
#if 0
{
{
w += 8;
h += 8;
{
}
else
{
Assert(0);
}
}
}
#endif
vboxVideoBuildResolutionTable(pModes->aModes, pModes->cModes, (SIZE*)((void*)pModes->aResolutions), &pModes->cResolutions);
}
NTSTATUS vboxWddmGetModesForResolution(VIDEO_MODE_INFORMATION *pAllModes, uint32_t cAllModes, int iSearchPreferredMode,
const D3DKMDT_2DREGION *pResolution, VIDEO_MODE_INFORMATION * pModes, uint32_t cModes, uint32_t *pcModes, int32_t *piPreferrableMode)
{
int iFoundPreferrableMode = -1;
{
{
else
if (i == iSearchPreferredMode)
++cFound;
}
}
if (piPreferrableMode)
return Status;
}
int vboxWddmVideoResolutionFind(const D3DKMDT_2DREGION *pResolutions, int cResolutions, const D3DKMDT_2DREGION *pRes)
{
for (int i = 0; i < cResolutions; ++i)
{
return i;
}
return -1;
}
bool vboxWddmVideoResolutionsMatch(const D3DKMDT_2DREGION *pResolutions1, const D3DKMDT_2DREGION *pResolutions2, int cResolutions)
{
for (int i = 0; i < cResolutions; ++i)
{
int j = 0;
for (;j < cResolutions; ++j)
{
break;
}
if (j == cResolutions)
{
return false;
}
}
return true;
}
bool vboxWddmVideoModesMatch(const VIDEO_MODE_INFORMATION *pModes1, const VIDEO_MODE_INFORMATION *pModes2, int cModes)
{
for (int i = 0; i < cModes; ++i)
{
int j = 0;
for (;j < cModes; ++j)
{
break;
}
if (j == cModes)
{
return false;
}
}
return true;
}
{
switch (pInfo->BitsPerPlane)
{
case 32:
if(!(pInfo->AttributeFlags & VIDEO_MODE_PALETTE_DRIVEN) && !(pInfo->AttributeFlags & VIDEO_MODE_MANAGED_PALETTE))
{
return D3DDDIFMT_A8R8G8B8;
drprintf((__FUNCTION__": unsupported format: bpp(%d), rmask(%d), gmask(%d), bmask(%d)\n", pInfo->BitsPerPlane, pInfo->RedMask, pInfo->GreenMask, pInfo->BlueMask));
}
else
{
}
break;
case 24:
if(!(pInfo->AttributeFlags & VIDEO_MODE_PALETTE_DRIVEN) && !(pInfo->AttributeFlags & VIDEO_MODE_MANAGED_PALETTE))
{
return D3DDDIFMT_R8G8B8;
drprintf((__FUNCTION__": unsupported format: bpp(%d), rmask(%d), gmask(%d), bmask(%d)\n", pInfo->BitsPerPlane, pInfo->RedMask, pInfo->GreenMask, pInfo->BlueMask));
}
else
{
}
break;
case 16:
if(!(pInfo->AttributeFlags & VIDEO_MODE_PALETTE_DRIVEN) && !(pInfo->AttributeFlags & VIDEO_MODE_MANAGED_PALETTE))
{
return D3DDDIFMT_R5G6B5;
drprintf((__FUNCTION__": unsupported format: bpp(%d), rmask(%d), gmask(%d), bmask(%d)\n", pInfo->BitsPerPlane, pInfo->RedMask, pInfo->GreenMask, pInfo->BlueMask));
}
else
{
}
break;
case 8:
if((pInfo->AttributeFlags & VIDEO_MODE_PALETTE_DRIVEN) && (pInfo->AttributeFlags & VIDEO_MODE_MANAGED_PALETTE))
{
return D3DDDIFMT_P8;
}
else
{
}
break;
default:
break;
}
return D3DDDIFMT_UNKNOWN;
}
{
pInfo->VisScreenWidth = w;
pInfo->VisScreenHeight = h;
pInfo->VideoMemoryBitmapWidth = w;
pInfo->VideoMemoryBitmapHeight = h;
switch (enmFormat)
{
case D3DDDIFMT_A8R8G8B8:
return true;
case D3DDDIFMT_R8G8B8:
return true;
case D3DDDIFMT_R5G6B5:
return true;
case D3DDDIFMT_P8:
pInfo->AttributeFlags = VIDEO_MODE_GRAPHICS | VIDEO_MODE_COLOR | VIDEO_MODE_NO_OFF_SCREEN | VIDEO_MODE_PALETTE_DRIVEN | VIDEO_MODE_MANAGED_PALETTE;
return true;
default:
break;
}
return false;
}
PVBOXWDDM_VIDEOMODES_INFO vboxWddmGetVideoModesInfo(PDEVICE_EXTENSION DeviceExtension, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
{
Assert(VidPnTargetId < (D3DDDI_VIDEO_PRESENT_TARGET_ID)commonFromDeviceExt(DeviceExtension)->cDisplays);
if (VidPnTargetId >= (D3DDDI_VIDEO_PRESENT_TARGET_ID)commonFromDeviceExt(DeviceExtension)->cDisplays)
{
return NULL;
}
{
}
return pInfo;
}
{
/* ensure all modes are initialized */
{
}
return g_aVBoxVideoModeInfos;
}
{
{
g_aVBoxVideoModeInfos[i].cModes = 0;
}
}
PVBOXWDDM_VIDEOMODES_INFO vboxWddmUpdateVideoModesInfo(PDEVICE_EXTENSION DeviceExtension, PVBOXWDDM_RECOMMENDVIDPN pVidPnInfo)
{
if (pVidPnInfo)
{
{
{
VIDEO_MODE_INFORMATION ModeInfo = {0};
switch (pScreenInfo->BitsPerPixel)
{
case 32:
break;
case 24:
break;
case 16:
break;
case 8:
break;
default:
Assert(0);
break;
}
if (enmFormat != D3DDDIFMT_UNKNOWN)
{
{
}
else
{
Assert(0);
}
}
}
}
}
/* ensure we have all the rest populated */
return g_aVBoxVideoModeInfos;
}
#else
/* Computes the size of a framebuffer. DualView has a few framebuffers of the computed size. */
{
/* Size of a framebuffer. */
/* Align down to 4096 bytes. */
ulSize &= ~0xFFF;
dprintf(("VBoxVideo::VBoxComputeFrameBufferSizes: cbVRAM = 0x%08X, cDisplays = %d, ulSize = 0x%08X, ulSize * cDisplays = 0x%08X, slack = 0x%08X\n",
/* Update the primary info. */
/* Update the per extension info. */
ULONG ulFrameBufferOffset = 0;
while (Extension)
{
/* That is assigned when a video mode is set. */
Extension->ulFrameBufferSize = 0;
dprintf(("VBoxVideo::VBoxComputeFrameBufferSizes: [%d] ulFrameBufferOffset 0x%08X\n",
}
}
#endif
int VBoxMapAdapterMemory (PVBOXVIDEO_COMMON pCommon, void **ppv, uint32_t ulOffset, uint32_t ulSize)
{
if (!ulSize)
{
dprintf(("Illegal length 0!\n"));
return ERROR_INVALID_PARAMETER;
}
#ifndef VBOX_WITH_WDDM
&VideoRamBase);
#else
NTSTATUS ntStatus = PrimaryExtension->u.primary.DxgkInterface.DxgkCbMapMemory(PrimaryExtension->u.primary.DxgkInterface.DeviceHandle,
FALSE, /* IN BOOLEAN InIoSpace */
FALSE, /* IN BOOLEAN MapToUserMode */
MmNonCached, /* IN MEMORY_CACHING_TYPE CacheType */
&VideoRamBase /*OUT PVOID *VirtualAddress*/
);
Status = ntStatus == STATUS_SUCCESS ? NO_ERROR : ERROR_INVALID_PARAMETER; /*<- this is what VideoPortMapMemory returns according to the docs */
#endif
{
*ppv = VideoRamBase;
}
return Status;
}
void *pvUser)
{
#ifndef VBOX_WITH_WDDM
#else
return !!fRet;
#endif
}
{
dprintf(("VBoxVideo::VBoxUnmapAdapterMemory\n"));
if (*ppv)
{
#ifndef VBOX_WITH_WDDM
#else
NTSTATUS ntStatus = PrimaryExtension->u.primary.DxgkInterface.DxgkCbUnmapMemory(PrimaryExtension->u.primary.DxgkInterface.DeviceHandle,
*ppv);
#endif
}
}
{
dprintf(("VBoxVideo::vboxVideoInitCustomVideoModes\n"));
/* Initialize all custom modes to the 800x600x32. */
int iCustomMode;
{
}
/* Load stored custom resolution from the registry. */
for (iCustomMode = 0;
#ifdef VBOX_WITH_WDDM
#else
#endif
iCustomMode++)
{
/*
* Get the last custom resolution
*/
if (iCustomMode == 0)
{
/* Name without a suffix */
CustomXRes = 0;
CustomYRes = 0;
CustomBPP = 0;
}
else
{
wchar_t keyname[32];
CustomXRes = 0;
CustomYRes = 0;
CustomBPP = 0;
}
dprintf(("VBoxVideo: got stored custom resolution[%d] %dx%dx%d\n", iCustomMode, CustomXRes, CustomYRes, CustomBPP));
{
if (CustomXRes == 0)
{
}
if (CustomYRes == 0)
{
}
if (CustomBPP == 0)
{
}
}
}
}
#ifndef VBOX_WITH_WDDM
{
unsigned i;
{
/* How much VRAM should be reserved for the guest drivers to use VBVA. */
p[i].u32ViewSize - cbReservedVRAM:
0;
}
{
return VINF_SUCCESS;
}
AssertFailed ();
return VERR_INTERNAL_ERROR;
}
{
{
/* Dynamically query the VideoPort import to be binary compatible across Windows versions */
if (vboxQueryWinVersion() > WINNT4)
{
/* This bluescreens on NT4, hence the above version check */
(PUCHAR)"VideoPortCreateSecondaryDisplay");
}
else
{
{
rc = pfnCreateSecondaryDisplay (PrimaryExtension, (PVOID*)&SecondaryExtension, VIDEO_DUALVIEW_REMOVABLE);
dprintf(("VBoxVideo::VBoxSetupDisplays: VideoPortCreateSecondaryDisplay returned %#x, SecondaryExtension = %p\n",
rc, SecondaryExtension));
{
break;
}
/* Update the list pointers. */
/* Take the successfully created display into account. */
}
}
/* Failure to create secondary displays is not fatal */
}
/* Now when the number of monitors is known and extensions are created,
* calculate the layout of framebuffers.
*/
/* in case of WDDM we do not control the framebuffer location,
* i.e. it is assigned by Video Memory Manager,
* The FB information should be passed to guest from our
* DxgkDdiSetVidPnSourceAddress callback */
{
if (RT_SUCCESS(rc))
{
(void *) PrimaryExtension);
}
if (RT_FAILURE (rc))
{
}
}
}
{
VBoxSetupVideoPortFunctions((PDEVICE_EXTENSION)HwDeviceExtension, &((PDEVICE_EXTENSION)HwDeviceExtension)->u.primary.VideoPortProcs, ConfigInfo);
if (DispiId == VBE_DISPI_ID2)
{
dprintf(("VBoxVideo::VBoxVideoFoundAdapter: found the VBE card\n"));
/*
* Write some hardware information to registry, so that
* it's visible in Windows property dialog.
*/
L"HardwareInformation.ChipType",
sizeof(VBoxChipType));
L"HardwareInformation.DacType",
sizeof(VBoxDACType));
/*
* Query the adapter's memory size. It's a bit of a hack, we just read
* an ULONG from the data port without setting an index before.
*/
L"HardwareInformation.MemorySize",
sizeof(ULONG));
L"HardwareInformation.AdapterString",
sizeof(VBoxAdapterString));
L"HardwareInformation.BiosString",
sizeof(VBoxBiosString));
dprintf(("VBoxVideo::VBoxVideoFindAdapter: calling VideoPortGetAccessRanges\n"));
/* need to call VideoPortGetAccessRanges to ensure interrupt info in ConfigInfo gets set up */
if (vboxQueryWinVersion() == WINNT4)
{
/* NT crashes if either of 'vendorId, 'deviceId' or 'slot' parameters is NULL,
* and needs PCI ids for a successful VideoPortGetAccessRanges call.
*/
0,
NULL,
&vendorId,
&deviceId,
&slot);
}
else
{
0,
NULL,
NULL,
NULL,
&slot);
}
/* Initialize VBoxGuest library, which is used for requests which go through VMMDev. */
/* Preinitialize the primary extension.
*/
/* Guest supports only HGSMI, the old VBVA via VMMDev is not supported. Old
* code will be ifdef'ed and later removed.
* The host will however support both old and new interface to keep compatibility
* with old guest additions.
*/
AdapterMemorySize, 0);
{
LogRel(("VBoxVideo: using HGSMI\n"));
}
// pretend success to make the driver work.
} else
{
dprintf(("VBoxVideo::VBoxVideoFindAdapter: VBE card not found, returning ERROR_DEV_NOT_EXIST\n"));
}
return rc;
}
/**
* VBoxVideoInitialize
*
* Performs the first initialization of the adapter, after the HAL has given
* up control of the video hardware to the video port driver.
*/
{
dprintf(("VBoxVideo::VBoxVideoInitialize\n"));
/* Initialize the request pointer. */
/* Check if the chip restricts horizontal resolution or not. */
if (DispiId == VBE_DISPI_ID_ANYX)
else
return TRUE;
}
# ifdef VBOX_WITH_VIDEOHWACCEL
static VOID VBoxVideoHGSMIDpc(
)
{
}
{
if (PrimaryExtension)
{
{
if((flags & HGSMIHOSTFLAGS_IRQ) != 0)
{
if((flags & HGSMIHOSTFLAGS_COMMANDS_PENDING) != 0)
{
/* schedule a DPC*/
BOOLEAN bResult = PrimaryExtension->u.primary.VideoPortProcs.pfnQueueDpc(PrimaryExtension, VBoxVideoHGSMIDpc, NULL);
}
/* clear the IRQ */
return TRUE;
}
}
}
return FALSE;
}
# endif /* #ifdef VBOX_WITH_VIDEOHWACCEL */
#endif /* #ifndef VBOX_WITH_WDDM */
/**
* Send a request to the host to make the absolute pointer visible
*/
{
/* Use primary device extension, because the show pointer request should be processed
* in vboxUpdatePointerShape regardless of the device. */
#ifndef VBOX_WITH_WDDM
#else
#endif
{
// tell the host to use the guest's pointer
/* Visible and No Shape means Show the pointer.
* It is enough to init only this field.
*/
Result = vboxUpdatePointerShapeWrap(commonFromDeviceExt(PrimaryExtension), &PointerAttributes, sizeof (PointerAttributes));
if (Result)
else
dprintf(("VBoxVideo::ShowPointer: Could not show the hardware pointer -> fallback\n"));
}
return Result;
}
#ifndef VBOX_WITH_WDDM
/**
* VBoxVideoStartIO
*
* Processes the specified Video Request Packet.
*/
{
// dprintf(("VBoxVideo::VBoxVideoStartIO: Code %08X\n", RequestPacket->IoControlCode));
switch (RequestPacket->IoControlCode)
{
{
{
return TRUE;
}
break;
}
case IOCTL_VIDEO_RESET_DEVICE:
{
break;
}
{
{
return TRUE;
}
break;
}
{
{
return TRUE;
}
break;
}
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_SHARE_VIDEO_MEMORY\n"));
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_SHARE_VIDEO_MEMORY: ERROR_INSUFFICIENT_BUFFER\n"));
break;
}
|| ((pShareMemory->ViewOffset + pShareMemory->ViewSize) > pDevExt->pPrimary->u.primary.ulMaxFrameBufferSize) ) {
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_SHARE_VIDEO_MEMORY - ERROR_INVALID_PARAMETER %x:%x size %x\n", pShareMemory->ViewOffset, pShareMemory->ViewSize, pDevExt->pPrimary->u.primary.ulMaxFrameBufferSize));
break;
}
status = VideoPortMapMemory(HwDeviceExtension, shareAddress, &sharedViewSize, &inIoSpace, &virtualAddress);
break;
}
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY\n"));
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY: ERROR_INSUFFICIENT_BUFFER\n"));
break;
}
status = VideoPortUnmapMemory(HwDeviceExtension, pShareMemory->RequestedVirtualAddress, pShareMemory->ProcessHandle);
break;
}
/*
* The display driver asks us how many video modes we support
* so that it can supply an appropriate buffer for the next call.
*/
{
{
return TRUE;
}
break;
}
/*
* The display driver asks us to provide a list of supported video modes
* into a buffer it has allocated.
*/
{
if (RequestPacket->OutputBufferLength <
gNumVideoModes * sizeof(VIDEO_MODE_INFORMATION))
{
return TRUE;
}
break;
}
{
sizeof(VIDEO_CLUT))
{
return TRUE;
}
break;
}
{
{
return TRUE;
}
break;
}
// show the pointer
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_ENABLE_POINTER\n"));
// find out whether the host wants absolute positioning
/// @todo this is now obsolete - remove it?
if (vboxQueryHostWantsAbsolute())
else
{
// fallback to software pointer
}
break;
}
// hide the pointer
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_DISABLE_POINTER\n"));
// find out whether the host wants absolute positioning
if (vboxQueryHostWantsAbsolute())
{
// tell the host to hide pointer
/* Enable == 0 means no shape, not visible.
* It is enough to init only this field.
*/
PointerAttributes.Enable = 0;
Result = vboxUpdatePointerShapeWrap(commonFromDeviceExt((PDEVICE_EXTENSION)HwDeviceExtension), &PointerAttributes, sizeof (PointerAttributes));
if (Result)
else
dprintf(("VBoxVideo::VBoxVideoStartIO: Could not hide hardware pointer -> fallback\n"));
} else
{
// fallback to software pointer
}
break;
}
/*
* Change the pointer shape
*/
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_SET_POINTER_ATTR\n"));
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Input buffer too small (%d bytes)\n", RequestPacket->InputBufferLength));
return TRUE;
}
// find out whether the host wants absolute positioning
if (vboxQueryHostWantsAbsolute())
{
PVIDEO_POINTER_ATTRIBUTES pPointerAttributes = (PVIDEO_POINTER_ATTRIBUTES)RequestPacket->InputBuffer;
#if 0
dprintf(("Pointer shape information:\n"
"\tFlags: %d\n"
"\tWidth: %d\n"
"\tHeight: %d\n"
"\tWidthInBytes: %d\n"
"\tEnable: %d\n"
"\tColumn: %d\n"
"\tRow: %d\n",
dprintf(("\tBytes attached: %d\n", RequestPacket->InputBufferLength - sizeof(VIDEO_POINTER_ATTRIBUTES)));
#endif
Result = vboxUpdatePointerShapeWrap(commonFromDeviceExt((PDEVICE_EXTENSION)HwDeviceExtension), pPointerAttributes, RequestPacket->InputBufferLength);
if (!Result)
dprintf(("VBoxVideo::VBoxVideoStartIO: Could not set hardware pointer -> fallback\n"));
} else
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Fallback to software pointer\n"));
// fallback to software pointer
}
break;
}
// query pointer information
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_QUERY_POINTER_ATTR\n"));
break;
}
// set the pointer position
{
// find out whether the host wants absolute positioning
/// @todo this is now obsolete - remove it?
if (vboxQueryHostWantsAbsolute())
else
{
// fallback to software pointer
}
break;
}
// query the pointer position
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_QUERY_POINTER_POSITION\n"));
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small!\n"));
return TRUE;
}
{
// map from 0xFFFF to the current resolution
}
if (!Result)
{
// fallback to software pointer
}
break;
}
// Determine hardware cursor capabilities. We will always report that we are
// very capable even though the host might not want to do pointer integration.
// This is done because we can still return errors on the actual calls later to
// make the display driver go to the fallback routines.
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES\n"));
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small!\n"));
return TRUE;
}
// for now we go with 64x64 cursors
// that doesn't seem to be relevant, VBoxDisp doesn't use it
break;
}
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_SWITCH_DUALVIEW[%d] (%ld)\n", pDevExt->iDevice, ulAttach));
{
}
break;
}
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_INTERPRET_DISPLAY_MEMORY\n"));
/* Pre-HGSMI IOCTL */
Result = false;
break;
}
case IOCTL_VIDEO_VBVA_ENABLE:
{
int rc;
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_VBVA_ENABLE\n"));
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Input buffer too small: %d needed: %d!!!\n",
return FALSE;
}
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small: %d needed: %d!!!\n",
return FALSE;
}
if (RT_FAILURE (rc))
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_VBVA_ENABLE: failed to enable VBVA\n"));
return FALSE;
}
break;
}
/* Private ioctls */
{
int rc;
{
dprintf(("VBoxVideo::IOCTL_VIDEO_VBOX_SETVISIBLEREGION: Output buffer too small: %d needed: %d!!!\n",
return FALSE;
}
/*
* Inform the host about the visible region
*/
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
{
break;
}
}
return FALSE;
}
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_QUERY_HGSMI_INFO\n"));
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small: %d needed: %d!!!\n",
return FALSE;
}
{
return FALSE;
}
/* Describes VRAM chunk for this display device. */
break;
}
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS\n"));
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small: %d needed: %d!!!\n",
return FALSE;
}
{
return FALSE;
}
break;
}
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_HGSMI_QUERY_PORTPROCS\n"));
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small: %d needed: %d!!!\n",
return FALSE;
}
{
return FALSE;
}
break;
}
{
dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_HGSMI_HANDLER_ENABLE\n"));
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small: %d needed: %d!!!\n",
return FALSE;
}
{
return FALSE;
}
if(RT_FAILURE(rc))
{
}
break;
}
{
/* TODO: implement */
{
return FALSE;
}
break;
}
# ifdef VBOX_WITH_VIDEOHWACCEL
{
{
dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small: %d needed: %d!!!\n",
return FALSE;
}
{
return FALSE;
}
break;
}
# endif
default:
dprintf(("VBoxVideo::VBoxVideoStartIO: Unsupported %p, fn %d(0x%x)\n",
return FALSE;
}
if (Result)
else
// dprintf(("VBoxVideo::VBoxVideoStartIO: Completed\n"));
return TRUE;
}
/**
* VBoxVideoReset HW
*
* Resets the video hardware.
*/
{
dprintf(("VBoxVideo::VBoxVideoResetHW\n"));
{
dprintf(("VBoxVideo::VBoxVideoResetHW: Skipping for non-primary display %d\n",
return TRUE;
}
{
}
VbglTerminate ();
/** @note using this callback instead of doing things manually adds an
* additional call to HGSMIHeapDestroy(). I assume that call was
* merely forgotton in the first place. */
return TRUE;
}
/**
* VBoxVideoGetPowerState
*
* Queries whether the device can support the requested power state.
*/
{
dprintf(("VBoxVideo::VBoxVideoGetPowerState\n"));
return NO_ERROR;
}
/**
* VBoxVideoSetPowerState
*
* Sets the power state of the specified device
*/
{
dprintf(("VBoxVideo::VBoxVideoSetPowerState\n"));
return NO_ERROR;
}
#endif /* #ifndef VBOX_WITH_WDDM */
/**
* VBoxVideoSetGraphicsCap
*
* Tells the host whether or not we currently support graphics in the
* additions
*/
{
int rc;
sizeof (VMMDevReqGuestCapabilities2),
if (!RT_SUCCESS(rc))
else
{
if (RT_FAILURE(rc))
}
return RT_SUCCESS(rc);
}
#ifdef VBOX_WITH_WDDM
#endif
)
{
#ifdef VBOX_WITH_WDDM
/* encode linear offDisplay to xOffset & yOffset to ensure offset fits USHORT */
if (bpp == 4)
{
xOffset <<= 1;
}
else
{
}
#else
#endif
/** @todo read from the port to see if the mode switch was successful */
return TRUE;
}
#ifndef VBOX_WITH_WDDM
/**
* VBoxVideoSetCurrentMode
*
* Sets the adapter to the specified operating mode.
*/
{
if (DeviceExtension->iDevice > 0)
{
dprintf(("VBoxVideo::VBoxVideoSetCurrentMode: Skipping for non-primary display %d\n",
return TRUE;
}
}
/*
* VBoxVideoResetDevice
*
* Resets the video hardware to the default mode, to which it was initialized
* at system boot.
*/
{
dprintf(("VBoxVideo::VBoxVideoResetDevice\n"));
if (DeviceExtension->iDevice > 0)
{
/* If the device is the secondary display, however, it is recommended that no action be taken. */
dprintf(("VBoxVideo::VBoxVideoResetDevice: Skipping for non-primary display %d\n",
return TRUE;
}
#if 0
/* Don't disable the extended video mode. This would only switch the video mode
* to <current width> x <current height> x 0 bpp which is not what we want. And
* even worse, it causes an disturbing additional mode switch */
#endif
/* Tell the host that we no longer support graphics in the additions
* @todo: Keep old behaviour, see similar comment in VBoxVideoSetCurrentMode for details.
*/
// VBoxVideoSetGraphicsCap(FALSE);
return TRUE;
}
/**
* VBoxVideoMapVideoMemory
*
* Maps the video hardware frame buffer and video RAM into the virtual address
* space of the requestor.
*/
{
dprintf(("VBoxVideo::VBoxVideoMapVideoMemory: fb offset 0x%x\n", DeviceExtension->ulFrameBufferOffset));
{
/* Save the new framebuffer size */
return TRUE;
}
return FALSE;
}
/**
* VBoxVideoUnmapVideoMemory
*
* Releases a mapping between the virtual address space and the adapter's
* frame buffer and video RAM.
*/
{
dprintf(("VBoxVideo::VBoxVideoUnmapVideoMemory\n"));
return TRUE;
}
/**
* VBoxVideoQueryNumAvailModes
*
* Returns the number of video modes supported by the adapter and the size
* in bytes of the video mode information, which can be used to allocate a
* buffer for an IOCTL_VIDEO_QUERY_AVAIL_MODES request.
*/
{
dprintf(("VBoxVideo::VBoxVideoQueryNumAvailModes\n"));
/* calculate the video modes table */
return TRUE;
}
/**
* VBoxVideoQueryAvailModes
*
* Returns information about each video mode supported by the adapter.
*/
{
dprintf(("VBoxVideo::VBoxVideoQueryAvailModes\n"));
return TRUE;
}
/**
* VBoxVideoQueryCurrentMode
*
* Returns information about current video mode.
*/
{
dprintf(("VBoxVideo::VBoxVideoQueryCurrentMode\n"));
return TRUE;
}
#endif /* ifndef VBOX_WITH_WDDM */
/*
* VBoxVideoSetColorRegisters
*
* Sets the adapter's color registers to the specified RGB values. There
* are code paths in this function, one generic and one for VGA compatible
* controllers. The latter is needed for Bochs, where the generic one isn't
* yet implemented.
*/
{
dprintf(("VBoxVideo::VBoxVideoSetColorRegisters first entry %d num entries %d\n", ColorLookUpTable->FirstEntry, ColorLookUpTable->NumEntries));
return FALSE;
Entry++)
{
}
return TRUE;
}
#ifndef VBOX_WITH_WDDM
{
dprintf(("VBoxVideo::VBoxVideoGetChildDescriptor: HwDeviceExtension = %p, ChildEnumInfo = %p\n",
if (ChildEnumInfo->ChildIndex > 0)
{
{
return VIDEO_ENUM_MORE_DEVICES;
}
}
return ERROR_NO_MORE_DEVICES;
}
#ifndef VBOX_WITH_WDDM
VP_STATUS vboxWaitForSingleObjectVoid(IN PVOID HwDeviceExtension, IN PVOID Object, IN PLARGE_INTEGER Timeout OPTIONAL)
{
return ERROR_INVALID_FUNCTION;
}
{
return 0;
}
{
}
VP_STATUS vboxCreateEventVoid(IN PVOID HwDeviceExtension, IN ULONG EventFlag, IN PVOID Unused, OUT PEVENT *ppEvent)
{
return ERROR_INVALID_FUNCTION;
}
{
return ERROR_INVALID_FUNCTION;
}
PVOID vboxAllocatePoolVoid(IN PVOID HwDeviceExtension, IN VBOXVP_POOL_TYPE PoolType, IN size_t NumberOfBytes, IN ULONG Tag)
{
return NULL;
}
{
}
BOOLEAN vboxQueueDpcVoid(IN PVOID HwDeviceExtension, IN PMINIPORT_DPC_ROUTINE CallbackRoutine, IN PVOID Context)
{
return FALSE;
}
void VBoxSetupVideoPortFunctions(PDEVICE_EXTENSION PrimaryExtension, VBOXVIDEOPORTPROCS *pCallbacks, PVIDEO_PORT_CONFIG_INFO pConfigInfo)
{
if (vboxQueryWinVersion() <= WINNT4)
{
/* VideoPortGetProcAddress is available for >= win2k */
return;
}
(PUCHAR)"VideoPortWaitForSingleObject");
(PUCHAR)"VideoPortSetEvent");
(PUCHAR)"VideoPortClearEvent");
(PUCHAR)"VideoPortCreateEvent");
(PUCHAR)"VideoPortDeleteEvent");
&& pCallbacks->pfnDeleteEvent)
{
}
else
{
}
(PUCHAR)"VideoPortAllocatePool");
(PUCHAR)"VideoPortFreePool");
&& pCallbacks->pfnFreePool)
{
}
else
{
}
(PUCHAR)"VideoPortQueueDpc");
if(pCallbacks->pfnQueueDpc)
{
}
else
{
}
#ifdef DEBUG_misha
#endif
}
#endif
{
if (pPrimaryDevExt)
{
if (req)
{
if (RT_FAILURE(rc))
{
}
}
}
return;
}
{
int rc = VINF_SUCCESS;
/*
* Query the VMMDev memory pointer. There we need VBVAMemory.
*/
dprintf(("VBoxVideo::vboxVbvaEnable: VbglQueryVMMDevMemory rc = %d, pVMMDevMemory = %p\n", rc, pVMMDevMemory));
{
dprintf(("VBoxVideo::vboxVbvaEnable: Skipping for non-primary display %d\n",
if ( ulEnable
{
}
else
{
}
return rc;
}
if (RT_SUCCESS(rc))
{
/* Allocate the memory block for VMMDevReq_VideoAccelFlush request. */
{
sizeof (VMMDevVideoAccelFlush),
if (RT_SUCCESS (rc))
{
}
else
{
}
}
}
else
{
}
if (RT_SUCCESS(rc))
{
/*
* Tell host that VBVA status is changed.
*/
sizeof (VMMDevVideoAccelEnable),
if (RT_SUCCESS(rc))
{
req->fu32Status = 0;
if (RT_SUCCESS(rc))
{
{
/*
* Initialize the result information and VBVA memory.
*/
{
ulEnabled = 1;
}
else
{
}
dprintf(("VBoxVideo::vboxVbvaEnable: success.\n"));
}
else
{
dprintf(("VBoxVideo::vboxVbvaEnable: not accepted.\n"));
/* Disable VBVA for old hosts. */
req->fu32Status = 0;
}
}
else
{
}
}
else
{
}
}
return rc;
}
#endif