task.c

samsung 9908DVD源代码,

	if(MK_pTaskReadyListHead[Priority] == MK_pTaskReadyListTail[Priority])
	{
		MK_pTaskReadyListHead[Priority] = MK_NULL;
		MK_pTaskReadyListTail[Priority] = MK_NULL;
		pTask->t_pTaskReadyNext = MK_NULL;
		pTask->t_pTaskReadyPrev = MK_NULL;

		/* modify Ready Group, MiddleGroup, Table */
		GroupValue = (Priority & 0x000000C0)>>6;				/* 7bit ~ 8bit */
		MiddleGroupValue = (Priority & 0x00000038)>>3;			/* 3bit ~ 6bit */
		TableValue = Priority & 0x00000007;				/* 0bit ~ 2bit */
		MK_ReadyTable[GroupValue][MiddleGroupValue] &= ~MK_MapTable[TableValue];
		if(MK_ReadyTable[GroupValue][MiddleGroupValue] == 0)
		{
			MK_ReadyMiddleGroup[GroupValue] &= ~MK_MapTable[MiddleGroupValue];
			if(MK_ReadyMiddleGroup[GroupValue] == 0)
			{
				MK_ReadyGroup &= ~MK_MapTable[GroupValue];
			}
		}
	}
	else
	{
		if(pTask == MK_pTaskReadyListHead[Priority]) 
		{
			MK_pTaskReadyListHead[Priority] = pTask->t_pTaskReadyNext;
			MK_pTaskReadyListHead[Priority]->t_pTaskReadyPrev = MK_NULL;
		}
		else if(pTask == MK_pTaskReadyListTail[Priority]) 
		{
			MK_pTaskReadyListTail[Priority] = pTask->t_pTaskReadyPrev;
			MK_pTaskReadyListTail[Priority]->t_pTaskReadyNext = MK_NULL;
		}
		else
		{
			pTask->t_pTaskReadyPrev->t_pTaskReadyNext = pTask->t_pTaskReadyNext;
			pTask->t_pTaskReadyNext->t_pTaskReadyPrev = pTask->t_pTaskReadyPrev;
		}
		pTask->t_pTaskReadyNext = MK_NULL;
		pTask->t_pTaskReadyPrev = MK_NULL;
	}

	pTask->t_Status &= ~MK_TASK_READY;

	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}

STATUS
MK_Resume(MK_TASK *pTask)
{
	UINT	oldStatus;
	INT	Flags;
	MK_PENDING_LIST *pPendingList;

	MK_SEMAPHORE	*pSem;
	MK_HEAP		*pHeap;
#ifdef	_MK_EVENT
	MK_EVENT	*pEvent;
	ULONG		compare;
#endif

	if (pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_GetTaskName() - Task doesn't exist! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}
	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_Resume() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}

	if(pTask->t_Status & MK_TASK_READY)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_Resume() -  task status is already READY! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}

	Flags = MK_InterruptDisable(); /* Critical Resion */ //Modified
	oldStatus = pTask->t_Status;
	pTask->t_Status = 0;
	if(oldStatus & MK_TASK_SUSPEND) { //Modified
		if(oldStatus & MK_TASK_DELAYED) 
			if(pTask->t_DelayedDeltaTicks > 0)
				MK_InsertTaskToDelayedList(pTask, pTask->t_DelayedDeltaTicks);
				
		if(oldStatus & MK_TASK_PENDING) {
			pPendingList = (MK_PENDING_LIST *)pTask->t_PendingList;
			if(pPendingList->p_Sem != 0) {
				pSem = (MK_SEMAPHORE *)pPendingList->p_Sem;
				if(pSem->s_Magic == MK_SEMAPHORE_MAGIC) //like semaphore_pend()
					if(--pSem->s_Count < 0) //don't care ticks
						MK_InsertTaskToPendingList(pPendingList, pTask);
				else if(pSem->s_Magic == MK_HEAP_MAGIC) {
					pHeap = (MK_HEAP *)pPendingList->p_Sem;
					if(MK_GetHeapMaxMemorySize(pHeap) < (UINT)pTask->t_pendingMemSize)
						MK_InsertTaskToPendingList(pPendingList, pTask);
				}
#ifdef	_MK_EVENT
				else if(pSem->s_Magic == MK_EVENT_MAGIC) {
					pEvent = (MK_EVENT *)pPendingList->p_Sem;
					
					compare = pEvent->e_Events & pTask->t_EventRequested;
					if(pTask->t_EventOperation & MK_EVENT_AND) {
						compare = (compare == pTask->t_EventRequested) ? compare : 0;
					}	
					if(compare) {
						if(pTask->t_EventOperation & MK_CONSUME)
							pEvent->e_Events &= ~pTask->t_EventRequested;
					}
					else //pending								
						MK_InsertTaskToPendingList(pPendingList, pTask);
				}
#endif /* #ifdef _MK_EVENT */
			}
			else //the resource may has been deleted(then, pPendingList->p_Sem = 0)
				pTask->t_Status |= MK_TASK_FORCED;
			
			if((pTask->t_Status & MK_TASK_DELAYED) && !(pTask->t_Status & MK_TASK_PENDING)) //it was delayed + pending, but pending is failed
				MK_DeleteTaskFromDelayedList(pTask);
		}

		if(oldStatus & (MK_TASK_FORCED | MK_TASK_SIGNAL)) {
			pTask->t_Status |= oldStatus & (MK_TASK_FORCED | MK_TASK_SIGNAL);
			MK_InsertTaskToReadyList(pTask);
		}
		else if(!(pTask->t_Status & MK_TASK_DELAYED) && !(pTask->t_Status & MK_TASK_PENDING)) { //prevent on missing to insert to delayed or pending
			//Just Resume
			MK_InsertTaskToReadyList(pTask);
		}
		
		if(pTask->t_Status & MK_TASK_READY)
			MK_Schedule();	
	}
	else {
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_Resume() -  task status is not MK_TASK_SUSPEND! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		MK_InterruptRestore(Flags);
		return MK_ERROR;
	}

	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}

