os_cpu_c.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

	App_TaskStatHook();
#endif
}
#endif

/*
*********************************************************************************************************
*   									 INITIALIZE A TASK'S STACK
*
* Description: This function is called by either OSTaskCreate() or OSTaskCreateExt() to initialize the
*   		   stack frame of the task being created.  This function is highly processor specific.
*
* Arguments  : task 		 is a pointer to the task code
*
*   		   p_arg		 is a pointer to a user supplied data area that will be passed to the task
*   						 when the task first executes.
*
*   		   ptos 		 is a pointer to the top of stack.  It is assumed that 'ptos' points to
*   						 a 'free' entry on the task stack.  If OS_STK_GROWTH is set to 1 then
*   						 'ptos' will contain the HIGHEST valid address of the stack.  Similarly, if
*   						 OS_STK_GROWTH is set to 0, the 'ptos' will contains the LOWEST valid address
*   						 of the stack.
*
*   		   opt  		 specifies options that can be used to alter the behavior of OSTaskStkInit().
*   						 (see uCOS_II.H for OS_TASK_OPT_xxx).
*
* Returns    : Always returns the location of the new top-of-stack' once the processor registers have
*   		   been placed on the stack in the proper order.
*
* Note(s)    : 1) Interrupts are enabled when your task starts executing.
*   		   2) All tasks run in SVC mode.
*********************************************************************************************************
*/

OS_STK * OSTaskStkInit(void (*task) (void *p_arg), void *p_arg, OS_STK *ptos, INT16U opt)
{
	OS_STK *stk;
	INT32U  task_addr;


	opt = opt;  												  /* 'opt' is not used, prevent warning 					  */
	stk = ptos; 												  /* Load stack pointer 									  */
	task_addr = (INT32U) task & ~1; 									 /* Mask off lower bit in case task is thumb mode   		 */
	*(stk) = (INT32U) task_addr;									  /* Entry Point											  */
	*(--stk) = (INT32U) 0x14141414L;									/* R14 (LR) 												*/
	*(--stk) = (INT32U) 0x12121212L;									/* R12  													*/
	*(--stk) = (INT32U) 0x11111111L;									/* R11  													*/
	*(--stk) = (INT32U) 0x10101010L;									/* R10  													*/
	*(--stk) = (INT32U) 0x09090909L;									/* R9   													*/
	*(--stk) = (INT32U) 0x08080808L;									/* R8   													*/
	*(--stk) = (INT32U) 0x07070707L;									/* R7   													*/
	*(--stk) = (INT32U) 0x06060606L;									/* R6   													*/
	*(--stk) = (INT32U) 0x05050505L;									/* R5   													*/
	*(--stk) = (INT32U) 0x04040404L;									/* R4   													*/
	*(--stk) = (INT32U) 0x03030303L;									/* R3   													*/
	*(--stk) = (INT32U) 0x02020202L;									/* R2   													*/
	*(--stk) = (INT32U) 0x01010101L;									/* R1   													*/
	*(--stk) = (INT32U) p_arg;  										/* R0 : argument											*/
	if ((INT32U) task & 0x01)
	{
		/* See if task runs in Thumb or ARM mode					*/
		*(--stk) = (INT32U) ARM_SVC_MODE_THUMB; 						 /* CPSR  (Enable both IRQ and FIQ interrupts, THUMB-mode)   */
	}
	else
	{
		*(--stk) = (INT32U) ARM_SVC_MODE_ARM;   						 /* CPSR  (Enable both IRQ and FIQ interrupts, ARM-mode)	 */
	}

	return (stk);
}

