tmtask.c

wince host 和 target PCI驱动程序

		goto taskmCreateFail4;
	}
	
	tmParameterDWORDGet ( TMHD_PARAM_TASK, (PDWORD)&this->pSharedData );
	
	if ( ( PSOSStatus = q_create ( 
		"tmsq", 0, Q_NOLIMIT | Q_PRIOR, &this->QueueIDSystem  ) ) != 0 )
	{
		Status = TM_STATUS ( TMTASK_ERR_QUEUESYSCREATEFAIL );
		DT(0, "tmos:taskmCreate:q_create:tmsq:FAIL[%x]\n", PSOSStatus );
		goto taskmCreateFail4;
	}
        

	/* create task to serve requests from teh host */

	if ( ( PSOSStatus = t_create ( 
		"tmst", 				/* 4 character task name */
		230,						/* priority */
		0x10000,				/* supervisor stack size */
		0x10000,				/* user stack size */
		0,						/* flags */
		&this->TaskIDSystem 				/*  Ptr to Task ID */
		) ) != 0 )
	{
		Status = TM_STATUS ( TMTASK_ERR_TASKSYSCREATEFAIL );
		DT(0, "tmos:taskmCreate:t_create:tmst:FAIL[%x]\n", PSOSStatus );
		goto	taskmCreateFail4;
	}

	if ( ( PSOSStatus = t_start ( 					 
		this->TaskIDSystem ,			/* task DI returned by t_create */
		T_PREEMPT | T_TSLICE | T_ASR | T_ISR, /* flags */
		TaskSystem,				/* task function */
		0					/* task startup args */
		) ) != 0 )
	{

		Status = TM_STATUS ( TMTASK_ERR_TASKSYSSTARTFAIL );
		DT(0, "tmos:taskmCreate:t_start:tmst:FAIL[%x]\n", PSOSStatus );
		goto	taskmCreateFail4;
	}

	*ppTaskMgr = this;
	return TMOK;


taskmCreateFail6 :
	t_delete ( this->TaskIDSystem );

taskmCreateFail7 :
	q_delete ( this->QueueIDSystem );

taskmCreateFail5 :
	chnlDestroy ( this->pSysChnlRecv );

taskmCreateFail4 :
	chnlDestroy ( this->pSysChnlSend );

taskmCreateFail3 :
	free ( this->pTaskTab );

taskmCreateFail2 :
	free ( this );

taskmCreateFail1 :
	return Status;

}

/* 
	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, DWORD dwHostHandle, PDWORD Handle )
{
	PTMTASK_MGR_OBJECT	this	=  ( PTMTASK_MGR_OBJECT )pObject;
	PTMTASK_OBJECT		pTask;
	TMSTD_PACKET		Packet;
	DWORD				IdxTask;
	STATUS				Status;
	DWORD PSOSStatus;
	DynLoad_Status DynLoadStatus;
	pTask = NULL;

	if ( this->AllocatedCount >= this->TaskCount )
	{
		Status = TM_STATUS(TMTASK_ERR_OUTOFTASKS);
		PRINTF(( "tmos:taskmCreateTask:No Mote Task Slots:FAIL\n"));
		goto	taskmCreateTaskExit1;
	}

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

	if ( ( pTask = malloc ( sizeof ( TMTASK_OBJECT ) ) ) == NULL )
	{
		Status  = TM_STATUS ( TMTASK_ERR_OBJALLOCFAIL );
		PRINTF(( "tmos:taskmCreateTask:NoMoreMemory:FAIL\n"));
		goto	taskmCreateTaskExit1;
	}

	this->pTaskTab[IdxTask] = (PVOID)pTask;
	this->AllocatedCount++;
	FlagSet ( pTask->Flags, TMTASK_TASK_FLAG_ALLOCATED );
	pTask->Idx = IdxTask;
	pTask->dwHostHandle = dwHostHandle;
	pTask->dwPriority = this->pSharedData->dwPriority;
	pTask->dwStackSize = this->pSharedData->dwStackSize;
	pTask->dwState = 0;
	strcpy ( pTask->szTaskFile, this->pSharedData->szTaskFile );


#ifdef	USE_DYNALOAD
	
	if ( ( DynLoadStatus = DynLoad_load_application ( 
		pTask->szTaskFile, 
		(DynLoad_Code_Segment_Handle *)(&pTask->DynLoadHandle) ) ) != DynLoad_OK )
	{
		/* handle cannot find executable error here. */
		Status  = TM_STATUS ( TMTASK_ERR_DLLOADFAIL );
		PRINTF(("taskmCreateTask:DynLoad_load:TaskName[%s]:Status[%x]:FAIL\n", pTask->szTaskFile, DynLoadStatus ));

		goto	taskmCreateTaskExit2;
	}

	PRINTF(("taskmCreateTask:DynLoad_load:TaskName[%s]:Status[%x]\n",	pTask->szTaskFile, DynLoadStatus ));
