tmtask.c

wince host 和 target PCI驱动程序

/* 
	taskmCreateTask

	Since the task opening happens in different phases it has to be 
	implemented as a finite state machine, that changes state every time there
	is a callback from the DSP. 
*/
STATUS	taskmCreateTask ( PVOID	pObject, PVOID TaskCreateArg, PDWORD Handle )
{
	PTMTASK_MGR_OBJECT	this	=  ( PTMTASK_MGR_OBJECT )pObject;
	PTMTASK_OBJECT		pTask;
	PTMIF_STRUCT_TASKCREATE		TaskCreate = 
		(PTMIF_STRUCT_TASKCREATE)TaskCreateArg;
	TMSTD_PACKET		Packet;
	DWORD				IdxTask;
	STATUS				Status;

	// find the task object

	pTask = NULL;

	if ( this->AllocatedCount >= this->TaskCount )
	{
		Status = TM_STATUS(TMTASK_ERR_OUTOFTASKS);
		goto	taskmCreateTask_fail1;
	}

	for ( IdxTask = 0 ; IdxTask < this->TaskCount ; IdxTask ++ )
	{
		if ( ! this->pTaskTab[IdxTask] )
		{
			break;
		}
	}

	if ( ( pTask = vxdMalloc ( sizeof ( TMTASK_OBJECT ) ) ) == NULL )
	{
		Status  = TM_STATUS ( TMTASK_ERR_OBJALLOCFAIL );
		goto	taskmCreateTask_fail2;
	}

	this->pTaskTab[IdxTask] = (PVOID)pTask;
	this->AllocatedCount++;
	FlagSet ( pTask->Flags, TMTASK_TASK_FLAG_ALLOCATED );
	pTask->Size = sizeof (TMTASK_OBJECT);
	pTask->pContainer = this->pContainer;
	pTask->Idx = IdxTask;

	pTask->dwPriority = TaskCreate->dwPriority;
	pTask->dwStackSize = TaskCreate->dwStackSize;
	vxdStrCopy ( TaskCreate->szTaskFile, pTask->szTaskFile );
	pTask->ClientHandle = TaskCreate->ClientHandle;
	pTask->Callback 	= TaskCreate->dwCallback;
	pTask->pContext 	= TaskCreate->pvContext;

	/* no requests pending in the queue so dump the request directly */
	Packet.dwCommand = TMHD_TASK_CREATE;
	Packet.dwArgument[TMHD_TASK_ARGHOSTTASK] = (DWORD)pTask;

	if ( this->fRequestInService )
	{
		if ( cqueueInsert ( this->pTaskRequestQ , &Packet ) != TRUE )
		{
			Status  = TM_STATUS ( TMTASK_ERR_QINSERTFAIL );
			goto	taskmCreateTask_fail3;
		}
	}
	else
	{
		this->pSharedData->dwPriority = pTask->dwPriority;
		this->pSharedData->dwStackSize = pTask->dwStackSize;
		vxdStrCopy ( pTask->szTaskFile, this->pSharedData->szTaskFile );
	
		if ( ( Status = chnlPacketSend ( this->pSysChnlSend, &Packet ) ) != TMOK )
		{
			Status  = TM_STATUS ( TMTASK_ERR_CHNLSENDFAIL );
			goto	taskmCreateTask_fail3;
		}
		else
		{
			this->fRequestInService = TRUE;
		}
	}

	*Handle = (DWORD)pTask;
	return TMOK;

taskmCreateTask_fail3:
	vxdFree( pTask );

taskmCreateTask_fail2:
	FlagClr ( pTask->Flags, TMTASK_TASK_FLAG_ALLOCATED );

taskmCreateTask_fail1:
	return Status;
}

STATUS	taskStart ( DWORD dwHandle )
{
	PTMTASK_OBJECT		this = ( PTMTASK_OBJECT) dwHandle;
	TMSTD_PACKET		Packet;
	STATUS				Status = TMOK;
	PTMTASK_MGR_OBJECT	pTaskMgr	=  GetTaskMgrObject ( this->pContainer );

	if ( ( Status = taskValidateHandle ( this ) ) != TMOK )
	{
		return Status;
	}

	Packet.dwCommand = TMHD_TASK_START;
	Packet.dwArgument[TMHD_TASK_ARGHOSTTASK] = (DWORD)this;
	Packet.dwArgument[TMHD_TASK_ARGDSPTASK]	= this->dwDSPTaskHandle;

	// queue up the request if there is already one in service
	if ( pTaskMgr->fRequestInService )
	{
		if ( cqueueInsert ( pTaskMgr->pTaskRequestQ , &Packet ) != TRUE )
		{
			Status  = TM_STATUS ( TMTASK_ERR_QINSERTFAIL );
			goto	taskStartExit1;
		}
	}
	else
	{
		if ( ( Status = chnlPacketSend ( pTaskMgr->pSysChnlSend, &Packet ) ) != TMOK )
		{
			goto	taskStartExit1;
		}
		else
		{
			pTaskMgr->fRequestInService = TRUE;
		}
	}
taskStartExit1:
	return  Status;
}

