/************************************************************************************
 * taskManager.c                                                             
 *
 *  synopsis: This file contains routines which organize tasks, which are run in a
 *            list on each iteration through the main polling loop. They manage a
 *    variety of tasks related to event-trapping and analysis on the slave DSPs, and
 *    monitoring functions on the master DSP. If a task gathers data, it will not
 *    send the data onward, but rather accumulate it in an internal list for a
 *    primitive to process and output. The difference between tasks and primitives is
 *    that tasks run in parallel, in the background, while a primitive list calls
 *    primitives sequentially. If a primitive in the list needs repeating it returns
 *    REPEAT_PRIMITIVE to execPrim(). This allows primitives to continue operating,
 *    but no other primitives can run meanwhile. The task manager calls each task on
 *    the task list in insertion order, so tasks run in "parallel". If a primitive
 *    list is handed to the DSP it will execute normally with the tasks running in
 *    the background beside it. Resource conflicts must be determined & handled by
 *    the operator.
 *
 *  nyi refinements:  a way for tasks to automatically pause themselves while a
 *                    list is running (needed? task-op: pause is there), & for tasks
 *                    to pause a list.
 *     
 *  in this file: setTaskState, getTaskState, initTaskManager, insertTask, taskOp,
 *                currentTask, getTaskData, taskManager, noTask,
 *
 *  related files:
 *   masterTasks.c: Contains the master DSP tasks.
 *   slaveTasks.c:  Contains the slave DSP tasks.
 *   primFuncts.c:  Contains the start & task operation primitives.
 *   primFuncts.h:  Declares the structure tag which communicates necessary information
 *                  to primitive functions.
 *   primParams.h:  Defines primitive ids which are used to index the array of pointers
 *                  to primitive functions, structure tags for primitive data and reply
 *     data, and prototypes of primitive functions. The task function input and
 *     output structures are defined here (for startTask & taskOperation).
 *
 *  Douglas Ferguson, UW Madison   (510) 486-5230                 dpferguson@lbl.gov
 ************************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stddef.h>

#include <csl.h>
#include <csl_mcbsp.h>

#include "resources.h"
#include "taskManager.h"
#include "comRegDfns.h"

extern char genStr[];
extern TIMER_Handle timer1;  /* general purpose timer, started in main() */

#if defined(I_AM_SLAVE_DSP)
	extern far struct EvtMgrCtrl evtMgrCtrl;
	extern far struct EventQueue eventQueue;
#endif

#pragma CODE_SECTION(setTaskState,    "xcode");
#pragma CODE_SECTION(getTaskState,    "xcode");
#pragma CODE_SECTION(initTaskManager, "xcode");
#pragma CODE_SECTION(insertTask,      "xcode");
#pragma CODE_SECTION(taskOp,          "xcode");
#pragma CODE_SECTION(currentTask,     "xcode");
#pragma CODE_SECTION(getTaskData,     "xcode");
#pragma CODE_SECTION(noTask,          "xcode");

#pragma CODE_SECTION(taskManager,     "icode");

/* file scope variables */
#pragma DATA_SECTION(taskMgrCtrl, "idata");
TaskMgrCtrl taskMgrCtrl, *taskMgrCtrlPtr;
TaskList    taskList;

/* task output structures array */
TaskOutput taskOut[MAX_NUM_TASKS];

/* file level routines */
INT32 noTask(TaskInput *, TaskOutput *, UINT32);

/************************************************************************************
 * set/getTaskState
 *
 *   synopsis:   setTaskState sets the appropriate nibble in the task state register
 *               to the input state, getTaskState retrieves the state for a given
 *               task.
 * 
 ************************************************************************************/
void setTaskState(UINT8 taskType, UINT8 state) {	
	UINT8 nibble;
	nibble= taskType -TASK_BASE;
	ASGN_RFLD(TASK_STATE_REG, nibble*4, 4, state);
}

UINT8 getTaskState(UINT8 taskType) {
	UINT8 nibble;
	nibble= taskType -TASK_BASE;
	return (UINT8) GET_RFLD(TASK_STATE_REG, nibble*4, 4);
}

