/**
* Creates the kernel input device.
*/
static int __init vboxguestLinuxCreateInputDevice(void)
{
int rc;
rc = VbglGRAlloc((VMMDevRequestHeader **)&g_pMouseStatusReq,
sizeof(*g_pMouseStatusReq),
VMMDevReq_GetMouseStatus);
if (RT_FAILURE(rc))
return -ENOMEM;
g_pInputDevice = input_allocate_device();
if (!g_pInputDevice)
{
VbglGRFree(&g_pMouseStatusReq->header);
return -ENOMEM;
}
g_pInputDevice->id.bustype = BUS_PCI;
g_pInputDevice->id.vendor = VMMDEV_VENDORID;
g_pInputDevice->id.product = VMMDEV_DEVICEID;
g_pInputDevice->id.version = VBOX_SHORT_VERSION;
g_pInputDevice->open = vboxguestOpenInputDevice;
g_pInputDevice->close = vboxguestCloseInputDevice;
# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
g_pInputDevice->cdev.dev = &g_pPciDev->dev;
# else
g_pInputDevice->dev.parent = &g_pPciDev->dev;
# endif
{
int rc = input_register_device(g_pInputDevice);
if (rc)
{
VbglGRFree(&g_pMouseStatusReq->header);
input_free_device(g_pInputDevice);
return rc;
}
}
/* Do what one of our competitors apparently does as that works. */
ASMBitSet(g_pInputDevice->evbit, EV_ABS);
ASMBitSet(g_pInputDevice->evbit, EV_KEY);
# ifdef EV_SYN
ASMBitSet(g_pInputDevice->evbit, EV_SYN);
# endif
input_set_abs_params(g_pInputDevice, ABS_X, VMMDEV_MOUSE_RANGE_MIN,
VMMDEV_MOUSE_RANGE_MAX, 0, 0);
input_set_abs_params(g_pInputDevice, ABS_Y, VMMDEV_MOUSE_RANGE_MIN,
VMMDEV_MOUSE_RANGE_MAX, 0, 0);
ASMBitSet(g_pInputDevice->keybit, BTN_MOUSE);
/** @todo this string should be in a header file somewhere. */
g_pInputDevice->name = "VirtualBox mouse integration";
return 0;
}
/**
* Terminates the kernel input device.
*/
static void vboxguestLinuxTermInputDevice(void)
{
VbglGRFree(&g_pMouseStatusReq->header);
/* See documentation of input_register_device(): input_free_device()
* should not be called after a device has been registered. */
input_unregister_device(g_pInputDevice);
}
uint32_t VBoxGetHeightReduction()
{
uint32_t retHeight = 0;
int rc;
LOGF_ENTER();
VMMDevGetHeightReductionRequest *req = NULL;
rc = VbglGRAlloc((VMMDevRequestHeader**)&req, sizeof(VMMDevGetHeightReductionRequest), VMMDevReq_GetHeightReduction);
if (RT_FAILURE(rc))
{
WARN(("ERROR allocating request, rc = %#xrc", rc));
}
else
{
rc = VbglGRPerform(&req->header);
if (RT_SUCCESS(rc))
{
retHeight = req->heightReduction;
}
else
{
WARN(("ERROR querying height reduction value from VMMDev. rc = %#xrc", rc));
}
VbglGRFree(&req->header);
}
LOGF_LEAVE();
return retHeight;
}
/* Called to reset adapter to a given character mode. */
static BOOLEAN
VBoxDrvResetHW(PVOID HwDeviceExtension, ULONG Columns, ULONG Rows)
{
PVBOXMP_DEVEXT pExt = (PVBOXMP_DEVEXT) HwDeviceExtension;
LOGF_ENTER();
if (pExt->iDevice==0) /* Primary device */
{
VideoPortWritePortUshort((PUSHORT)VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_ENABLE);
VideoPortWritePortUshort((PUSHORT)VBE_DISPI_IOPORT_DATA, VBE_DISPI_DISABLED);
#if 0
/* ResetHW is not the place to do such cleanup. See MSDN. */
if (pExt->u.primary.pvReqFlush != NULL)
{
VbglGRFree((VMMDevRequestHeader *)pExt->u.primary.pvReqFlush);
pExt->u.primary.pvReqFlush = NULL;
}
VbglTerminate();
VBoxFreeDisplaysHGSMI(VBoxCommonFromDeviceExt(pExt));
#endif
}
else
{
LOG(("ignoring non primary device %d", pExt->iDevice));
}
LOGF_LEAVE();
/* Tell the system to use VGA BIOS to set the text video mode. */
return FALSE;
}
bool VBoxLikesVideoMode(uint32_t display, uint32_t width, uint32_t height, uint32_t bpp)
{
bool bRC = FALSE;
VMMDevVideoModeSupportedRequest2 *req2 = NULL;
int rc = VbglGRAlloc((VMMDevRequestHeader**)&req2, sizeof(VMMDevVideoModeSupportedRequest2), VMMDevReq_VideoModeSupported2);
if (RT_FAILURE(rc))
{
LOG(("ERROR allocating request, rc = %#xrc", rc));
/* Most likely the VBoxGuest driver is not loaded.
* To get at least the video working, report the mode as supported.
*/
bRC = TRUE;
}
else
{
req2->display = display;
req2->width = width;
req2->height = height;
req2->bpp = bpp;
rc = VbglGRPerform(&req2->header);
if (RT_SUCCESS(rc))
{
bRC = req2->fSupported;
}
else
{
/* Retry using old interface. */
AssertCompile(sizeof(VMMDevVideoModeSupportedRequest2) >= sizeof(VMMDevVideoModeSupportedRequest));
VMMDevVideoModeSupportedRequest *req = (VMMDevVideoModeSupportedRequest *)req2;
req->header.size = sizeof(VMMDevVideoModeSupportedRequest);
req->header.version = VMMDEV_REQUEST_HEADER_VERSION;
req->header.requestType = VMMDevReq_VideoModeSupported;
req->header.rc = VERR_GENERAL_FAILURE;
req->header.reserved1 = 0;
req->header.reserved2 = 0;
req->width = width;
req->height = height;
req->bpp = bpp;
rc = VbglGRPerform(&req->header);
if (RT_SUCCESS(rc))
{
bRC = req->fSupported;
}
else
{
WARN(("ERROR querying video mode supported status from VMMDev. rc = %#xrc", rc));
}
}
VbglGRFree(&req2->header);
}
LOG(("width: %d, height: %d, bpp: %d -> %s", width, height, bpp, (bRC == 1) ? "OK" : "FALSE"));
return bRC;
}
static bool VBoxQueryPointerPosInternal(uint16_t *pPosX, uint16_t *pPosY)
{
bool bRC = FALSE;
VMMDevReqMouseStatus *req = NULL;
int rc = VbglGRAlloc((VMMDevRequestHeader **)&req, sizeof(VMMDevReqMouseStatus), VMMDevReq_GetMouseStatus);
if (RT_FAILURE(rc))
{
LOG(("ERROR allocating request, rc = %#xrc", rc));
}
else
{
rc = VbglGRPerform(&req->header);
if (RT_SUCCESS(rc))
{
if (req->mouseFeatures & VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE)
{
if (pPosX)
{
*pPosX = req->pointerXPos;
}
if (pPosY)
{
*pPosY = req->pointerYPos;
}
bRC = TRUE;
}
}
else
{
LOG(("ERROR querying mouse capabilities from VMMDev. rc = %#xrc", rc));
}
VbglGRFree(&req->header);
}
return bRC;
}
bool VBoxQueryDisplayRequest(uint32_t *xres, uint32_t *yres, uint32_t *bpp, uint32_t *pDisplayId)
{
bool bRC = FALSE;
VMMDevDisplayChangeRequest2 *req = NULL;
LOGF_ENTER();
int rc = VbglGRAlloc ((VMMDevRequestHeader **)&req, sizeof (VMMDevDisplayChangeRequest2), VMMDevReq_GetDisplayChangeRequest2);
if (RT_FAILURE(rc))
{
LOG(("ERROR allocating request, rc = %#xrc", rc));
}
else
{
req->eventAck = 0;
rc = VbglGRPerform (&req->header);
if (RT_SUCCESS(rc))
{
if (xres)
*xres = req->xres;
if (yres)
*yres = req->yres;
if (bpp)
*bpp = req->bpp;
if (pDisplayId)
*pDisplayId = req->display;
LOG(("returning %d x %d @ %d for %d", req->xres, req->yres, req->bpp, req->display));
bRC = TRUE;
}
else
{
WARN(("ERROR querying display request from VMMDev. rc = %#xrc", rc));
}
VbglGRFree (&req->header);
}
LOGF_LEAVE();
return bRC;
}
/**
* Used by vbglQueryDriverInfo and VbglInit to try get the host feature mask and
* version information (g_vbgldata::hostVersion).
*
* This was first implemented by the host in 3.1 and we quietly ignore failures
* for that reason.
*/
static void vbglR0QueryHostVersion (void)
{
VMMDevReqHostVersion *pReq;
int rc = VbglGRAlloc ((VMMDevRequestHeader **) &pReq, sizeof (*pReq), VMMDevReq_GetHostVersion);
if (RT_SUCCESS (rc))
{
rc = VbglGRPerform (&pReq->header);
if (RT_SUCCESS (rc))
{
g_vbgldata.hostVersion = *pReq;
Log (("vbglR0QueryHostVersion: %u.%u.%ur%u %#x\n",
pReq->major, pReq->minor, pReq->build, pReq->revision, pReq->features));
}
VbglGRFree (&pReq->header);
}
}
/* Called for IOCTL_VIDEO_VBOX_SETVISIBLEREGION.
* Sends visible regions information to the host.
*/
BOOLEAN VBoxMPSetVisibleRegion(uint32_t cRects, RTRECT *pRects, PSTATUS_BLOCK pStatus)
{
int rc;
BOOLEAN bRC = FALSE;
LOGF_ENTER();
VMMDevVideoSetVisibleRegion *req = NULL;
rc = VbglGRAlloc((VMMDevRequestHeader **)&req, sizeof(VMMDevVideoSetVisibleRegion) + (cRects-1)*sizeof(RTRECT),
VMMDevReq_VideoSetVisibleRegion);
if (RT_SUCCESS(rc))
{
req->cRect = cRects;
memcpy(&req->Rect, pRects, cRects*sizeof(RTRECT));
rc = VbglGRPerform(&req->header);
if (RT_SUCCESS(rc))
{
bRC=TRUE;
}
VbglGRFree(&req->header);
}
else
{
WARN(("VbglGRAlloc rc = %#xrc", rc));
}
if (!bRC)
{
pStatus->Status = ERROR_INVALID_FUNCTION;
}
LOGF_LEAVE();
return bRC;
}
int VBoxVbvaEnable(PVBOXMP_DEVEXT pExt, BOOLEAN bEnable, VBVAENABLERESULT *pResult)
{
int rc = VINF_SUCCESS;
LOGF_ENTER();
VMMDevMemory *pVMMDevMemory = NULL;
rc = VbglQueryVMMDevMemory (&pVMMDevMemory);
if (RT_FAILURE(rc))
{
WARN(("VbglQueryVMMDevMemory rc = %#xrc", rc));
LOGF_LEAVE();
return rc;
}
if (pExt->iDevice>0)
{
PVBOXMP_DEVEXT pPrimary = pExt->pPrimary;
LOGF(("skipping non-primary display %d", pExt->iDevice));
if (bEnable && pPrimary->u.primary.ulVbvaEnabled && pVMMDevMemory)
{
pResult->pVbvaMemory = &pVMMDevMemory->vbvaMemory;
pResult->pfnFlush = VBoxVbvaFlush;
pResult->pvFlush = pExt;
}
else
{
VideoPortZeroMemory(&pResult, sizeof(VBVAENABLERESULT));
}
LOGF_LEAVE();
return rc;
}
/* Allocate the memory block for VMMDevReq_VideoAccelFlush request. */
if (pExt->u.primary.pvReqFlush == NULL)
{
VMMDevVideoAccelFlush *req = NULL;
rc = VbglGRAlloc((VMMDevRequestHeader **)&req, sizeof(VMMDevVideoAccelFlush), VMMDevReq_VideoAccelFlush);
if (RT_SUCCESS(rc))
{
pExt->u.primary.pvReqFlush = req;
}
else
{
WARN(("VbglGRAlloc(VMMDevVideoAccelFlush) rc = %#xrc", rc));
LOGF_LEAVE();
return rc;
}
}
ULONG ulEnabled = 0;
VMMDevVideoAccelEnable *req = NULL;
rc = VbglGRAlloc((VMMDevRequestHeader **)&req, sizeof(VMMDevVideoAccelEnable), VMMDevReq_VideoAccelEnable);
if (RT_SUCCESS(rc))
{
req->u32Enable = bEnable;
req->cbRingBuffer = VBVA_RING_BUFFER_SIZE;
req->fu32Status = 0;
rc = VbglGRPerform(&req->header);
if (RT_SUCCESS(rc))
{
if (req->fu32Status & VBVA_F_STATUS_ACCEPTED)
{
LOG(("accepted"));
/* Initialize the result information and VBVA memory. */
if (req->fu32Status & VBVA_F_STATUS_ENABLED)
{
pResult->pVbvaMemory = &pVMMDevMemory->vbvaMemory;
pResult->pfnFlush = VBoxVbvaFlush;
pResult->pvFlush = pExt;
ulEnabled = 1;
}
else
{
VideoPortZeroMemory(&pResult, sizeof(VBVAENABLERESULT));
}
}
else
{
LOG(("rejected"));
/* Disable VBVA for old hosts. */
req->u32Enable = 0;
req->cbRingBuffer = VBVA_RING_BUFFER_SIZE;
req->fu32Status = 0;
VbglGRPerform(&req->header);
rc = VERR_NOT_SUPPORTED;
}
}
else
{
WARN(("rc = %#xrc", rc));
}
VbglGRFree(&req->header);
}
else
{
WARN(("VbglGRAlloc(VMMDevVideoAccelEnable) rc = %#xrc", rc));
}
pExt->u.primary.ulVbvaEnabled = ulEnabled;
LOGF_LEAVE();
return rc;
}
/**
* Terminates the kernel input device.
*/
static void vboxguestLinuxTermInputDevice(void)
{
VbglGRFree(&g_pMouseStatusReq->header);
input_unregister_device(g_pInputDevice);
input_free_device(g_pInputDevice);
}
/**
* Handle the Power requests.
*
* @returns NT status code
* @param pDevObj device object
* @param pIrp IRP
*/
NTSTATUS vbgdNtPower(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
PVBOXGUESTDEVEXTWIN pDevExt = (PVBOXGUESTDEVEXTWIN)pDevObj->DeviceExtension;
POWER_STATE_TYPE enmPowerType = pStack->Parameters.Power.Type;
POWER_STATE PowerState = pStack->Parameters.Power.State;
POWER_ACTION enmPowerAction = pStack->Parameters.Power.ShutdownType;
Log(("VBoxGuest::vbgdNtGuestPower\n"));
switch (pStack->MinorFunction)
{
case IRP_MN_SET_POWER:
{
Log(("VBoxGuest::vbgdNtGuestPower: IRP_MN_SET_POWER, type= %d\n", enmPowerType));
switch (enmPowerType)
{
case SystemPowerState:
{
Log(("VBoxGuest::vbgdNtGuestPower: SystemPowerState, action = %d, state = %d/%d\n",
enmPowerAction, PowerState.SystemState, PowerState.DeviceState));
switch (enmPowerAction)
{
case PowerActionSleep:
/* System now is in a working state. */
if (PowerState.SystemState == PowerSystemWorking)
{
if ( pDevExt
&& pDevExt->LastSystemPowerAction == PowerActionHibernate)
{
Log(("VBoxGuest::vbgdNtGuestPower: Returning from hibernation!\n"));
int rc = VbgdCommonReinitDevExtAfterHibernation(&pDevExt->Core,
vbgdNtVersionToOSType(g_enmVbgdNtVer));
if (RT_FAILURE(rc))
Log(("VBoxGuest::vbgdNtGuestPower: Cannot re-init VMMDev chain, rc = %d!\n", rc));
}
}
break;
case PowerActionShutdownReset:
{
Log(("VBoxGuest::vbgdNtGuestPower: Power action reset!\n"));
/* Tell the VMM that we no longer support mouse pointer integration. */
VMMDevReqMouseStatus *pReq = NULL;
int vrc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, sizeof (VMMDevReqMouseStatus),
VMMDevReq_SetMouseStatus);
if (RT_SUCCESS(vrc))
{
pReq->mouseFeatures = 0;
pReq->pointerXPos = 0;
pReq->pointerYPos = 0;
vrc = VbglGRPerform(&pReq->header);
if (RT_FAILURE(vrc))
{
Log(("VBoxGuest::PowerStateRequest: error communicating new power status to VMMDev. vrc = %Rrc\n", vrc));
}
VbglGRFree(&pReq->header);
}
/* Don't do any cleanup here; there might be still coming in some IOCtls after we got this
* power action and would assert/crash when we already cleaned up all the stuff! */
break;
}
case PowerActionShutdown:
case PowerActionShutdownOff:
{
Log(("VBoxGuest::vbgdNtGuestPower: Power action shutdown!\n"));
if (PowerState.SystemState >= PowerSystemShutdown)
{
Log(("VBoxGuest::vbgdNtGuestPower: Telling the VMMDev to close the VM ...\n"));
VMMDevPowerStateRequest *pReq = pDevExt->pPowerStateRequest;
int vrc = VERR_NOT_IMPLEMENTED;
if (pReq)
{
pReq->header.requestType = VMMDevReq_SetPowerStatus;
pReq->powerState = VMMDevPowerState_PowerOff;
vrc = VbglGRPerform(&pReq->header);
}
if (RT_FAILURE(vrc))
Log(("VBoxGuest::PowerStateRequest: Error communicating new power status to VMMDev. vrc = %Rrc\n", vrc));
/* No need to do cleanup here; at this point we should've been
* turned off by VMMDev already! */
}
break;
}
case PowerActionHibernate:
Log(("VBoxGuest::vbgdNtGuestPower: Power action hibernate!\n"));
break;
}
/*
* Save the current system power action for later use.
* This becomes handy when we return from hibernation for example.
*/
if (pDevExt)
pDevExt->LastSystemPowerAction = enmPowerAction;
break;
}
default:
break;
}
break;
}
default:
break;
}
/*
* Whether we are completing or relaying this power IRP,
* we must call PoStartNextPowerIrp.
*/
PoStartNextPowerIrp(pIrp);
/*
* Send the IRP down the driver stack, using PoCallDriver
* (not IoCallDriver, as for non-power irps).
*/
IoCopyCurrentIrpStackLocationToNext(pIrp);
IoSetCompletionRoutine(pIrp,
vbgdNtPowerComplete,
(PVOID)pDevExt,
TRUE,
TRUE,
TRUE);
return PoCallDriver(pDevExt->pNextLowerDriver, pIrp);
}
VOID VBoxDeviceRemoved(PVBOXMOUSE_DEVEXT pDevExt)
{
LOGF_ENTER();
/* Save the allocated request pointer and clear the devExt. */
VMMDevReqMouseStatus *pSCReq = (VMMDevReqMouseStatus *) InterlockedExchangePointer((PVOID volatile *)&pDevExt->pSCReq, NULL);
if (pDevExt->bHostMouse && vboxIsHostInformed())
{
// tell the VMM that from now on we can't handle absolute coordinates anymore
VMMDevReqMouseStatus *req = NULL;
int rc = VbglGRAlloc((VMMDevRequestHeader **)&req, sizeof(VMMDevReqMouseStatus), VMMDevReq_SetMouseStatus);
if (RT_SUCCESS(rc))
{
req->mouseFeatures = 0;
req->pointerXPos = 0;
req->pointerYPos = 0;
rc = VbglGRPerform(&req->header);
if (RT_FAILURE(rc))
{
WARN(("VbglGRPerform failed with rc=%#x", rc));
}
VbglGRFree(&req->header);
}
else
{
WARN(("VbglGRAlloc failed with rc=%#x", rc));
}
InterlockedExchange(&g_ctx.fHostInformed, FALSE);
}
if (pSCReq)
{
VbglGRFree(&pSCReq->header);
}
LONG callCnt = InterlockedDecrement(&g_ctx.cDevicesStarted);
vboxNewProtDeviceRemoved(pDevExt);
if (callCnt == 0)
{
if (vboxIsVBGLInited())
{
/* Set the flag to prevent reinitializing of the VBGL. */
InterlockedExchange(&g_ctx.fVBGLInitFailed, TRUE);
VbglTerminate();
/* The VBGL is now in the not initialized state. */
InterlockedExchange(&g_ctx.fVBGLInited, FALSE);
InterlockedExchange(&g_ctx.fVBGLInitFailed, FALSE);
}
}
LOGF_LEAVE();
}
VOID VBoxInformHost(PVBOXMOUSE_DEVEXT pDevExt)
{
LOGF_ENTER();
if (!vboxIsVBGLInited())
{
WARN(("!vboxIsVBGLInited"));
return;
}
/* Inform host we support absolute coordinates */
if (pDevExt->bHostMouse && !vboxIsHostInformed())
{
VMMDevReqMouseStatus *req = NULL;
int rc = VbglGRAlloc((VMMDevRequestHeader **)&req, sizeof(VMMDevReqMouseStatus), VMMDevReq_SetMouseStatus);
if (RT_SUCCESS(rc))
{
req->mouseFeatures = VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE;
if (vboxNewProtIsEnabled())
req->mouseFeatures |= VMMDEV_MOUSE_NEW_PROTOCOL;
req->pointerXPos = 0;
req->pointerYPos = 0;
rc = VbglGRPerform(&req->header);
if (RT_SUCCESS(rc))
{
InterlockedExchange(&g_ctx.fHostInformed, TRUE);
}
else
{
WARN(("VbglGRPerform failed with rc=%#x", rc));
}
VbglGRFree(&req->header);
}
else
{
WARN(("VbglGRAlloc failed with rc=%#x", rc));
}
}
/* Preallocate request to be used in VBoxServiceCB*/
if (pDevExt->bHostMouse && !pDevExt->pSCReq)
{
VMMDevReqMouseStatus *req = NULL;
int rc = VbglGRAlloc((VMMDevRequestHeader **)&req, sizeof(VMMDevReqMouseStatus), VMMDevReq_GetMouseStatus);
if (RT_SUCCESS(rc))
{
InterlockedExchangePointer((PVOID volatile *)&pDevExt->pSCReq, req);
}
else
{
WARN(("VbglGRAlloc for service callback failed with rc=%#x", rc));
}
}
LOGF_LEAVE();
}