STATUS	taskStop ( DWORD dwHandle )
{
	PTMTASK_OBJECT		this = ( PTMTASK_OBJECT) dwHandle;
	TMSTD_PACKET		Packet;
	STATUS				Status = TMOK;
	PTMTASK_MGR_OBJECT	pTaskMgr	=  GetTaskMgrObject ( this->pContainer );

	if ( ( Status = taskValidateHandle ( this ) ) != TMOK )
	{
		return Status;
	}

	Packet.dwCommand = TMHD_TASK_STOP;
	Packet.dwArgument[TMHD_TASK_ARGHOSTTASK] = (DWORD)this;
	Packet.dwArgument[TMHD_TASK_ARGDSPTASK]	= this->dwDSPTaskHandle;

	if ( pTaskMgr->fRequestInService )
	{
		if ( cqueueInsert ( pTaskMgr->pTaskRequestQ , &Packet ) != TRUE )
		{
			Status  = TM_STATUS ( TMTASK_ERR_QINSERTFAIL );
			goto	taskStopExit1;
		}
	}
	else
	{
		if ( ( Status = chnlPacketSend ( pTaskMgr->pSysChnlSend,
			&Packet ) ) != TMOK )
		{
			goto	taskStopExit1;
		}
		else
		{
			pTaskMgr->fRequestInService = TRUE;
		}
	}

taskStopExit1:
	return  Status;
}

STATUS	taskSignal ( DWORD dwHandle, DWORD State )
{
	PTMTASK_OBJECT		this = ( PTMTASK_OBJECT) dwHandle;
	TMSTD_PACKET		Packet;
	STATUS				Status = TMOK;
	PTMTASK_MGR_OBJECT	pTaskMgr	=  GetTaskMgrObject ( this->pContainer );

	if ( ( Status = taskValidateHandle ( this ) ) != TMOK )
	{
		return Status;
	}

	Packet.dwCommand = TMHD_TASK_SIGNAL;
	Packet.dwArgument[TMHD_TASK_ARGHOSTTASK] = (DWORD)this;
	Packet.dwArgument[TMHD_TASK_ARGDSPTASK]	= this->dwDSPTaskHandle;
	Packet.dwArgument[TMHD_TASK_ARGSTATUS]	= State;

	if ( pTaskMgr->fRequestInService )
	{
		if ( cqueueInsert ( pTaskMgr->pTaskRequestQ , &Packet ) != TRUE )
		{
			Status  = TM_STATUS ( TMTASK_ERR_QINSERTFAIL );
			goto	taskSignalExit1;
		}
	}
	else
	{
		if ( ( Status = chnlPacketSend ( pTaskMgr->pSysChnlSend,
			&Packet ) ) != TMOK )
		{
			goto	taskSignalExit1;
		}
		else
		{
			pTaskMgr->fRequestInService = TRUE;
		}
	}

taskSignalExit1:
	return  Status;
}

STATUS	taskDestroy ( DWORD dwHandle )
{
	PTMTASK_OBJECT		this = ( PTMTASK_OBJECT) dwHandle;
	TMSTD_PACKET		Packet;
	STATUS				Status = TMOK;
	PTMTASK_MGR_OBJECT	pTaskMgr	=  GetTaskMgrObject ( this->pContainer );

	if ( ( Status = taskValidateHandle ( this ) ) != TMOK )
	{
		return Status;
	}

	Packet.dwCommand = TMHD_TASK_DESTROY;
	Packet.dwArgument[TMHD_TASK_ARGHOSTTASK] = (DWORD)this;
	Packet.dwArgument[TMHD_TASK_ARGDSPTASK]	= this->dwDSPTaskHandle;

	if ( pTaskMgr->fRequestInService )
	{
		if ( cqueueInsert ( pTaskMgr->pTaskRequestQ , &Packet ) != TRUE )
		{
			Status  = TM_STATUS ( TMTASK_ERR_QINSERTFAIL );
			goto	taskDestroyExit1;
		}
	}
	else
	{
		if ( ( Status = chnlPacketSend ( pTaskMgr->pSysChnlSend, &Packet ) ) != TMOK )
		{
			goto	taskDestroyExit1;
		}
		else
		{
			pTaskMgr->fRequestInService = TRUE;
		}
	}


taskDestroyExit1:
	return Status;
}

STATUS	taskmDestroy ( PVOID pTaskMgr )
{
	PTMTASK_MGR_OBJECT	this = (PTMTASK_MGR_OBJECT)pTaskMgr;
	
	this->Size = 0;
	this->Flags = 0;
	chnlDestroy ( this->pSysChnlSend );
	chnlDestroy ( this->pSysChnlRecv );
	vxdFree ( this->pTaskTab );
	vxdFree ( this );
	return TMOK;
}


STATUS	taskmDestroyTaskByClnt  ( PVOID pObject, DWORD dwClientHandle )
{
	PTMTASK_MGR_OBJECT	this	=  ( PTMTASK_MGR_OBJECT )pObject;
	PTMTASK_OBJECT		pTask; 

	DWORD	IdxTask;

	for ( IdxTask = 0 ; IdxTask < this->TaskCount ; IdxTask ++ )
	{
		pTask = this->pTaskTab[IdxTask];

		if ( ! pTask )
			continue;

		if ( ! FlagGet ( pTask->Flags, 
			TMTASK_TASK_FLAG_ALLOCATED ) )
			continue;

		if ( pTask->ClientHandle != dwClientHandle )
			continue; 

		taskDestroy ( (DWORD)pTask );
	}
	
	return TMOK;

}

STATUS	taskValidateHandle ( PVOID  TaskObject )
{
	PTMTASK_OBJECT this = (PTMTASK_OBJECT)TaskObject;

	if ( ! TaskObject )
		goto taskValidateHandle_fail;

	if ( this->Size != sizeof(TMTASK_OBJECT) )
		goto taskValidateHandle_fail;

	if ( ! FlagGet ( this->Flags, TMTASK_TASK_FLAG_ALLOCATED ) )
		goto taskValidateHandle_fail;

	return TMOK;

taskValidateHandle_fail :
	DP(0,"TM:taskValidateHandle:Task[%x]:FAIL\n",TaskObject);
	return TMTASK_ERR_INVALIDHANDLE;
}