/************************************************************************************
 * initTaskManager
 *
 *   synopsis:   Initializes all the variables & structures associated with
 *               the task manager.
 * 
 *   author: Douglas Ferguson
 ************************************************************************************/
INT32 initTaskManager() {	
	INT32 returnCode= SUCCESS;
	int i;
	
	taskMgrCtrlPtr= &taskMgrCtrl;
    taskMgrCtrl.taskIterations= 0;
    taskList.nTasks= 0;	
    
	setMem((UINT32 *) &taskMgrCtrl, SIZEOF(TaskMgrCtrl), 0);

    for (i=0; i<MAX_NUM_TASKS; ++i)
    	setMem((UINT32 *) &taskOut[i], SIZEOF(TaskOutput), 0);

    for (i=0; i<MAX_NUM_TASKS +1; ++i) {
		setMem((UINT32 *) &taskList.taskData[i], SIZEOF(TaskData), 0);
		taskList.taskData[i].taskFunction= noTask;
    }

	return returnCode;
}

/************************************************************************************
 * insertTask
 *   
 *   synopsis: Insert a task onto the task list, after checking that it is:
 *             a) currently not running,         b) not at a currently used priority,
 *             c) a task type that exists, and   d) a good version for that task.
 *     The task list execution is then controlled inside the taskManager function.
 *     Priority of execution is controlled via the priority field; after a task
 *     has been inserted, the list is re-ordered according to the priority. For
 *     currently defined tasks this doesn't matter much, but it is implemented in case
 *     a well-defined order of execution is desired in the future.
 * 
 *   author: Douglas Ferguson
 ************************************************************************************/
