static void
suspend(pmEvent event, Bool undo)
{
int i;
InputInfoPtr pInfo;
for (i = 0; i < xf86NumScreens; i++) {
if (xf86Screens[i]->EnableDisableFBAccess)
(*xf86Screens[i]->EnableDisableFBAccess) (xf86Screens[i], FALSE);
}
pInfo = xf86InputDevs;
while (pInfo) {
DisableDevice(pInfo->dev, TRUE);
pInfo = pInfo->next;
}
OsBlockSIGIO();
for (i = 0; i < xf86NumScreens; i++) {
if (xf86Screens[i]->PMEvent)
xf86Screens[i]->PMEvent(xf86Screens[i], event, undo);
else {
xf86Screens[i]->LeaveVT(xf86Screens[i]);
xf86Screens[i]->vtSema = FALSE;
}
}
xf86AccessLeave();
}
static void
suspend (pmEvent event, Bool undo)
{
int i;
InputInfoPtr pInfo;
xf86inSuspend = TRUE;
for (i = 0; i < xf86NumScreens; i++) {
xf86EnableAccess(xf86Screens[i]);
if (xf86Screens[i]->EnableDisableFBAccess)
(*xf86Screens[i]->EnableDisableFBAccess) (i, FALSE);
}
#if !defined(__EMX__)
pInfo = xf86InputDevs;
while (pInfo) {
DisableDevice(pInfo->dev);
pInfo = pInfo->next;
}
#endif
xf86EnterServerState(SETUP);
for (i = 0; i < xf86NumScreens; i++) {
xf86EnableAccess(xf86Screens[i]);
if (xf86Screens[i]->PMEvent)
xf86Screens[i]->PMEvent(i,event,undo);
else {
xf86Screens[i]->LeaveVT(i, 0);
xf86Screens[i]->vtSema = FALSE;
}
}
xf86AccessLeave();
xf86AccessLeaveState();
}
void cOpenClHardware::EnableDevicesByHashList(const QString &list)
{
QStringList stringList = list.split("|");
// disable all devices
for (int dev = 0; dev < clDeviceWorkers.size(); dev++)
{
DisableDevice(dev);
}
// enable only devices from list
for (int i = 0; i < stringList.size(); i++)
{
QByteArray hashFromList = QByteArray::fromHex(stringList.at(i).toLocal8Bit());
for (int dev = 0; dev < clDeviceWorkers.size(); dev++)
{
QByteArray hashFromDevice = clDeviceWorkers[dev].getDeviceInformation().hash;
if (hashFromDevice.left(3) == hashFromList.left(3))
{
EnableDevice(dev);
WriteLog(
QString("Device ") + clDeviceWorkers[dev].getDeviceInformation().deviceName + " enabled",
3);
}
}
}
}
// called before destruction
void GContactlessReaderManager::Dispose()
{
m_pCLRService = GContactlessReaderService::GetService();
if (m_pCLRService)
{
DisableDevice();
m_pCLRService->DetachManager();
}
}
static int
remove_master(ClientPtr client, xXIRemoveMasterInfo *r,
int flags[MAXDEVICES])
{
DeviceIntPtr ptr, keybd, XTestptr, XTestkeybd;
int rc = Success;
if (r->return_mode != XIAttachToMaster &&
r->return_mode != XIFloating)
return BadValue;
rc = dixLookupDevice(&ptr, r->deviceid, client, DixDestroyAccess);
if (rc != Success)
goto unwind;
if (!IsMaster(ptr))
{
client->errorValue = r->deviceid;
rc = BadDevice;
goto unwind;
}
/* XXX: For now, don't allow removal of VCP, VCK */
if (ptr == inputInfo.pointer || ptr == inputInfo.keyboard)
{
rc = BadDevice;
goto unwind;
}
ptr = GetMaster(ptr, MASTER_POINTER);
rc = dixLookupDevice(&ptr, ptr->id, client, DixDestroyAccess);
if (rc != Success)
goto unwind;
keybd = GetMaster(ptr, MASTER_KEYBOARD);
rc = dixLookupDevice(&keybd, keybd->id, client, DixDestroyAccess);
if (rc != Success)
goto unwind;
XTestptr = GetXTestDevice(ptr);
rc = dixLookupDevice(&XTestptr, XTestptr->id, client, DixDestroyAccess);
if (rc != Success)
goto unwind;
XTestkeybd = GetXTestDevice(keybd);
rc = dixLookupDevice(&XTestkeybd, XTestkeybd->id, client,
DixDestroyAccess);
if (rc != Success)
goto unwind;
disable_clientpointer(ptr);
/* Disabling sends the devices floating, reattach them if
* desired. */
if (r->return_mode == XIAttachToMaster)
{
DeviceIntPtr attached,
newptr,
newkeybd;
rc = dixLookupDevice(&newptr, r->return_pointer, client, DixAddAccess);
if (rc != Success)
goto unwind;
if (!IsMaster(newptr))
{
client->errorValue = r->return_pointer;
rc = BadDevice;
goto unwind;
}
rc = dixLookupDevice(&newkeybd, r->return_keyboard,
client, DixAddAccess);
if (rc != Success)
goto unwind;
if (!IsMaster(newkeybd))
{
client->errorValue = r->return_keyboard;
rc = BadDevice;
goto unwind;
}
for (attached = inputInfo.devices; attached; attached = attached->next)
{
if (!IsMaster(attached)) {
if (GetMaster(attached, MASTER_ATTACHED) == ptr)
{
AttachDevice(client, attached, newptr);
flags[attached->id] |= XISlaveAttached;
}
if (GetMaster(attached, MASTER_ATTACHED) == keybd)
{
AttachDevice(client, attached, newkeybd);
flags[attached->id] |= XISlaveAttached;
}
}
}
}
/* can't disable until we removed pairing */
keybd->spriteInfo->paired = NULL;
ptr->spriteInfo->paired = NULL;
XTestptr->spriteInfo->paired = NULL;
XTestkeybd->spriteInfo->paired = NULL;
/* disable the remove the devices, XTest devices must be done first
else the sprites they rely on will be destroyed */
DisableDevice(XTestptr, FALSE);
DisableDevice(XTestkeybd, FALSE);
DisableDevice(keybd, FALSE);
DisableDevice(ptr, FALSE);
flags[XTestptr->id] |= XIDeviceDisabled | XISlaveDetached;
flags[XTestkeybd->id] |= XIDeviceDisabled | XISlaveDetached;
flags[keybd->id] |= XIDeviceDisabled;
flags[ptr->id] |= XIDeviceDisabled;
RemoveDevice(XTestptr, FALSE);
RemoveDevice(XTestkeybd, FALSE);
RemoveDevice(keybd, FALSE);
RemoveDevice(ptr, FALSE);
flags[XTestptr->id] |= XISlaveRemoved;
flags[XTestkeybd->id] |= XISlaveRemoved;
flags[keybd->id] |= XIMasterRemoved;
flags[ptr->id] |= XIMasterRemoved;
unwind:
return rc;
}
void GContactlessReaderManager::ProcessEventReceived(eEvents e, sDataEvent* pDataEvent)
{
switch (m_Status)
{
//======================================================================================================
case eStatusInitial:
{
switch (e)
{
case eEventSoftKeyL4:
{
NextState(eEventSoftKeyL4, eStatusInitial);
DisableDevice();
m_pCLRMenu->Quit();
}
break;
case eEventSoftKeyL3:
{
NextState(eEventSoftKeyR4, eSatusStatistics);
DisableDevice();
GoToStatistics();
}
break;
case eEventSoftKeyL1:
case eEventSoftKeyL2:
case eEventSoftKeyR1:
case eEventSoftKeyR2:
case eEventSoftKeyR3:
case eEventSoftKeyR4:
LOG(eContactlessReader, eTrace, "IGNORED EVENT [%s] received in [%s].\n", mst_arypcEventLabel[e], mst_arypcStatusLabel[m_Status]);
break;
case eEventRead:
{
NextState(eEventRead, eStatusInitial);
if(pDataEvent != NULL)
{
processData((GContactlessReaderServiceStatistics::eTypeStatistics)(pDataEvent->data));
}
GoToTestResultScreen();
}
break;
case eEventError:
{
NextState(eEventError, eStatusInitial);
}
break;
default:
LOG(eContactlessReader, eError, "ERROR: INVALID EVENT [%s] received in [%s].\n", mst_arypcEventLabel[e], mst_arypcStatusLabel[m_Status]);
break;
}
}
break;
//======================================================================================================
//======================================================================================================
case eSatusStatistics:
{
switch (e)
{
case eEventSoftKeyL4:
{
NextState(eEventSoftKeyL4, eStatusInitial);
EnableDevice();
GoToTestResultScreen();
}
break;
case eEventError:
{
NextState(eEventError, eSatusStatistics);
}
break;
default:
LOG(eContactlessReader, eError, "ERROR: INVALID EVENT [%s] received in [%s].\n", mst_arypcEventLabel[e], mst_arypcStatusLabel[m_Status]);
break;
}
}
break;
//======================================================================================================
case eStatusError:
{
switch (e)
{
default:
LOG(eContactlessReader, eError, "ERROR: event [%s] received in eStatusError. The Display device is in unrecoverable state.\n", mst_arypcEventLabel[e]);
NextState(e, eStatusError);
break;
}
}
break;
//======================================================================================================
}
if(pDataEvent != NULL)
{
delete pDataEvent;
pDataEvent = NULL;
}
}
__attribute__((weak)) void vPortSuppressTicksAndSleep(TickType_t xExpectedIdleTime) {
unsigned long ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickIncrements;
TickCounter_t tmp; /* because of how we get the current tick counter */
bool tickISRfired;
/* Make sure the tick timer reload value does not overflow the counter. */
if(xExpectedIdleTime>xMaximumPossibleSuppressedTicks) {
xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
}
/* Stop the tick timer momentarily. The time the counter is stopped for
* is accounted for as best it can be, but using the tickless mode will
* inevitably result in some tiny drift of the time maintained by the
* kernel with respect to calendar time.
*/
DISABLE_TICK_COUNTER();
/* Calculate the reload value required to wait xExpectedIdleTime
* tick periods. -1 is used because this code will execute part way
* through one of the tick periods.
*/
GET_TICK_CURRENT_VAL(&tmp);
ulReloadValue = tmp+(UL_TIMER_COUNTS_FOR_ONE_TICK*(xExpectedIdleTime-1UL));
if (ulReloadValue>ulStoppedTimerCompensation) {
ulReloadValue -= ulStoppedTimerCompensation;
}
/* Enter a critical section but don't use the taskENTER_CRITICAL()
* method as that will mask interrupts that should exit sleep mode.
*/
TICKLESS_DISABLE_INTERRUPTS();
/* If a context switch is pending or a task is waiting for the scheduler
* to be unsuspended then abandon the low power entry.
*/
if (eTaskConfirmSleepModeStatus()==eAbortSleep) {
ENABLE_TICK_COUNTER(); /* Restart SysTick. */
TICKLESS_ENABLE_INTERRUPTS();
} else {
#if configUSE_LP_TIMER
DisableDevice();
ClearInterruptFlag();
WriteCompareReg(xExpectedIdleTime-1);
EnableDevice(); /* start timer */
#else
SET_TICK_DURATION(ulReloadValue); /* Set the new reload value. */
RESET_TICK_COUNTER_VAL(); /* Reset the counter. */
ENABLE_TICK_COUNTER(); /* Restart tick timer. */
TICK_INTERRUPT_FLAG_RESET(); /* reset flag so we know later if it has fired */
#endif
/* Sleep until something happens. configPRE_SLEEP_PROCESSING() can
* set its parameter to 0 to indicate that its implementation contains
* its own wait for interrupt or wait for event instruction, and so wfi
* should not be executed again. However, the original expected idle
* time variable must remain unmodified, so a copy is taken.
*/
/* CPU *HAS TO WAIT* in the sequence below for an interrupt. If vOnPreSleepProcessing() is not used, a default implementation is provided */
/* default wait/sleep code */
__asm volatile("dsb");
__asm volatile("wfi");
__asm volatile("isb");
/* ----------------------------------------------------------------------------
* Here the CPU *HAS TO BE* low power mode, waiting to wake up by an interrupt
* ----------------------------------------------------------------------------*/
/* Stop tick counter. Again, the time the tick counter is stopped for is
* accounted for as best it can be, but using the tickless mode will
* inevitably result in some tiny drift of the time maintained by the
* kernel with respect to calendar time.
*/
tickISRfired = TICK_INTERRUPT_HAS_FIRED(); /* need to check Interrupt flag here, as might be modified below */
DISABLE_TICK_COUNTER();
TICKLESS_ENABLE_INTERRUPTS();/* Re-enable interrupts */
if (tickISRfired) {
/* The tick interrupt has already executed, and the timer
* count reloaded with the modulo/match value.
* Reset the counter register with whatever remains of
* this tick period.
*/
GET_TICK_CURRENT_VAL(&tmp);
#if COUNTS_UP
SET_TICK_DURATION((UL_TIMER_COUNTS_FOR_ONE_TICK-1UL)-tmp);
#else
SET_TICK_DURATION((UL_TIMER_COUNTS_FOR_ONE_TICK-1UL)-(ulReloadValue-tmp));
#endif
/* The tick interrupt handler will already have pended the tick
* processing in the kernel. As the pending tick will be
* processed as soon as this function exits, the tick value
* maintained by the tick is stepped forward by one less than the
* time spent waiting.
*/
ulCompleteTickPeriods = xExpectedIdleTime-1UL;
} else {
/* Something other than the tick interrupt ended the sleep.
* Work out how long the sleep lasted rounded to complete tick
* periods (not the ulReload value which accounted for part ticks).
*/
GET_TICK_CURRENT_VAL(&tmp);
ulCompletedSysTickIncrements = (xExpectedIdleTime*UL_TIMER_COUNTS_FOR_ONE_TICK)-tmp;
/* How many complete tick periods passed while the processor was waiting? */
ulCompleteTickPeriods = ulCompletedSysTickIncrements/UL_TIMER_COUNTS_FOR_ONE_TICK;
/* The reload value is set to whatever fraction of a single tick period remains. */
SET_TICK_DURATION(((ulCompleteTickPeriods+1)*UL_TIMER_COUNTS_FOR_ONE_TICK)-ulCompletedSysTickIncrements);
}
/* Restart SysTick so it runs from portNVIC_SYSTICK_LOAD_REG
again, then set portNVIC_SYSTICK_LOAD_REG back to its standard
value. The critical section is used to ensure the tick interrupt
can only execute once in the case that the reload register is near
zero.
*/
RESET_TICK_COUNTER_VAL();
portENTER_CRITICAL();
{
ENABLE_TICK_COUNTER();
vTaskStepTick(ulCompleteTickPeriods);
SET_TICK_DURATION(UL_TIMER_COUNTS_FOR_ONE_TICK-1UL);
}
portEXIT_CRITICAL();
}
}
/*
* xf86VTSwitch --
* Handle requests for switching the vt.
*/
static void
xf86VTSwitch(void)
{
int i;
static int prevSIGIO;
InputInfoPtr pInfo;
IHPtr ih;
DebugF("xf86VTSwitch()\n");
#ifdef XFreeXDGA
if(!DGAVTSwitch())
return;
#endif
/*
* Since all screens are currently all in the same state it is sufficient
* check the first. This might change in future.
*/
if (xf86Screens[0]->vtSema) {
DebugF("xf86VTSwitch: Leaving, xf86Exiting is %s\n",
BOOLTOSTRING((dispatchException & DE_TERMINATE) ? TRUE : FALSE));
#ifdef DPMSExtension
if (DPMSPowerLevel != DPMSModeOn)
DPMSSet(serverClient, DPMSModeOn);
#endif
for (i = 0; i < xf86NumScreens; i++) {
if (!(dispatchException & DE_TERMINATE))
if (xf86Screens[i]->EnableDisableFBAccess)
(*xf86Screens[i]->EnableDisableFBAccess) (i, FALSE);
}
/*
* Keep the order: Disable Device > LeaveVT
* EnterVT > EnableDevice
*/
for (ih = InputHandlers; ih; ih = ih->next)
xf86DisableInputHandler(ih);
for (pInfo = xf86InputDevs; pInfo; pInfo = pInfo->next) {
if (pInfo->dev) {
xf86ReleaseKeys(pInfo->dev);
ProcessInputEvents();
DisableDevice(pInfo->dev, TRUE);
}
}
prevSIGIO = xf86BlockSIGIO();
for (i = 0; i < xf86NumScreens; i++)
xf86Screens[i]->LeaveVT(i, 0);
xf86AccessLeave(); /* We need this here, otherwise */
if (!xf86VTSwitchAway()) {
/*
* switch failed
*/
DebugF("xf86VTSwitch: Leave failed\n");
xf86AccessEnter();
for (i = 0; i < xf86NumScreens; i++) {
if (!xf86Screens[i]->EnterVT(i, 0))
FatalError("EnterVT failed for screen %d\n", i);
}
if (!(dispatchException & DE_TERMINATE)) {
for (i = 0; i < xf86NumScreens; i++) {
if (xf86Screens[i]->EnableDisableFBAccess)
(*xf86Screens[i]->EnableDisableFBAccess) (i, TRUE);
}
}
dixSaveScreens(serverClient, SCREEN_SAVER_FORCER, ScreenSaverReset);
pInfo = xf86InputDevs;
while (pInfo) {
if (pInfo->dev)
EnableDevice(pInfo->dev, TRUE);
pInfo = pInfo->next;
}
for (ih = InputHandlers; ih; ih = ih->next)
xf86EnableInputHandler(ih);
xf86UnblockSIGIO(prevSIGIO);
} else {
#ifdef XF86PM
if (xf86OSPMClose)
xf86OSPMClose();
xf86OSPMClose = NULL;
#endif
for (i = 0; i < xf86NumScreens; i++) {
/*
* zero all access functions to
* trap calls when switched away.
*/
xf86Screens[i]->vtSema = FALSE;
}
if (xorgHWAccess)
xf86DisableIO();
}
} else {
DebugF("xf86VTSwitch: Entering\n");
if (!xf86VTSwitchTo()) return;
#ifdef XF86PM
xf86OSPMClose = xf86OSPMOpen();
#endif
if (xorgHWAccess)
xf86EnableIO();
xf86AccessEnter();
for (i = 0; i < xf86NumScreens; i++) {
xf86Screens[i]->vtSema = TRUE;
if (!xf86Screens[i]->EnterVT(i, 0))
FatalError("EnterVT failed for screen %d\n", i);
}
for (i = 0; i < xf86NumScreens; i++) {
if (xf86Screens[i]->EnableDisableFBAccess)
(*xf86Screens[i]->EnableDisableFBAccess)(i, TRUE);
}
/* Turn screen saver off when switching back */
dixSaveScreens(serverClient, SCREEN_SAVER_FORCER, ScreenSaverReset);
pInfo = xf86InputDevs;
while (pInfo) {
if (pInfo->dev)
EnableDevice(pInfo->dev, TRUE);
pInfo = pInfo->next;
}
for (ih = InputHandlers; ih; ih = ih->next)
xf86EnableInputHandler(ih);
xf86UnblockSIGIO(prevSIGIO);
}
}
//----------------------------------------------------------------------------------------------
// SetPower
//----------------------------------------------------------------------------------------------
NTSTATUS SetPower(
IN PDEVICE_OBJECT DeviceObject
,IN PDEVICE_EXTENSION DeviceExtension
,IN PIRP Irp
,IN PIO_STACK_LOCATION CurrentIrpStack )
{
// 変数宣言
NTSTATUS Status;
// デバイスの電源状態が変更された場合にデバイスの状態を変更する
#if (NTDDI_VERSION < NTDDI_LONGHORN)
switch( CurrentIrpStack->Parameters.Power.Type )
{
case SystemPowerState:
if( CurrentIrpStack->Parameters.Power.State.SystemState == PowerSystemWorking )
{
// デバイスをリセットする
DeviceExtension->ResetDevice = TRUE;
}
break;
}
// IRP_MJ_POWER 要求を下位ドライバに送る
Status = SendPowerRequest( DeviceObject, Irp );
#else
if( CurrentIrpStack->Parameters.Power.Type == DevicePowerState )
{
switch( CurrentIrpStack->Parameters.Power.State.DeviceState )
{
case PowerDeviceD0:
// 先に IRP_MN_SET_POWER 要求を下位ドライバに送る
Status = SendAndWaitPowerRequest( DeviceObject, Irp );
if( !NT_SUCCESS( Status ) )
{
CompleteRequest( Irp, Status, 0 );
return( Status );
}
// デバイスを有効にする
Status = EnableDevice( DeviceExtension );
// IRP_MN_SET_POWER 要求を完了させる
CompleteRequest( Irp, Status, 0 );
break;
case PowerDeviceD1:
case PowerDeviceD2:
case PowerDeviceD3:
// デバイスを無効にする
DisableDevice( DeviceExtension );
// IRP_MJ_POWER 要求を下位ドライバに送る
Status = SendPowerRequest( DeviceObject, Irp );
break;
default:
// IRP_MJ_POWER 要求を下位ドライバに送る
Status = SendPowerRequest( DeviceObject, Irp );
break;
}
} else {
// IRP_MJ_POWER 要求を下位ドライバに送る
Status = SendPowerRequest( DeviceObject, Irp );
}
#endif
return( Status );
}
void
EventListenerManager::RemoveEventListenerInternal(
const EventListenerHolder& aListenerHolder,
uint32_t aType,
nsIAtom* aUserType,
const nsAString& aTypeString,
const EventListenerFlags& aFlags,
bool aAllEvents)
{
if (!aListenerHolder || !aType || mClearingListeners) {
return;
}
Listener* listener;
uint32_t count = mListeners.Length();
uint32_t typeCount = 0;
bool deviceType = IsDeviceType(aType);
#ifdef MOZ_B2G
bool timeChangeEvent = (aType == NS_MOZ_TIME_CHANGE_EVENT);
bool networkEvent = (aType == NS_NETWORK_UPLOAD_EVENT ||
aType == NS_NETWORK_DOWNLOAD_EVENT);
#endif // MOZ_B2G
for (uint32_t i = 0; i < count; ++i) {
listener = &mListeners.ElementAt(i);
if (EVENT_TYPE_EQUALS(listener, aType, aUserType, aTypeString,
aAllEvents)) {
++typeCount;
if (listener->mListener == aListenerHolder &&
listener->mFlags.EqualsIgnoringTrustness(aFlags)) {
nsRefPtr<EventListenerManager> kungFuDeathGrip(this);
mListeners.RemoveElementAt(i);
--count;
mNoListenerForEvent = NS_EVENT_NULL;
mNoListenerForEventAtom = nullptr;
if (mTarget && aUserType) {
mTarget->EventListenerRemoved(aUserType);
}
if (!deviceType
#ifdef MOZ_B2G
&& !timeChangeEvent && !networkEvent
#endif // MOZ_B2G
) {
return;
}
--typeCount;
}
}
}
if (!aAllEvents && deviceType && typeCount == 0) {
DisableDevice(aType);
#ifdef MOZ_B2G
} else if (timeChangeEvent && typeCount == 0) {
nsCOMPtr<nsPIDOMWindow> window = GetTargetAsInnerWindow();
if (window) {
window->DisableTimeChangeNotifications();
}
} else if (!aAllEvents && networkEvent && typeCount == 0) {
nsCOMPtr<nsPIDOMWindow> window = GetTargetAsInnerWindow();
if (window) {
window->DisableNetworkEvent(aType);
}
#endif // MOZ_B2G
}
}
int
ProcXChangeDeviceControl(ClientPtr client)
{
unsigned len;
int i, status, ret = BadValue;
DeviceIntPtr dev;
xDeviceResolutionCtl *r;
xChangeDeviceControlReply rep;
AxisInfoPtr a;
CARD32 *resolution;
xDeviceEnableCtl *e;
REQUEST(xChangeDeviceControlReq);
REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
len = stuff->length - bytes_to_int32(sizeof(xChangeDeviceControlReq));
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess);
if (ret != Success)
goto out;
rep = (xChangeDeviceControlReply) {
.repType = X_Reply,
.RepType = X_ChangeDeviceControl,
.sequenceNumber = client->sequence,
.length = 0
};
switch (stuff->control) {
case DEVICE_RESOLUTION:
r = (xDeviceResolutionCtl *) &stuff[1];
if ((len < bytes_to_int32(sizeof(xDeviceResolutionCtl))) ||
(len !=
bytes_to_int32(sizeof(xDeviceResolutionCtl)) + r->num_valuators)) {
ret = BadLength;
goto out;
}
if (!dev->valuator) {
ret = BadMatch;
goto out;
}
if ((dev->deviceGrab.grab) && !SameClient(dev->deviceGrab.grab, client)) {
rep.status = AlreadyGrabbed;
ret = Success;
goto out;
}
resolution = (CARD32 *) (r + 1);
if (r->first_valuator + r->num_valuators > dev->valuator->numAxes) {
ret = BadValue;
goto out;
}
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) r);
if (status == Success) {
a = &dev->valuator->axes[r->first_valuator];
for (i = 0; i < r->num_valuators; i++)
if (*(resolution + i) < (a + i)->min_resolution ||
*(resolution + i) > (a + i)->max_resolution)
return BadValue;
for (i = 0; i < r->num_valuators; i++)
(a++)->resolution = *resolution++;
ret = Success;
}
else if (status == DeviceBusy) {
rep.status = DeviceBusy;
ret = Success;
}
else {
ret = BadMatch;
}
break;
case DEVICE_ABS_CALIB:
case DEVICE_ABS_AREA:
/* Calibration is now done through properties, and never had any effect
* on anything (in the open-source world). Thus, be honest. */
ret = BadMatch;
break;
case DEVICE_CORE:
/* Sorry, no device core switching no more. If you want a device to
* send core events, attach it to a master device */
ret = BadMatch;
break;
case DEVICE_ENABLE:
e = (xDeviceEnableCtl *) &stuff[1];
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) e);
if (status == Success) {
if (e->enable)
EnableDevice(dev, TRUE);
else
DisableDevice(dev, TRUE);
ret = Success;
}
else if (status == DeviceBusy) {
rep.status = DeviceBusy;
ret = Success;
}
else {
ret = BadMatch;
}
break;
default:
ret = BadValue;
}
out:
if (ret == Success) {
devicePresenceNotify dpn = {
.type = DevicePresenceNotify,
.time = currentTime.milliseconds,
.devchange = DeviceControlChanged,
.deviceid = dev->id,
.control = stuff->control
};
SendEventToAllWindows(dev, DevicePresenceNotifyMask,
(xEvent *) &dpn, 1);
WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
}
return ret;
}
/***********************************************************************
*
* This procedure writes the reply for the xChangeDeviceControl function,
* if the client and server have a different byte ordering.
*
*/
void
SRepXChangeDeviceControl(ClientPtr client, int size,
xChangeDeviceControlReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, rep);
}
/// \brief Motion is stopped immediatley
/// \details All motion with the MCDC device is killed using the "DI" command
/// \pre MCDC is still connected on the given COM port
/// \post Motor brakes heavily and stops spinning/moving.
void MotionController::Stop(void)
{
DisableDevice(); //Send kill command to MCDC (stops the motor instantly)
m_currentState = Stopped;
}
/// \brief Lock or unlock the motor based on the input boolean parameter (defaults to lock)
/// \details Use the kill command ("DI") followed by the enable command ("EN") to lock the motor
/// \pre MCDC is still connected on the given COM port
/// \post Motor is locked in its current position or unlocked depending on value of boolean "lock"
void MotionController::LockMotor(bool lock/*=true*/)
{
if(!lock) DisableDevice();
else EnableDevice();
}