/*
*********************************************************************************************************
*   										TASK SWITCH HOOK
*
* Description: This function is called when a task switch is performed.  This allows you to perform other
*   		   operations during a context switch.
*
* Arguments  : none
*
* Note(s)    : 1) Interrupts are disabled during this call.
*   		   2) It is assumed that the global pointer 'OSTCBHighRdy' points to the TCB of the task that
*   			  will be 'switched in' (i.e. the highest priority task) and, 'OSTCBCur' points to the
*   			  task being switched out (i.e. the preempted task).
*********************************************************************************************************
*/
#if (OS_CPU_HOOKS_EN > 0) && (OS_TASK_SW_HOOK_EN > 0)
void OSTaskSwHook(void)
{
#if OS_CPU_FPU_EN > 0
	void  *pblk;
#endif

#if OS_CPU_FPU_EN > 0   								   /* Save VFP context of preempted task	   */
	if (OSRunning == OS_TRUE)
	{
		/* Don't save on OSStart()!                 */
		if (OSTCBCur->OSTCBOpt & OS_TASK_OPT_SAVE_FP)
		{
			/* See if task used FP  					*/
			pblk = OSTCBCur->OSTCBExtPtr;   			   /* Yes, Get pointer to FP storage area      */
			if (pblk != (void *) 0)
			{
				/*  	Make sure we have storage   		*/
				OS_CPU_FP_Save(pblk);   				   /*      Save the VFP registers in block     */
			}
		}
	}
	/* Restore VFP context of new task  		*/
	if (OSTCBHighRdy->OSTCBOpt & OS_TASK_OPT_SAVE_FP)
	{
		/* See if new task uses FP  				*/
		pblk = OSTCBHighRdy->OSTCBExtPtr;   			   /* Yes, Get pointer to FP storage area      */
		if (pblk != (void *) 0)
		{
			/*  	Make sure we have storage   		*/
			OS_CPU_FP_Restore(pblk);					   /*      Get contents of VFP registers	   */
		}
	}
#endif

#if OS_APP_HOOKS_EN > 0
	App_TaskSwHook();
#endif
}
#endif

/*
*********************************************************************************************************
*   										OS_TCBInit() HOOK
*
* Description: This function is called by OS_TCBInit() after setting up most of the TCB.
*
* Arguments  : ptcb    is a pointer to the TCB of the task being created.
*
* Note(s)    : 1) Interrupts may or may not be ENABLED during this call.
*********************************************************************************************************
*/
#if OS_CPU_HOOKS_EN > 0 && OS_VERSION > 203
void OSTCBInitHook(OS_TCB *ptcb)
{
#if OS_APP_HOOKS_EN > 0
	App_TCBInitHook(ptcb);
#else
	(void) ptcb;														 /* Prevent compiler warning								 */
#endif
}
#endif


/*
*********************************************************************************************************
*   											TICK HOOK
*
* Description: This function is called every tick.
*
* Arguments  : none
*
* Note(s)    : 1) Interrupts may or may not be ENABLED during this call.
*********************************************************************************************************
*/
#if (OS_CPU_HOOKS_EN > 0) && (OS_TIME_TICK_HOOK_EN > 0)
void OSTimeTickHook(void)
{
#if OS_APP_HOOKS_EN > 0
	App_TimeTickHook();
#endif

#if OS_TMR_EN > 0
	OSTmrCtr++;
	if (OSTmrCtr >= (OS_TICKS_PER_SEC / OS_TMR_CFG_TICKS_PER_SEC))
	{
		OSTmrCtr = 0;
		OSTmrSignal();
	}
#endif

#if OS_CPU_ARM_DCC_EN > 0
	OSDCC_Handler();
#endif
}
#endif


/*
*********************************************************************************************************
*   						  INTERRUPT DISABLE TIME MEASUREMENT, START
*********************************************************************************************************
*/

#if OS_CPU_INT_DIS_MEAS_EN > 0
void OS_CPU_IntDisMeasInit(void)
{
	OS_CPU_IntDisMeasNestingCtr = 0;
	OS_CPU_IntDisMeasCntsEnter = 0;
	OS_CPU_IntDisMeasCntsExit = 0;
	OS_CPU_IntDisMeasCntsMax = 0;
	OS_CPU_IntDisMeasCntsDelta = 0;
	OS_CPU_IntDisMeasCntsOvrhd = 0;
	OS_CPU_IntDisMeasStart();   										/* Measure the overhead of the functions					*/
	OS_CPU_IntDisMeasStop();
	OS_CPU_IntDisMeasCntsOvrhd = OS_CPU_IntDisMeasCntsDelta;
}


void OS_CPU_IntDisMeasStart(void)
{
	OS_CPU_IntDisMeasNestingCtr++;
	if (OS_CPU_IntDisMeasNestingCtr == 1)
	{
		/* Only measure at the first nested level   				*/
		OS_CPU_IntDisMeasCntsEnter = OS_CPU_IntDisMeasTmrRd();
	}
}