INT32 insertTask(UINT32 taskType, UINT32 taskRevision, UINT32 priority,
                 UINT32 completionFlag, TaskInput *taskStruct) {
	INT32  returnCode= SUCCESS;
	UINT8  taskErr= 0, priorityErr= 0, revisionErr= 0, nibble, i;

	UINT8 trapFxn;  //dpsf xxx
	
	INT32  (*taskFxn)(TaskInput *, TaskOutput *, UINT32);

	if ((priority>0xff)||(priority==0)) {
		newError(&returnCode, TASK_PRIORITY_MAX_ERROR, FATAL_ERR, "insertTask",
		   "Priority must range between 0 and 255. \n",
		   __FILE__, __LINE__);
		return returnCode;
	}

	/* check whether the task is already running, or there is another task running
	   at this priority level. */
	for (i=0; i<taskList.nTasks; ++i) {
		if (taskList.taskData[i].taskType == taskType)  taskErr= 1;
/*		if (taskList.taskData[i].priority == priority)  priorityErr= 1; */
	}	
	if (taskErr) {
		newError(&returnCode, TASK_DUPLICATE_ERROR, FATAL_ERR, "insertTask",
		   "A task of this type is already running on the DSP.\n", __FILE__, __LINE__);
		return returnCode;
	}
/*
	else if (priorityErr) {
		newError(&returnCode, TASK_PRIORITY_ERROR, FATAL_ERR, "insertTask",
		   "A task with this priority is already running on the DSP.",
		   __FILE__, __LINE__);
		return returnCode;
	}
*/	
	/* check to see that the task exists, set the running task register's nibble. */
	#if     defined(I_AM_MASTER_DSP)
		nibble= taskType -MASTER_TASK_BASE;
		if (taskType==HISTOGRAM_CTRL_TASK) {strcpy(genStr, "Scan Control "); }
		else if (taskType==MIRROR_TASK)    {strcpy(genStr, "Memory mirroring "); }
		else if (taskType==TRAP_REQ_TASK)  {strcpy(genStr, "Trap request monitoring ");}
		else  {taskErr= 1;}
	#elif   defined(I_AM_SLAVE_DSP)
		nibble= taskType -SLAVE_TASK_BASE;
		if      (taskType==HISTOGRAM_TASK) {strcpy(genStr, "Histogramming "); }
		else if (taskType==TRAP_TASK)      {strcpy(genStr, "Event trapping "); }
		else if (taskType==ERROR_TASK)     {strcpy(genStr, "Error counting "); }
		else if (taskType==OCCUPANCY_TASK) {strcpy(genStr, "Occupancy "); }
		else if (taskType==RESYNCH_TASK)   {strcpy(genStr, "Re-synchronization "); }
		else  {taskErr= 1;}
	#endif
	if ((taskErr)||(nibble>7)) { /* (nibble>7) ==> protect the task reg (see below) */
		newError(&returnCode, TASK_NONEXISTANT_ERROR, FATAL_ERR, "insertTask",
		   "This task type does not exist on this type of DSP!", __FILE__, __LINE__);
		return returnCode;
	}

	/* check to see that the task's revision number is good. */
	#if     defined(I_AM_MASTER_DSP)
		if      (   (  (taskType==HISTOGRAM_CTRL_TASK)
		             &&(taskRevision!=R_HISTOGRAM_CTRL_TASK))
		          ||((taskType==MIRROR_TASK)   &&(taskRevision!=R_MIRROR_TASK))   
		          ||((taskType==TRAP_REQ_TASK) &&(taskRevision!=R_TRAP_REQ_TASK))
		        ) {revisionErr= 1; }
	#elif   defined(I_AM_SLAVE_DSP)
		if      (   ((taskType==HISTOGRAM_TASK) &&(taskRevision!=R_HISTOGRAM_TASK))   
		          ||((taskType==TRAP_TASK)      &&(taskRevision!=R_TRAP_TASK))
		          ||((taskType==ERROR_TASK)     &&(taskRevision!=R_ERROR_TASK))
		          ||((taskType==OCCUPANCY_TASK) &&(taskRevision!=R_OCCUPANCY_TASK))
		          ||((taskType==RESYNCH_TASK)   &&(taskRevision!=R_RESYNCH_TASK))
		        ) {revisionErr= 1; }
	#endif
	if (revisionErr) {
		newError(&returnCode, TASK_REVISION_ERROR, FATAL_ERR, "insertTask",
		   "The requested task's DAQ version number is wrong.", __FILE__, __LINE__);
		return returnCode;
	}
	else {   /* all ok, insert task on list. */
		strcat(genStr, "task started on DSP.\n");
		newInformation(__FILE__, __LINE__, genStr);

		//taskMgrCtrl.runningTaskReg &= ~(0xf<<(nibble*4));
		//taskMgrCtrl.runningTaskReg |= (TASK_INIT<<(nibble*4));
		setTaskState(taskType, TASK_INIT);

		i= taskList.nTasks;
		taskList.taskData[i].taskType=     taskType;
		taskList.taskData[i].taskRevision= taskRevision;
		taskList.taskData[i].priority=     priority;
		taskList.taskData[i].completionFlag= completionFlag;
		taskList.taskData[i].state=          TASK_INIT;
		copyMem((UINT32 *) taskStruct, (UINT32 *) &taskList.taskData[i].taskStruct,
		        SIZEOF(TaskInput));

		#if     defined(I_AM_MASTER_DSP)
			if      (taskType==HISTOGRAM_CTRL_TASK) {taskFxn= histoCtrlTask; }
			else if (taskType==MIRROR_TASK)         {taskFxn= mirrorTask; }
			else if (taskType==TRAP_REQ_TASK)       {taskFxn= trapReqTask; }
			trapFxn= 0;
		#elif   defined(I_AM_SLAVE_DSP)
			/*
			if      (taskType==HISTOGRAM_TASK) {taskFxn= histogramTask; }
			else if (taskType==TRAP_TASK)      {taskFxn= trapTask; }
			else if (taskType==ERROR_TASK)     {taskFxn= errorTask; }
			else if (taskType==OCCUPANCY_TASK) {taskFxn= occupancyTask; }
			else if (taskType==RESYNCH_TASK)   {taskFxn= resynchTask; }
			*/
			//dpsf xxx
			if      (taskType==HISTOGRAM_TASK) {taskFxn= histogramTask; trapFxn= TRAP_FXN_HISTOGRAM; }
			else if (taskType==TRAP_TASK)      {taskFxn= trapTask;      trapFxn= TRAP_FXN_TRAP; }
			else if (taskType==ERROR_TASK)     {taskFxn= errorTask;     trapFxn= TRAP_FXN_OCCUPANCY; }
			else if (taskType==OCCUPANCY_TASK) {taskFxn= occupancyTask; trapFxn= TRAP_FXN_ERRORCNT; }
			else if (taskType==RESYNCH_TASK)   {taskFxn= resynchTask;   trapFxn= TRAP_FXN_RESYNCH; }

		#endif
		taskList.taskData[i].taskFunction= taskFxn;
		taskList.taskData[i].trapFxn= trapFxn;   //dpsf xxx

		++taskList.nTasks;
		ASGN_RFLD(STATUS_REG_0, SR_NTASKS, SR_NTASKS_W, taskList.nTasks);
	}	

	/* re-order the tasks according to their priority */
/*
	if (taskList.nTasks>1) {
		for (i=0; i<taskList.nTasks-1; ++i) {
			for (j=i+1; j<taskList.nTasks; ++j) {
				if (taskList.taskData[i].priority < taskList.taskData[j].priority) {
					copyMem((UINT32 *) &taskList.taskData[i],
					        (UINT32 *) &taskList.taskData[MAX_NUM_TASKS],
			                SIZEOF(struct TaskData));

					copyMem((UINT32 *) &taskList.taskData[j],
					        (UINT32 *) &taskList.taskData[i],
					        SIZEOF(struct TaskData));

					copyMem((UINT32 *) &taskList.taskData[MAX_NUM_TASKS],
					        (UINT32 *) &taskList.taskData[j],
					        SIZEOF(struct TaskData));
				}
			}
		}

		setMem((UINT32 *) &taskList.taskData[MAX_NUM_TASKS], SIZEOF(struct TaskData),0);
		taskList.taskData[MAX_NUM_TASKS].taskFunction= noTask;
	}
*/
	return returnCode;
}

