/**
* Callback for blah blah blah.
*/
IOReturn VbgdDarwinSleepHandler(void * /* pvTarget */, void *pvRefCon, UInt32 uMessageType, IOService * /* pProvider */, void * /* pvMessageArgument */, vm_size_t /* argSize */)
{
LogFlow(("VBoxGuest: Got sleep/wake notice. Message type was %X\n", (uint)uMessageType));
if (uMessageType == kIOMessageSystemWillSleep)
RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
else if (uMessageType == kIOMessageSystemHasPoweredOn)
RTPowerSignalEvent(RTPOWEREVENT_RESUME);
acknowledgeSleepWakeNotification(pvRefCon);
return 0;
}
/**
* Callback for blah blah blah.
*/
static IOReturn vgdrvDarwinSleepHandler(void *pvTarget, void *pvRefCon, UInt32 uMessageType,
IOService *pProvider, void *pvMsgArg, vm_size_t cbMsgArg)
{
LogFlow(("VBoxGuest: Got sleep/wake notice. Message type was %x\n", uMessageType));
if (uMessageType == kIOMessageSystemWillSleep)
RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
else if (uMessageType == kIOMessageSystemHasPoweredOn)
RTPowerSignalEvent(RTPOWEREVENT_RESUME);
acknowledgeSleepWakeNotification(pvRefCon);
return 0;
}
/**
* ExRegisterCallback handler for power events
*
* @param pCallbackContext User supplied parameter (pDevObj)
* @param pArgument1 First argument
* @param pArgument2 Second argument
*/
VOID _stdcall VBoxPowerDispatchCallback(PVOID pCallbackContext, PVOID pArgument1, PVOID pArgument2)
{
PDEVICE_OBJECT pDevObj = (PDEVICE_OBJECT)pCallbackContext;
Log(("VBoxPowerDispatchCallback: %x %x\n", pArgument1, pArgument2));
/* Power change imminent? */
if ((unsigned)pArgument1 == PO_CB_SYSTEM_STATE_LOCK)
{
if ((unsigned)pArgument2 == 0)
Log(("VBoxPowerDispatchCallback: about to go into suspend mode!\n"));
else
Log(("VBoxPowerDispatchCallback: resumed!\n"));
/* Inform any clients that have registered themselves with IPRT. */
RTPowerSignalEvent(((unsigned)pArgument2 == 0) ? RTPOWEREVENT_SUSPEND : RTPOWEREVENT_RESUME);
}
}
/**
* Detach entry point, to detach a device to the system or suspend it.
*
* @param pDip The module structure instance.
* @param enmCmd Operation type (detach/suspend).
*
* @return corresponding solaris error code.
*/
static int VBoxDrvSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
{
LogFlowFunc(("VBoxDrvSolarisDetach\n"));
switch (enmCmd)
{
case DDI_DETACH:
{
#ifndef USE_SESSION_HASH
ddi_remove_minor_node(pDip, NULL);
#else
int instance = ddi_get_instance(pDip);
vbox_devstate_t *pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, instance);
ddi_remove_minor_node(pDip, NULL);
ddi_soft_state_free(g_pVBoxDrvSolarisState, instance);
#endif
ddi_prop_remove_all(pDip);
return DDI_SUCCESS;
}
case DDI_SUSPEND:
{
#if 0
RTSemFastMutexRequest(g_DevExt.mtxGip);
if (g_DevExt.pGipTimer && g_DevExt.cGipUsers > 0)
RTTimerStop(g_DevExt.pGipTimer);
RTSemFastMutexRelease(g_DevExt.mtxGip);
#endif
RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
LogFlow(("vboxdrv: Falling to suspend mode.\n"));
return DDI_SUCCESS;
}
default:
return DDI_FAILURE;
}
}
/**
* Attach entry point, to attach a device to the system or resume it.
*
* @param pDip The module structure instance.
* @param enmCmd Operation type (attach/resume).
*
* @return corresponding solaris error code.
*/
static int VBoxDrvSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
{
LogFlowFunc(("VBoxDrvSolarisAttach\n"));
switch (enmCmd)
{
case DDI_ATTACH:
{
int rc;
#ifdef USE_SESSION_HASH
int instance = ddi_get_instance(pDip);
vbox_devstate_t *pState;
if (ddi_soft_state_zalloc(g_pVBoxDrvSolarisState, instance) != DDI_SUCCESS)
{
LogRel(("VBoxDrvSolarisAttach: state alloc failed\n"));
return DDI_FAILURE;
}
pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, instance);
#endif
/*
* Register for suspend/resume notifications
*/
rc = ddi_prop_create(DDI_DEV_T_NONE, pDip, DDI_PROP_CANSLEEP /* kmem alloc can sleep */,
"pm-hardware-state", "needs-suspend-resume", sizeof("needs-suspend-resume"));
if (rc != DDI_PROP_SUCCESS)
LogRel(("vboxdrv: Suspend/Resume notification registration failed.\n"));
/*
* Register ourselves as a character device, pseudo-driver
*/
#ifdef VBOX_WITH_HARDENING
rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME_SYS, S_IFCHR, 0 /*minor*/, DDI_PSEUDO,
0, NULL, NULL, 0600);
#else
rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME_SYS, S_IFCHR, 0 /*minor*/, DDI_PSEUDO,
0, "none", "none", 0666);
#endif
if (rc == DDI_SUCCESS)
{
rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME_USR, S_IFCHR, 1 /*minor*/, DDI_PSEUDO,
0, "none", "none", 0666);
if (rc == DDI_SUCCESS)
{
#ifdef USE_SESSION_HASH
pState->pDip = pDip;
#endif
ddi_report_dev(pDip);
return DDI_SUCCESS;
}
ddi_remove_minor_node(pDip, NULL);
}
return DDI_FAILURE;
}
case DDI_RESUME:
{
#if 0
RTSemFastMutexRequest(g_DevExt.mtxGip);
if (g_DevExt.pGipTimer)
RTTimerStart(g_DevExt.pGipTimer, 0);
RTSemFastMutexRelease(g_DevExt.mtxGip);
#endif
RTPowerSignalEvent(RTPOWEREVENT_RESUME);
LogFlow(("vboxdrv: Awakened from suspend.\n"));
return DDI_SUCCESS;
}
default:
return DDI_FAILURE;
}
return DDI_FAILURE;
}
static int VBoxDrvResume(struct platform_device *pDev)
# endif
{
RTPowerSignalEvent(RTPOWEREVENT_RESUME);
return 0;
}
static int VBoxDrvSuspend(struct platform_device *pDev, pm_message_t State)
# endif
{
RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
return 0;
}