void OS_CPU_IntDisMeasStop(void)
{
	OS_CPU_IntDisMeasNestingCtr--;  									/* Decrement nesting ctr									*/
	if (OS_CPU_IntDisMeasNestingCtr == 0)
	{
		OS_CPU_IntDisMeasCntsExit = OS_CPU_IntDisMeasTmrRd();
		OS_CPU_IntDisMeasCntsDelta = OS_CPU_IntDisMeasCntsExit - OS_CPU_IntDisMeasCntsEnter;
		if (OS_CPU_IntDisMeasCntsDelta > OS_CPU_IntDisMeasCntsOvrhd)
		{
			/* Ensure overhead < delta  								*/
			OS_CPU_IntDisMeasCntsDelta -= OS_CPU_IntDisMeasCntsOvrhd;
		}
		else
		{
			OS_CPU_IntDisMeasCntsDelta = OS_CPU_IntDisMeasCntsOvrhd;
		}
		if (OS_CPU_IntDisMeasCntsDelta > OS_CPU_IntDisMeasCntsMax)
		{
			/* Track MAXIMUM											*/
			OS_CPU_IntDisMeasCntsMax = OS_CPU_IntDisMeasCntsDelta;
		}
	}
}
#endif


/*
*********************************************************************************************************
*   								  INITIALIZE EXCEPTION VECTORS
*
* Description : This function initialize exception vectors to the default handlers.
*
* Arguments   : None.
*********************************************************************************************************
*/

void OS_CPU_InitExceptVect(void)
{
	/*
		(*(INT32U *)OS_CPU_ARM_EXCEPT_RESET_VECT_ADDR)  		   =		 OS_CPU_ARM_INSTR_JUMP_TO_HANDLER;
		(*(INT32U *)OS_CPU_ARM_EXCEPT_RESET_HANDLER_ADDR)   	   = (INT32U)OS_CPU_ARM_ExceptResetHndlr;
	*/

	(*(INT32U *) OS_CPU_ARM_EXCEPT_UNDEF_INSTR_VECT_ADDR) = OS_CPU_ARM_INSTR_JUMP_TO_HANDLER;
	(*(INT32U *) OS_CPU_ARM_EXCEPT_UNDEF_INSTR_HANDLER_ADDR) = (INT32U) OS_CPU_ARM_ExceptUndefInstrHndlr;

	(*(INT32U *) OS_CPU_ARM_EXCEPT_SWI_VECT_ADDR) = OS_CPU_ARM_INSTR_JUMP_TO_HANDLER;
	(*(INT32U *) OS_CPU_ARM_EXCEPT_SWI_HANDLER_ADDR) = (INT32U) OS_CPU_ARM_ExceptSwiHndlr;

	(*(INT32U *) OS_CPU_ARM_EXCEPT_PREFETCH_ABORT_VECT_ADDR) = OS_CPU_ARM_INSTR_JUMP_TO_HANDLER;
	(*(INT32U *) OS_CPU_ARM_EXCEPT_PREFETCH_ABORT_HANDLER_ADDR) = (INT32U) OS_CPU_ARM_ExceptPrefetchAbortHndlr;

	(*(INT32U *) OS_CPU_ARM_EXCEPT_DATA_ABORT_VECT_ADDR) = OS_CPU_ARM_INSTR_JUMP_TO_HANDLER;
	(*(INT32U *) OS_CPU_ARM_EXCEPT_DATA_ABORT_HANDLER_ADDR) = (INT32U) OS_CPU_ARM_ExceptDataAbortHndlr;

	(*(INT32U *) OS_CPU_ARM_EXCEPT_ADDR_ABORT_VECT_ADDR) = OS_CPU_ARM_INSTR_JUMP_TO_HANDLER;
	(*(INT32U *) OS_CPU_ARM_EXCEPT_ADDR_ABORT_HANDLER_ADDR) = (INT32U) OS_CPU_ARM_ExceptAddrAbortHndlr;

	(*(INT32U *) OS_CPU_ARM_EXCEPT_IRQ_VECT_ADDR) = OS_CPU_ARM_INSTR_JUMP_TO_HANDLER;
	(*(INT32U *) OS_CPU_ARM_EXCEPT_IRQ_HANDLER_ADDR) = (INT32U) OS_CPU_ARM_ExceptIrqHndlr;

	(*(INT32U *) OS_CPU_ARM_EXCEPT_FIQ_VECT_ADDR) = OS_CPU_ARM_INSTR_JUMP_TO_HANDLER;
	(*(INT32U *) OS_CPU_ARM_EXCEPT_FIQ_HANDLER_ADDR) = (INT32U) OS_CPU_ARM_ExceptFiqHndlr;
}