/************************************************************************************
 * taskOp
 *   
 *   synopsis: Performs an operation on a running task. This can be either 1) halting
 *             it and removing it from the list, 2) pausing it, 3) resuming it,
 *     4) querying it for data, 5) resetting it, or 6) changing its priority.
 *     
 *     When removing a task from the list, the task is aborted even if it is not ready
 *     (say, event trapping hasn't trapped the number of events requested). If tasks
 *     complete on their own (by gathering the requested number of events), this routine
 *     will already have been called, so calling this routine using taskOperation will
 *     generate an error. If the completion flag is set (completion flag is input to 
 *     startTask), or if taskOperation is called, a message is given. The input
 *     parameter msgReq= 1  is set in these two cases. The nibbleVal variable indicates
 *     to taskOp how it should set the nibble in the running task register (see
 *     taskManager.h for explanation of the nibble values). 
 * 
 *   author: Douglas Ferguson
 ************************************************************************************/
INT32 taskOp(UINT8 taskType, UINT8 nibbleVal, UINT32 msgReq, UINT32 operation) {
	INT32  returnCode= SUCCESS, taskErr= FALSE;
	UINT32 opFlags;
    char   taskRunning= 0, taskListPos, i;
    
	/* check to see that the task type exists. */
	#if     defined(I_AM_MASTER_DSP)
		if (taskType==HISTOGRAM_CTRL_TASK) {strcpy(genStr, "Scan Control "); }
		else if (taskType==MIRROR_TASK)    {strcpy(genStr, "Memory mirroring "); }
		else if (taskType==TRAP_REQ_TASK)  {strcpy(genStr, "Trap request monitoring ");}
		else  {taskErr= 1;}
	#elif   defined(I_AM_SLAVE_DSP)
		if      (taskType==HISTOGRAM_TASK) {strcpy(genStr, "Histogramming "); }
		else if (taskType==TRAP_TASK)      {strcpy(genStr, "Event trapping "); }
		else if (taskType==ERROR_TASK)     {strcpy(genStr, "Error counting "); }
		else if (taskType==OCCUPANCY_TASK) {strcpy(genStr, "Occupancy "); }
		else if (taskType==RESYNCH_TASK)   {strcpy(genStr, "Re-synchronization "); }
		else  {taskErr= 1;}
	#endif
	if (taskErr) {
		newError(&returnCode, TASK_NONEXISTANT_ERROR, FATAL_ERR, "taskOp",
		   "This task type does not exist on this type of DSP!\n", __FILE__, __LINE__);
		return returnCode;
	}
		
	/* check whether the task is running */
	for (i=0; i<taskList.nTasks; ++i) {
		if (taskList.taskData[i].taskType == taskType) {
			taskRunning= 1; taskListPos= i;
		}
	}	
	if (!taskRunning) {
		strcat(genStr,"task is not currently running on the DSP.\n");
		newError(&returnCode, TASK_NOTRUNNING_ERROR, FATAL_ERR, "taskOp",
		   genStr, __FILE__, __LINE__);
		return returnCode;
	}
	else {    /* do the operation */

		if (operation == TASK_STOP) {
			opFlags= taskList.taskData[taskListPos].completionFlag | TASK_HALT_MASK;
			taskErr= taskList.taskData[taskListPos].taskFunction(
			                 &taskList.taskData[taskListPos].taskStruct,
			                 &taskOut[taskType-TASK_BASE], opFlags);
			if (taskErr!= TASK_HALTED) {
				strcat(genStr,"task does not acknowledge halt request!\n");
				newError(&returnCode, TASK_CODING_ERROR, FATAL_ERR, "taskOp",
				         genStr, __FILE__, __LINE__);
				return returnCode;
			}
	
			strcat(genStr,"task halted on the DSP.\n");
			/* Remove list member and shift the upper list members down. This will
			 * work even for the last list task since there are actually
			 * MAX_NUM_TASKS +1 list members */
			for (i=taskListPos; i<taskList.nTasks; ++i) {
				setMem((UINT32 *) &taskList.taskData[i], SIZEOF(TaskData), 0);
				copyMem((UINT32 *) &taskList.taskData[i+1],
				        (UINT32 *) &taskList.taskData[i], SIZEOF(TaskData));
			}
	
			setTaskState(taskType, nibbleVal);
			--taskList.nTasks;
			ASGN_RFLD(STATUS_REG_0, SR_NTASKS, SR_NTASKS_W, taskList.nTasks);
		}

		else if (operation == TASK_PAUSE) {
			strcat(genStr,"task paused on the DSP.\n");

			taskList.taskData[taskListPos].prevState= getTaskState(taskType);
			taskList.taskData[taskListPos].state= TASK_PAUSED;
			setTaskState(taskType, taskList.taskData[taskListPos].state);
		}

		else if (operation == TASK_RESUME) {
			strcat(genStr,"task resumed on the DSP.\n");

			taskList.taskData[taskListPos].state=
				taskList.taskData[taskListPos].prevState;
			setTaskState(taskType, taskList.taskData[taskListPos].state);
		}

		/* query the task-- when the task is run with the query mask set, it
		   will not do anything other than output it's internal values. */
		else if (operation == TASK_QUERY) {
			opFlags=  taskList.taskData[taskListPos].completionFlag | TASK_QUERY_MASK;
			taskErr= taskList.taskData[taskListPos].taskFunction(
			                 &taskList.taskData[taskListPos].taskStruct,
			                 &taskOut[taskType-TASK_BASE], opFlags);
			if (taskErr!= TASK_QUERIED) {
				strcat(genStr,"problem acknowledging the query!\n");
				newError(&returnCode, TASK_CODING_ERROR, FATAL_ERR, "taskOp",
				         genStr, __FILE__, __LINE__);
				return returnCode;
			}

			strcat(genStr,"task queried on the DSP.\n");
		}

		else if (operation == TASK_RESET) {
			opFlags= taskList.taskData[taskListPos].completionFlag | TASK_INIT_MASK;
			taskErr= taskList.taskData[taskListPos].taskFunction(
			                 &taskList.taskData[taskListPos].taskStruct,
			                 &taskOut[taskType-TASK_BASE], opFlags);
			if (taskErr!= TASK_INITIALIZED) {
				strcat(genStr,"problem resetting the task!\n");
				newError(&returnCode, TASK_CODING_ERROR, FATAL_ERR, "taskOp",
				         genStr, __FILE__, __LINE__);
				return returnCode;
			}

			strcat(genStr,"task re-initialized on the DSP.\n");
		}

		else if (operation == TASK_SETPRIORITY) { /* nyi */
		}

		if (msgReq) {newInformation(__FILE__, __LINE__, genStr);  }
	}

	return returnCode;
}