STATUS	
MK_Suspend(MK_TASK *pTask)
{
	INT		Priority;
	INT		Flags;
	MK_PENDING_LIST *pPendingList;
	MK_SEMAPHORE	*pSem;

	if (pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_Suspend() - Task doesn't exist! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}
	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_Suspend() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}
	
	if(pTask->t_Status & MK_TASK_SUSPEND) //Modified because of blocking recall to suspend
		return MK_NO_ERROR;

	Flags = MK_InterruptDisable();

	if( pTask->t_Status & MK_TASK_READY )
		MK_DeleteTaskFromReadyList( pTask );

	if( pTask->t_Status & MK_TASK_DELAYED ) {
		if(MK_DeleteTaskFromDelayedList( pTask ) == MK_NO_ERROR)
			pTask->t_Status |= MK_TASK_DELAYED; //Modified
		else
			pTask->t_DelayedDeltaTicks = 0;
	}

	if( pTask->t_Status & MK_TASK_PENDING ) {
		pPendingList = (MK_PENDING_LIST *)pTask->t_PendingList;
		pSem = (MK_SEMAPHORE *)pPendingList->p_Sem;
		if(pSem->s_Magic == MK_SEMAPHORE_MAGIC)
			pSem->s_Count++;
#if 0
		else if(pSem->s_Magic == MK_EVENT_MAGIC) {
			MK_Printf("\nMK_EVENT_PENDING_LIST\n");
		}
		else if(pSem->s_Magic == MK_HEAP_MAGIC) {
		MK_Printf("\nMK_HEAP_PENDING_LIST\n");
		}
		else { }
#endif
		if(MK_DeleteTaskFromPendingList( pPendingList, pTask ) == MK_NO_ERROR) {
			pTask->t_PendingList = (ULONG)pPendingList; //Modified
			pTask->t_Status |= MK_TASK_PENDING; //Modified
		}
		else
			pTask->t_PendingList = 0; //Modified
	}

	pTask->t_Status |= MK_TASK_SUSPEND;

	/*if( pTask == MK_pCurrentTask )  //Modified
	{
		Priority = MK_GetHighPriority();
		pTask = MK_pTaskReadyListHead[Priority];
		MK_pCurrentTask = pTask;
		MK_StartHighPriorityTask(&pTask->t_CurrentOfStack);
	}*/

	MK_Schedule();
	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}

STATUS
MK_DeleteTask(MK_TASK *pTask)
{
	INT		Priority;
	INT		Flags;
	int		ContextFlags;
	MK_PENDING_LIST	*pPendingList;
	MK_SEMAPHORE	*pSem;

	if(pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_ERROR, "MK_DeleteTask() - Task does not exist\n");
#endif
		return MK_ERROR;
	}
	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_DeleteTask() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}

	if(pTask->t_Priority == Idle_Task)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_ERROR, "MK_DeleteTask() - IDLE Task must be not Delete! Priority(%dL)\n", pTask->t_Priority);