#endif
	if ( ( PSOSStatus = t_create ( 
		&pTask->dwHostHandle,	/* 4 character task name */
		pTask->dwPriority,	/* priority */
		0x10000,					/* supervisor stack size */
		pTask->dwStackSize,	/* user stack size */
		0,							/* flags */
		&pTask->OSTaskID ) ) != 0 )	/*  Ptr to Task ID */
	{
		Status  = TM_STATUS ( TMTASK_ERR_TASKCREATEFAIL );
		PRINTF(( "tmos:taskmCreateTask:t_create:FAIL[%x]\n",PSOSStatus));
		goto	taskmCreateTaskExit3;
	}

	PRINTF(( "taskmCreateTask:t_create:TaskID[%x]:Status[%x]\n", pTask->OSTaskID, PSOSStatus ));
	
	*Handle = (DWORD)pTask;
	return TMOK;

taskmCreateTaskExit4:
	t_delete ( pTask->OSTaskID );

taskmCreateTaskExit3:
	DynLoad_unload_application ( pTask->DynLoadHandle);

taskmCreateTaskExit2:
	this->pTaskTab[IdxTask] = NULL;
	this->AllocatedCount--;
	FlagClr ( pTask->Flags, TMTASK_TASK_FLAG_ALLOCATED );
	free ( pTask );

taskmCreateTaskExit1:
	return Status;
}

STATUS	taskStop ( DWORD dwHandle )
{
	PTMTASK_OBJECT		this = ( PTMTASK_OBJECT) dwHandle;
	DWORD PSOSStatus;
	PSOSStatus = t_suspend ( this->OSTaskID );
	DT(0,"tmos:taskStop:t_suspend:ID[%x]:FAIL[%x]\n",this->OSTaskID, PSOSStatus);

	PRINTF(( "taskStop:t_suspend:Status[%x] \n", PSOSStatus ));

	return TMOK;
}

STATUS	taskGetState ( DWORD OSTaskID, PDWORD StatePtr )
{
	PTMTASK_MGR_OBJECT		this = ( PTMTASK_MGR_OBJECT)GetTaskMgrObject ( );
	STATUS				Status = TMOK;
	DWORD				IdxTask;

	for ( IdxTask = 0 ; IdxTask < this->TaskCount ; IdxTask ++ )
	{
		if ( this->pTaskTab[IdxTask]->OSTaskID == OSTaskID )
		{
			*StatePtr = this->pTaskTab[IdxTask]->dwState;
			return TMOK;
		}
	}
	
	return TMTASK_ERR_INVALIDOBJECT;
}

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

	if ( ( PSOSStatus = t_start ( 					 
		this->OSTaskID,	/* task DI returned by t_create */
		T_PREEMPT | T_TSLICE | T_ASR | T_ISR, /* flags */
	#ifdef	USE_DYNALOAD
		((DynLoad_Code_Segment_Handle)this->DynLoadHandle)->start,
	#else
		Task2,
	#endif
		0 ) ) != 0 )					/* task startup args */
	{
		PRINTF(("tmos:taskStart:t_create:ID[%x]:FAIL[%x]\n",this->OSTaskID, PSOSStatus));
		Status  = TM_STATUS ( TMTASK_ERR_TASKSTARTFAIL );
		goto taskStartExit1;
	}
	
	PRINTF(( "taskStart:t_start:Function[%x]:Status[%x] \n", 
		((DynLoad_Code_Segment_Handle)this->DynLoadHandle)->start,
		PSOSStatus ));

	
taskStartExit1:
	return  Status;
}

STATUS	taskDestroy ( DWORD dwHandle )
{
	PTMTASK_OBJECT		this = ( PTMTASK_OBJECT) dwHandle;
	PTMTASK_MGR_OBJECT	pTaskMgr	=  GetTaskMgrObject ( );

	t_delete ( this->OSTaskID );

#ifdef	USE_DYNALOAD
	DynLoad_unload_application ( 
		((DynLoad_Code_Segment_Handle)this->DynLoadHandle)->name );

#endif
	PRINTF(( "taskDestroy:DynLoad_unload\n" ));

	pTaskMgr->pTaskTab[this->Idx] = NULL;
	pTaskMgr->AllocatedCount--;
	FlagClr ( this->Flags, TMTASK_TASK_FLAG_ALLOCATED );
	free ( this );

	return TMOK;
}

STATUS	taskmDestroy ( PVOID pTaskMgr )
{
	PTMTASK_MGR_OBJECT	this = (PTMTASK_MGR_OBJECT)pTaskMgr;

	t_suspend ( this->TaskIDSystem );

	t_delete ( this->TaskIDSystem );
	
	q_delete ( this->QueueIDSystem );
	
	chnlDestroy ( this->pSysChnlRecv );

	chnlDestroy ( this->pSysChnlSend );

	free ( this->pTaskTab );
	this->Size = 0;
	this->Flags = 0;
	free ( this );
	return TMOK;
}