/************************************************************************************
 * currentTask
 *   
 *   synopsis: Check to see if a given type of task is running on the DSP. Returns
 *             true if it is.
 * 
 *   author: Douglas Ferguson
 ************************************************************************************/
INT32 currentTask(UINT8 taskType) {
	INT32  returnCode= 0;
	int i;
	for (i=0; i<taskList.nTasks; ++i) {
		if (taskList.taskData[i].taskType == taskType)  returnCode= 1;
	}	

	return returnCode;
}

/************************************************************************************
 * getTaskData
 *   
 *   synopsis: Returns a pointer to the indicated external file-scope task output
 *             structure; checks to see if the indicated task has been run at
 *     least once by checking the task's nibble value in the running task register.
 *     This will be non-zero if the task has run at least once. Returns data for 
 *     any completed, completed with error, or halted (by stopTask) task. It is
 *     the user's responsibility to ensure that this data has been created/stored
 *     in a way that ensures its reliability.
 * 
 *   author: Douglas Ferguson
 ************************************************************************************/
TaskOutput *getTaskData(UINT8 taskType) {
	char taskErr= 0;

	#if     defined(I_AM_MASTER_DSP)
		if (taskType==HISTOGRAM_CTRL_TASK) {strcpy(genStr, "Scan Control "); }
		else if (taskType==MIRROR_TASK)    {strcpy(genStr, "Memory mirroring "); }
		else if (taskType==TRAP_REQ_TASK)  {strcpy(genStr, "Trap request monitoring ");}
		else  {taskErr= 1;}
	#elif   defined(I_AM_SLAVE_DSP)
		if      (taskType==HISTOGRAM_TASK) {strcpy(genStr, "Histogramming "); }
		else if (taskType==TRAP_TASK)      {strcpy(genStr, "Event trapping "); }
		else if (taskType==ERROR_TASK)     {strcpy(genStr, "Error counting "); }
		else if (taskType==OCCUPANCY_TASK) {strcpy(genStr, "Occupancy "); }
		else if (taskType==RESYNCH_TASK)   {strcpy(genStr, "Re-synchronization "); }
		else  {taskErr= 1;}
	#endif

	if (taskErr) {return NULL; }

	if (getTaskState(taskType) != 0) {
		return  &taskOut[taskType-TASK_BASE];
	}
	else {
		return NULL;
	}
}