#endif
		return MK_ERROR;
	}

	Flags = MK_InterruptDisable();		/* Critical Region */

	if(pTask->t_Status & MK_TASK_READY)
	{
		MK_DeleteTaskFromReadyList(pTask);
	}
	if(pTask->t_Status & MK_TASK_DELAYED)
	{
		MK_DeleteTaskFromDelayedList(pTask);
	}
	if( pTask->t_Status & MK_TASK_PENDING ) {
		pPendingList = (MK_PENDING_LIST *)pTask->t_PendingList;
		pSem = (MK_SEMAPHORE *)pPendingList->p_Sem;
if(pSem->s_Magic == MK_SEMAPHORE_MAGIC) {
		pSem->s_Count++;
}
#if 0
else if(pSem->s_Magic == MK_EVENT_MAGIC) {
	MK_Printf("\nMK_EVENT_PENDING_LIST\n");
}
else if(pSem->s_Magic == MK_HEAP_MAGIC) {
	MK_Printf("\nMK_HEAP_PENDING_LIST\n");
}
else { }
#endif
		MK_DeleteTaskFromPendingList( (MK_PENDING_LIST *)pTask->t_PendingList, pTask );
	}

	if(MK_pTaskListHead == MK_pTaskListTail)
	{
		pTask->t_pTaskNext = MK_NULL;
		pTask->t_pTaskPrev = MK_NULL;
	}
	else 
	{
		if(pTask == MK_pTaskListHead)
		{
			MK_pTaskListHead = pTask->t_pTaskNext;
			MK_pTaskListHead->t_pTaskPrev = MK_NULL;

		}
		else if(pTask == MK_pTaskListTail)
		{
			MK_pTaskListTail = pTask->t_pTaskPrev;
			MK_pTaskListTail->t_pTaskNext = MK_NULL;
		}
		else
		{
			pTask->t_pTaskPrev->t_pTaskNext = pTask->t_pTaskNext;
			pTask->t_pTaskNext->t_pTaskPrev = pTask->t_pTaskPrev;
		}
	}
	pTask->t_pTaskNext = MK_NULL;
	pTask->t_pTaskPrev = MK_NULL;

	pTask->t_Status = MK_TASK_DORMANT;
	pTask->t_Magic = 0;
	MK_DelTotalTasks();
ContextFlags = MK_ContextSwitchDisable();
	MK_FreeMemory((void *)pTask->t_TopOfStack);
MK_ContextSwitchRestore(ContextFlags);
	if( pTask == MK_pCurrentTask )
	{
		Priority = MK_GetHighPriority();
		pTask = MK_pTaskReadyListHead[Priority];
		MK_pCurrentTask = pTask;
		MK_StartHighPriorityTask(&pTask->t_CurrentOfStack);
	}

	MK_InterruptRestore(Flags);		

	return MK_NO_ERROR;
}

VOID
MK_SleepTicks(LONG Ticks)
{
	MK_TASK *pTask;
	INT		Flags;

	Flags = MK_InterruptDisable();

	pTask = MK_pCurrentTask;
	if(pTask->t_Magic == MK_TASK_MAGIC)
	{
		MK_InsertTaskToDelayedList(pTask, Ticks);
		MK_Schedule();
	}

	MK_InterruptRestore( Flags );
	return;
}

VOID
MK_Wakeup(VOID)
{
	LONG Value, Revision;
	MK_TASK *pTask;
	INT Flags;

	if(MK_pTaskDelayedListHead == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_Wakeup() - task is not existed in delayed list! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return;
	}

	Flags = MK_InterruptDisable();		/* Critical Region */

	Revision = 0;

	for(Value = MK_pTaskDelayedListHead->t_DelayedDeltaTicks; Value<=Revision; )
	{
		pTask = MK_pTaskDelayedListHead;
		MK_DeleteTaskFromDelayedList(pTask);	/* MK_pTaskDelayedListHead = MK_pTaskDelayedListHead->t_pDelayedNext */
		MK_InsertTaskToReadyList(pTask);
		Revision -= Value;
		if(MK_pTaskDelayedListHead == MK_NULL)
		{
			break;
		}
		Value = MK_pTaskDelayedListHead->t_DelayedDeltaTicks;
	}

	MK_InterruptRestore(Flags);
}

