void
com_ximeta_driver_NDASProtocolTransport::CompleteSCSITask (
com_ximeta_driver_NDASCommand *NDCmd_ptr
)
{
SCSITaskIdentifier scsiTask = NULL;
SCSIServiceResponse serviceResponse = kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE;
SCSITaskStatus taskStatus = kSCSITaskStatus_No_Status;
IOByteCount bytesTransfered = 0;
PSCSICommand scsiCommand_Ptr = NULL;
DbgIOLog(DEBUG_MASK_DISK_TRACE, ("CompleteSCSITask: Entered. 0x%x\n", NDCmd_ptr));
scsiCommand_Ptr = NDCmd_ptr->scsiCommand();
if ( scsiCommand_Ptr->CmdData.taskStatus == kSCSITaskStatus_GOOD )
{
bytesTransfered = scsiCommand_Ptr->CmdData.xferCount;
}
DbgIOLog(DEBUG_MASK_DISK_INFO, ("CompleteSCSITask: task 0x%x xferCount %u result 0x%x\n", scsiCommand_Ptr->scsiTask, bytesTransfered, scsiCommand_Ptr->CmdData.results));
SetRealizedDataTransferCount ( scsiCommand_Ptr->scsiTask, bytesTransfered );
// re-entrancy protection
scsiTask = scsiCommand_Ptr->scsiTask;
if(scsiCommand_Ptr->CmdData.results == kIOReturnSuccess) {
serviceResponse = kSCSIServiceResponse_TASK_COMPLETE;
} else {
serviceResponse = kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE;
}
taskStatus = scsiCommand_Ptr->CmdData.taskStatus;
scsiCommand_Ptr->scsiTask = NULL;
// fProvider->clearCommand();
CommandCompleted ( scsiTask, serviceResponse, taskStatus );
scsiTask->release();
DbgIOLog(DEBUG_MASK_DISK_INFO, ("CompleteSCSITask: End task 0x%x task status 0x%x\n", scsiTask, taskStatus));
NDCmd_ptr->release();
/*
if ( true == bTerminating ) {
DebugPrint(1, false, "%s: CompleteSCSITask call didTerminate\n", getName () );
bool defer = false;
IOService::didTerminate(TerminationProvider, TerminationOptions, &defer);
}
*/
return;
}
//data is available on one of the thread-safe queues.
void pv_metadata_engine_test::ThreadSafeQueueDataAvailable(ThreadSafeQueue* aQueue)
{
if (aQueue == &iThreadSafeCommandQueue)
{
for (uint32 ndata = 1; ndata;)
{
ThreadSafeQueueId id;
OsclAny* data;
ndata = iThreadSafeCommandQueue.DeQueue(id, data);
if (ndata)
{
PVCmdResponse* cmd = (PVCmdResponse*)data;
CommandCompleted(*cmd);
OSCL_DELETE(cmd);
}
}
}
if (aQueue == &iThreadSafeErrorQueue)
{
for (uint32 ndata = 1; ndata;)
{
ThreadSafeQueueId id;
OsclAny* data;
ndata = iThreadSafeErrorQueue.DeQueue(id, data);
if (ndata)
{
int32 eventType = (PVMFEventType)data;
PVAsyncErrorEvent event(eventType);
HandleErrorEvent(event);
}
}
}
if (aQueue == &iThreadSafeInfoQueue)
{
for (uint32 ndata = 1; ndata;)
{
ThreadSafeQueueId id;
OsclAny* data;
ndata = iThreadSafeInfoQueue.DeQueue(id, data);
if (ndata)
{
int32 eventType = (PVMFEventType)data;
PVAsyncInformationalEvent event(eventType);
HandleInformationalEvent(event);
}
}
}
}
void QueueManager::run()
{
SetStatus(QM_STARTING);
m_isRunning = true;
m_ruleManager.Load(config.RULES_LOCATION);
SetStatus(QM_LOADING);
m_controllerLoaded = ControllerLoad();
int res = 0;
// flush queue commented because of cmd line (will wake up queue)
// m_queueCommands.clear();
struct x10_ha_command x10CmdRecv;
Logger::Log(DEBUG, "** QueueManager Entering loop", qPrintable(StatusStr()));
while (m_isRunning)
{
QMutexLocker locker(&m_mutex);
unsigned int nbErrors = 0;
// while nothing to send
while (m_isRunning && !m_queueCommands.size())
{
/// Read input.
if (m_controllerLoaded)
{
res = m_X10Controller->x10_recv(&x10CmdRecv);
if (res > 0)
{
nbErrors = 0;
Logger::Log(INFO, "X10 command received on house %c unit %d, cmd:%s res:%d", house_code_to_char(x10CmdRecv.house), unit_code_to_int(x10CmdRecv.unit), cmd_code_to_str(x10CmdRecv.cmd), res);
// emit CommandReceived(*cmd);
QString address = QString("%1%2")
.arg(house_code_to_char(x10CmdRecv.house))
.arg(unit_code_to_int(x10CmdRecv.unit))
.toUpper();
CheckContainerExist(address);
switch (x10CmdRecv.cmd)
{
case X10CMD_ON:
Containers[address]->SetOn(true);
break;
case X10CMD_OFF:
Containers[address]->SetOn(false);
break;
case X10CMD_BRIGHT:
Containers[address]->PushDirection(true);
break;
case X10CMD_DIM:
Containers[address]->PushDirection(false);
break;
case X10CMD_UP:
case X10CMD_RIGHT:
case X10CMD_DOWN:
case X10CMD_LEFT:
break;
case X10CMD_INVALID:
break;
}
emit CommandReceived();
}
else if (res && res != -110 /*&& res != -1*/) // first res is -1
{
// Logger::Log(ERROR, "res = -1 !!", res);
nbErrors++;
Logger::Log(DEBUG, "ERROR: (%d)", res);
if (nbErrors > config.MAX_ERRORS)
break;
}
}
queueNotEmpty.wait(&m_mutex, 1000);
}
if (nbErrors > config.MAX_ERRORS) // reload controller
{
ControllerUnload();
if (!config.RELOAD_ON_ERROR)
{
Logger::Log(ERROR, "X10 Interface died, quitting QueueManager thread");
break;
}
nbErrors = 0;
ControllerLoad();
continue;
}
COMMAND* cmd = 0;
if (m_isRunning && m_queueCommands.size()) // not supposed to be empty at this point
{
cmd = m_queueCommands.back();
// when receiving it, it is this engine role to figure out how
if (cmd->command == CMD_SET)
{
COMMAND* intermCmd;
int nbSteps = GetNextCommand(*cmd, &intermCmd);
// unique step or nothing to do
if (nbSteps <= 1)
m_queueCommands.remove(cmd);
if (nbSteps)
{
if (!cmd->notified)
{
emit CommandCompleted(*cmd);
cmd->notified = true;
}
intermCmd->notified = true; // not to be resent by subcmd
}
// Logger::Log(DEBUG, "** SET to %d produced %d steps", cmd->value, nbSteps);
cmd = intermCmd; // null if nothing to do
}
else
{
// Logger::Log(DEBUG, "** SEND command");
m_queueCommands.remove(cmd); // 1 step per command
}
}
locker.unlock();
if (!cmd)
continue; // end marker
x10_ha_command* x10cmd = new_x10_ha_command(parse_cmd_code(cmd->command), cmd->channel, cmd->unit);
if (x10cmd) // else params out of bound
{
QString address = cmd->address();
CheckContainerExist(address); // for read
int currentValue = Containers[address]->Value();
switch (cmd->command)
{
case CMD_SET:
Containers[address]->SetValue(cmd->value);
break;
case CMD_ON:
Containers[address]->SetValue(currentValue < 0 ? MAX_VALUE : currentValue);
break;
case CMD_OFF:
Containers[address]->SetValue(-1);
break;
case CMD_DIM:
if (currentValue == -1) currentValue = MAX_VALUE;
Containers[address]->SetValue(currentValue ? currentValue - 1 : 0);
break;
case CMD_BRIGHT:
if (currentValue == -1)
currentValue = MAX_VALUE;
Containers[address]->SetValue(currentValue >= MAX_VALUE ? MAX_VALUE : currentValue + 1);
break;
default:
break;
}
if (m_controllerLoaded)
{
// emit CommandCompleted if not SET
if (!cmd->notified)
emit CommandCompleted(*cmd);
m_X10Controller->x10_send(x10cmd);
}
else
{
Logger::Log(ERROR, "NO Controller to send Command %s", qPrintable(cmd->commandStr()));
}
del_x10_ha_command(x10cmd);
}
delete cmd;
}
ControllerUnload();
SetStatus(QM_STOPPED);
}