/************************************************************************************
 * taskManager
 *   
 *   synopsis: Run the tasks currently in the list, according to their priority. Upon
 *             completion, tasks store any output data inside an output structure
 *     union (similar to the input structure union). This is stored as a set of
 *     file level (global) variables for possible later retrieval.
 * 
 *   author: Douglas Ferguson
 ************************************************************************************/
INT32 taskManager() {
	INT32  returnCode= SUCCESS, taskErr, errorCode;
    UINT8   i, cf, taskType, paused;
	#if defined(I_AM_SLAVE_DSP)
		UINT32 trapMask, newPos;
		UINT8  rPtr;
		UINT8 skip; //dpsf xxx
	#endif

	if (taskList.nTasks>0) ++taskMgrCtrl.taskIterations;

	#if defined(I_AM_SLAVE_DSP)
		eventQueue.nEvents= eventQueue.writePtr -eventQueue.readPtr;
		rPtr= eventQueue.readPtr;

		if ((eventQueue.nEvents == 0)&&(!GET_RBIT(COMMAND_REG_0, CR_HISTO_OVERRIDE)))
			return returnCode;
		trapMask= (eventQueue.eventData[rPtr].data2 & EVT_MGR_TRAPMASK)
			      >> EVT_MGR_TRAP_O;
	#endif

	for (i=0; i<taskList.nTasks; ++i) {
		taskType=  taskList.taskData[i].taskType;

		#if defined(I_AM_SLAVE_DSP)
			skip= (taskList.taskData[i].trapFxn != trapMask);
			if (taskType == HISTOGRAM_TASK)
				skip= skip && (!GET_RBIT(COMMAND_REG_0, CR_HISTO_OVERRIDE));  //dpsf
			if (skip) continue;
		#endif

		cf=        taskList.taskData[i].completionFlag;
		paused=   (taskList.taskData[i].state == TASK_PAUSED);

		if (!paused) {
		/*	for (j=0; j<taskList.taskData[i].priority; ++j) {  */
	
				taskErr= taskList.taskData[i].taskFunction(
				             &taskList.taskData[i].taskStruct,
				             &taskOut[taskType-TASK_BASE], cf);
				if (taskErr!= REPEAT_TASK) {
		
					if (taskErr == SUCCESS) {
						errorCode= taskOp(taskType, TASK_DONE, cf,  TASK_STOP);
					}
					else {
						errorCode= taskOp(taskType, TASK_ERROR, cf,  TASK_STOP);
						
						addError(&returnCode, taskErr, "taskManager", "task function",
						         __FILE__, __LINE__);
					}

					if (errorCode!= SUCCESS) {
						addError(&returnCode, errorCode, "taskManager", "taskOp",
						         __FILE__, __LINE__);
					}
				} /* task not repeating. */
	
			/** } * priority */
		}  /* task is running*/
	}

	#if defined(I_AM_SLAVE_DSP)
	if (eventQueue.nEvents > 0) {
			CSR &= ~1; //Disable interrupts globally (bit 0 in CSR).

			rPtr= eventQueue.readPtr;
			evtMgrCtrl.iFrameCnt-= eventQueue.eventData[rPtr].iFrameCnt;
			evtMgrCtrl.xFrameCnt-= eventQueue.eventData[rPtr].xFrameCnt;

			if (eventQueue.eventData[rPtr].iFrameCnt>0) {
				newPos=  eventQueue.eventData[rPtr].iStartFrame
				        +eventQueue.eventData[rPtr].iFrameCnt;

				//Wrap beyond frame #(nFrames -1):
				if (newPos > evtMgrCtrl.iFrameMax) newPos-= (evtMgrCtrl.iFrameMax +1);
				ASGN_RFLD(TRAPSTAT_REG1_2, TSR2_IFRAME_HEAD,TSR2_IFRAME_HEAD_W, newPos);

				/* If it was held high (no room), can now lower pin4 mask. The
				   post-increment sets the pin4MaskDown flag to TRUE. */
				if (!evtMgrCtrl.pin4MaskDown++) MCBSP_FSET(PCR1, DXSTAT, 0);
			}

			if (eventQueue.eventData[rPtr].xFrameCnt>0) {
				newPos=  eventQueue.eventData[rPtr].xStartFrame
				        +eventQueue.eventData[rPtr].xFrameCnt;
				//Wrap beyond end:
				if (newPos > evtMgrCtrl.xMaxIdx) newPos-= (evtMgrCtrl.xFrameMax +1);
				ASGN_RFLD(TRAPSTAT_REG1_2, TSR2_XFRAME_HEAD,TSR2_XFRAME_HEAD_W, newPos);
			}
	
			++eventQueue.readPtr; --eventQueue.nEvents;
			CSR |= 1; //Re-enable interrupts. Any triggered will have pended until now.
	}
	#endif

	return returnCode;
}

/************************************************************************************
 * noTask
 *   
 *   synopsis: Safety net; should never be called. 
 * 
 *   author: Douglas Ferguson
 ************************************************************************************/
INT32 noTask(TaskInput *tsi, TaskOutput *tso, UINT32 opFlags) {
	INT32  returnCode= SUCCESS;

	if (taskMgrCtrl.taskIterations%100000== 0)
		newInformation(__FILE__, __LINE__, "noTask!\n");

	return returnCode;
}