STATUS
MK_Unsleep(MK_TASK *pTask)
{
	INT	Flags;

	if (pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_Unsleep() - Task doesn't exist! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}
	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_Unsleep() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}

	Flags = MK_InterruptDisable();

	MK_DeleteTaskFromDelayedList(pTask);
	MK_InsertTaskToReadyList(pTask);
	MK_Schedule();

	MK_InterruptRestore( Flags );
	return MK_NO_ERROR;
}


STATUS
MK_InsertTaskToDelayedList(MK_TASK *pTask, LONG Ticks)
{
	MK_TASK *pNext;
	INT Priority;
	INT Flags;

	if (pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_InsertTaskToDelayedList() - Task doesn't exist! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}
	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_InsertTaskToDelayedList() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}

	if(pTask->t_Status & MK_TASK_DELAYED)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_InsertTaskToDelayedList() - Task status is already existed in delayed list! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}

	if(Ticks < 0)
		return MK_ERROR;

	if(Ticks == 0)
	{
		Flags = MK_InterruptDisable();	/* Critical Region */
		Priority = pTask->t_Priority;

		if(MK_pTaskReadyListHead[Priority] != MK_pTaskReadyListTail[Priority])
		{
			/* When more than 2 Task exist, move Current Task to Tail */
			pTask->t_RemainedTimeSlice = 0;
			/* it effects MK_Schedule() */
		}

		MK_InterruptRestore(Flags);
	}
	else
	{
		if(pTask->t_Status & MK_TASK_SIGNAL)	/* Prevent Delayed State in Signal */
		{
			return MK_ERROR;
		}

		Flags = MK_InterruptDisable();	/* Critical Region */

		MK_DeleteTaskFromReadyList(pTask);

		pTask->t_pDelayedNext = MK_NULL;
		pTask->t_pDelayedPrev = MK_NULL;
		if(Ticks > 0)
		{
			if(MK_pTaskDelayedListHead == MK_NULL)
			{
				MK_pTaskDelayedListHead = pTask;
				pTask->t_DelayedDeltaTicks = Ticks;
			}
			else
			{
				pNext = MK_pTaskDelayedListHead;
				if(Ticks < pNext->t_DelayedDeltaTicks)
				{
					MK_pTaskDelayedListHead->t_pDelayedPrev = pTask;
					pTask->t_pDelayedNext = MK_pTaskDelayedListHead;
					MK_pTaskDelayedListHead->t_DelayedDeltaTicks -= Ticks;
					MK_pTaskDelayedListHead = pTask;
					pTask->t_DelayedDeltaTicks = Ticks;
				}
				else
				{
					pNext = MK_pTaskDelayedListHead;
					while(Ticks >= pNext->t_DelayedDeltaTicks)
					{
						Ticks -= pNext->t_DelayedDeltaTicks;
						if(pNext->t_pDelayedNext == MK_NULL)
						{
							pTask->t_pDelayedPrev = pNext;
							pNext->t_pDelayedNext = pTask;
							pTask->t_DelayedDeltaTicks = Ticks;
							pTask->t_Status |= MK_TASK_DELAYED;
							MK_InterruptRestore(Flags);
							return MK_NO_ERROR;
						}
						pNext = pNext->t_pDelayedNext;
					}
					pTask->t_pDelayedPrev = pNext->t_pDelayedPrev;
					pTask->t_pDelayedPrev->t_pDelayedNext = pTask;
					pTask->t_pDelayedNext = pNext;
					pNext->t_pDelayedPrev = pTask;
					pTask->t_DelayedDeltaTicks = Ticks;
					pNext->t_DelayedDeltaTicks -= Ticks;
				}
			}
		}

		pTask->t_Status |= MK_TASK_DELAYED;

		MK_InterruptRestore(Flags);
	}

	return MK_NO_ERROR;
}


STATUS
MK_DeleteTaskFromDelayedList(MK_TASK *pTask)
{
	MK_TASK *pNext;
	int Flags;
	int oldDelayedDeltaTicks;

		if (pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_DeleteTaskFromDelayedList() - Task doesn't exist! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}

	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_DeleteTaskFromDelayedList() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}

	if(!(pTask->t_Status & MK_TASK_DELAYED))
	{