os_task.s43

IAR project for MSP430 and uC/OS. All configured to start filling with tasks.

	PUSH	10(SP)	
	CALL	#OSTaskStkInit	
	MOV	R12,R14	
	ADD	#4,SP	
; 178.	        err = OS_TCBInit(prio, psp, (OS_STK *)0, 0, 0, (void *)0, 0);
	PUSH	#0	
	PUSH	#0	
	PUSH	#0	
	PUSH	#0	
	PUSH	#0	
	PUSH	#0	
	MOV.B	R11,R12	
	CALL	#OS_TCBInit	
	ADD	#12,SP	
	MOV.B	R12,R10	
; 179.	        if (err == OS_NO_ERR) {
	CMP.B	#0,R10	
	DINT		
	JNE	(?0091)	
; 180.	            OS_ENTER_CRITICAL();
; 181.	            OSTaskCtr++;                                        /* Increment the #tasks counter        */
	ADD.B	#1,&OSTaskCtr	
; 182.	            OS_EXIT_CRITICAL();
	EINT		
; 183.	            if (OSRunning == TRUE) {         /* Find highest priority task if multitasking has started */
	CMP.B	#1,&OSRunning	
	JNE	(?0094)	
; 184.	                OS_Sched();
	CALL	#OS_Sched	
; 185.	            }
; 186.	        } else {
	JMP	(?0094)	
?0091:
; 187.	            OS_ENTER_CRITICAL();
; 188.	            OSTCBPrioTbl[prio] = (OS_TCB *)0;/* Make this priority available to others                 */
	ADD	R11,R11	
	MOV	#0,OSTCBPrioTbl(R11)	
; 189.	            OS_EXIT_CRITICAL();
	EINT		
?0094:
; 190.	        }
; 191.	        return (err);
	MOV.B	R10,R12	
; 192.	    }
	JMP	(?0095)	
?0089:
; 193.	    OS_EXIT_CRITICAL();
	EINT		
; 194.	    return (OS_PRIO_EXIST);
	MOV.B	#40,R12	
; 195.	}
?0095:
	POP	R11	
	POP	R10	
	RET		
OSTaskCreateExt:
; 196.	#endif
; 197.	/*$PAGE*/
; 198.	/*
; 199.	*********************************************************************************************************
; 200.	*                                     CREATE A TASK (Extended Version)
; 201.	*
; 202.	* Description: This function is used to have uC/OS-II manage the execution of a task.  Tasks can either
; 203.	*              be created prior to the start of multitasking or by a running task.  A task cannot be
; 204.	*              created by an ISR.  This function is similar to OSTaskCreate() except that it allows
; 205.	*              additional information about a task to be specified.
; 206.	*
; 207.	* Arguments  : task     is a pointer to the task's code
; 208.	*
; 209.	*              pdata    is a pointer to an optional data area which can be used to pass parameters to
; 210.	*                       the task when the task first executes.  Where the task is concerned it thinks
; 211.	*                       it was invoked and passed the argument 'pdata' as follows:
; 212.	*
; 213.	*                           void Task (void *pdata)
; 214.	*                           {
; 215.	*                               for (;;) {
; 216.	*                                   Task code;
; 217.	*                               }
; 218.	*                           }
; 219.	*
; 220.	*              ptos     is a pointer to the task's top of stack.  If the configuration constant
; 221.	*                       OS_STK_GROWTH is set to 1, the stack is assumed to grow downward (i.e. from high
; 222.	*                       memory to low memory).  'pstk' will thus point to the highest (valid) memory
; 223.	*                       location of the stack.  If OS_STK_GROWTH is set to 0, 'pstk' will point to the
; 224.	*                       lowest memory location of the stack and the stack will grow with increasing
; 225.	*                       memory locations.  'pstk' MUST point to a valid 'free' data item.
; 226.	*
; 227.	*              prio     is the task's priority.  A unique priority MUST be assigned to each task and the
; 228.	*                       lower the number, the higher the priority.
; 229.	*
; 230.	*              id       is the task's ID (0..65535)
; 231.	*
; 232.	*              pbos     is a pointer to the task's bottom of stack.  If the configuration constant
; 233.	*                       OS_STK_GROWTH is set to 1, the stack is assumed to grow downward (i.e. from high
; 234.	*                       memory to low memory).  'pbos' will thus point to the LOWEST (valid) memory
; 235.	*                       location of the stack.  If OS_STK_GROWTH is set to 0, 'pbos' will point to the
; 236.	*                       HIGHEST memory location of the stack and the stack will grow with increasing
; 237.	*                       memory locations.  'pbos' MUST point to a valid 'free' data item.
; 238.	*
; 239.	*              stk_size is the size of the stack in number of elements.  If OS_STK is set to INT8U,
; 240.	*                       'stk_size' corresponds to the number of bytes available.  If OS_STK is set to
; 241.	*                       INT16U, 'stk_size' contains the number of 16-bit entries available.  Finally, if
; 242.	*                       OS_STK is set to INT32U, 'stk_size' contains the number of 32-bit entries
; 243.	*                       available on the stack.
; 244.	*
; 245.	*              pext     is a pointer to a user supplied memory location which is used as a TCB extension.
; 246.	*                       For example, this user memory can hold the contents of floating-point registers
; 247.	*                       during a context switch, the time each task takes to execute, the number of times
; 248.	*                       the task has been switched-in, etc.
; 249.	*
; 250.	*              opt      contains additional information (or options) about the behavior of the task.  The
; 251.	*                       LOWER 8-bits are reserved by uC/OS-II while the upper 8 bits can be application
; 252.	*                       specific.  See OS_TASK_OPT_??? in uCOS-II.H.
; 253.	*
; 254.	* Returns    : OS_NO_ERR        if the function was successful.
; 255.	*              OS_PRIO_EXIT     if the task priority already exist
; 256.	*                               (each task MUST have a unique priority).
; 257.	*              OS_PRIO_INVALID  if the priority you specify is higher that the maximum allowed
; 258.	*                               (i.e. > OS_LOWEST_PRIO)
; 259.	*********************************************************************************************************
; 260.	*/
; 261.	/*$PAGE*/
; 262.	#if OS_TASK_CREATE_EXT_EN > 0
; 263.	INT8U  OSTaskCreateExt (void   (*task)(void *pd),
; 264.	                        void    *pdata,
; 265.	                        OS_STK  *ptos,
; 266.	                        INT8U    prio,
; 267.	                        INT16U   id,
; 268.	                        OS_STK  *pbos,
; 269.	                        INT32U   stk_size,
; 270.	                        void    *pext,
; 271.	                        INT16U   opt)
; 272.	{
	PUSH	R10	
	PUSH	R11	
	PUSH	R8	
	PUSH	R9	
	PUSH	R6	
	PUSH	R7	
	PUSH	R4	
	MOV	R12,R8	
	MOV	R14,R9	
	MOV	22(SP),R4	
	MOV	24(SP),R10	
	MOV	26(SP),R11	
	MOV	30(SP),R6	
	MOV.B	18(SP),R7	
; 273.	#if OS_CRITICAL_METHOD == 3                  /* Allocate storage for CPU status register               */
; 274.	    OS_CPU_SR  cpu_sr;
; 275.	#endif
; 276.	    OS_STK    *psp;
; 277.	    INT8U      err;
; 278.	
; 279.	
; 280.	#if OS_ARG_CHK_EN > 0
; 281.	    if (prio > OS_LOWEST_PRIO) {             /* Make sure priority is within allowable range           */
	CMP.B	#13,R7	
	JNC	(?0097)	
; 282.	        return (OS_PRIO_INVALID);
	MOV.B	#42,R12	
; 283.	    }
	JMP	(?0109)	
?0097:
; 284.	#endif
; 285.	    OS_ENTER_CRITICAL();
	DINT		
; 286.	    if (OSTCBPrioTbl[prio] == (OS_TCB *)0) { /* Make sure task doesn't already exist at this priority  */
	MOV.B	R7,R12	
	ADD	R12,R12	
	CMP	#0,OSTCBPrioTbl(R12)	
	JNE	(?0099)	
; 287.	        OSTCBPrioTbl[prio] = (OS_TCB *)1;    /* Reserve the priority to prevent others from doing ...  */
	MOV.B	R7,R12	
	ADD	R12,R12	
	MOV	#1,OSTCBPrioTbl(R12)	
; 288.	                                             /* ... the same thing until task is created.              */
; 289.	        OS_EXIT_CRITICAL();
	EINT		
; 290.	
; 291.	        if (((opt & OS_TASK_OPT_STK_CHK) != 0x0000) ||   /* See if stack checking has been enabled     */
; 292.	            ((opt & OS_TASK_OPT_STK_CLR) != 0x0000)) {   /* See if stack needs to be cleared           */
	BIT	#1,R6	
	JNE	(?0102)	
	BIT	#2,R6	
	JEQ	(?0101)	
?0102:
; 293.	            #if OS_STK_GROWTH == 1
; 294.	            (void)memset(pbos, 0, stk_size * sizeof(OS_STK));
	MOV	R10,R12	
	ADD	R12,R12	
	PUSH	R12	
	MOV	#0,R14	
	MOV	R4,R12	
	CALL	#memset	
	ADD	#2,SP	
?0101:
; 295.	            #else
; 296.	            (void)memset(ptos, 0, stk_size * sizeof(OS_STK));
; 297.	            #endif
; 298.	        }
; 299.	
; 300.	        psp = (OS_STK *)OSTaskStkInit(task, pdata, ptos, opt); /* Initialize the task's stack          */
	PUSH	R6	
	PUSH	20(SP)	
	MOV	R9,R14	
	MOV	R8,R12	
	CALL	#OSTaskStkInit	
	MOV	R12,R14	
	ADD	#4,SP	
; 301.	        err = OS_TCBInit(prio, psp, pbos, id, stk_size, pext, opt);
	PUSH	R6	
	PUSH	32(SP)	
	PUSH	R11	
	PUSH	R10	
	PUSH	30(SP)	
	PUSH	R4	
	MOV.B	R7,R12	
	CALL	#OS_TCBInit	
	ADD	#12,SP	
	MOV.B	R12,R10	
; 302.	        if (err == OS_NO_ERR) {
	CMP.B	#0,R10	
	DINT		
	JNE	(?0105)	
; 303.	            OS_ENTER_CRITICAL();
; 304.	            OSTaskCtr++;                                       /* Increment the #tasks counter         */
	ADD.B	#1,&OSTaskCtr	
; 305.	            OS_EXIT_CRITICAL();
	EINT		
; 306.	            if (OSRunning == TRUE) {                           /* Find HPT if multitasking has started */
	CMP.B	#1,&OSRunning	
	JNE	(?0108)	
; 307.	                OS_Sched();
	CALL	#OS_Sched	
; 308.	            }
; 309.	        } else {
	JMP	(?0108)	
?0105:
; 310.	            OS_ENTER_CRITICAL();
; 311.	            OSTCBPrioTbl[prio] = (OS_TCB *)0;                  /* Make this priority avail. to others  */
	ADD	R7,R7	
	MOV	#0,OSTCBPrioTbl(R7)	
; 312.	            OS_EXIT_CRITICAL();
	EINT		
?0108:
; 313.	        }
; 314.	        return (err);
	MOV.B	R10,R12	
; 315.	    }
	JMP	(?0109)	
?0099:
; 316.	    OS_EXIT_CRITICAL();
	EINT		
; 317.	    return (OS_PRIO_EXIST);
	MOV.B	#40,R12	
; 318.	}
?0109:
	POP	R4	
	POP	R7	
	POP	R6	
	POP	R9	
	POP	R8	
	POP	R11	
	POP	R10	
	RET		
OSTaskDel:
; 319.	#endif
; 320.	/*$PAGE*/
; 321.	/*
; 322.	*********************************************************************************************************
; 323.	*                                            DELETE A TASK
; 324.	*
; 325.	* Description: This function allows you to delete a task.  The calling task can delete itself by
; 326.	*              its own priority number.  The deleted task is returned to the dormant state and can be
; 327.	*              re-activated by creating the deleted task again.
; 328.	*
; 329.	* Arguments  : prio    is the priority of the task to delete.  Note that you can explicitely delete
; 330.	*                      the current task without knowing its priority level by setting 'prio' to
; 331.	*                      OS_PRIO_SELF.
; 332.	*
; 333.	* Returns    : OS_NO_ERR           if the call is successful
; 334.	*              OS_TASK_DEL_IDLE    if you attempted to delete uC/OS-II's idle task
; 335.	*              OS_PRIO_INVALID     if the priority you specify is higher that the maximum allowed
; 336.	*                                  (i.e. >= OS_LOWEST_PRIO) or, you have not specified OS_PRIO_SELF.
; 337.	*              OS_TASK_DEL_ERR     if the task you want to delete does not exist
; 338.	*              OS_TASK_DEL_ISR     if you tried to delete a task from an ISR
; 339.	*
; 340.	* Notes      : 1) To reduce interrupt latency, OSTaskDel() 'disables' the task:
; 341.	*                    a) by making it not ready
; 342.	*                    b) by removing it from any wait lists
; 343.	*                    c) by preventing OSTimeTick() from making the task ready to run.
; 344.	*                 The task can then be 'unlinked' from the miscellaneous structures in uC/OS-II.
; 345.	*              2) The function OS_Dummy() is called after OS_EXIT_CRITICAL() because, on most processors,
; 346.	*                 the next instruction following the enable interrupt instruction is ignored.  
; 347.	*              3) An ISR cannot delete a task.
; 348.	*              4) The lock nesting counter is incremented because, for a brief instant, if the current
; 349.	*                 task is being deleted, the current task would not be able to be rescheduled because it
; 350.	*                 is removed from the ready list.  Incrementing the nesting counter prevents another task
; 351.	*                 from being schedule.  This means that an ISR would return to the current task which is
; 352.	*                 being deleted.  The rest of the deletion would thus be able to be completed.
; 353.	*********************************************************************************************************
; 354.	*/
; 355.	/*$PAGE*/
; 356.	#if OS_TASK_DEL_EN > 0
; 357.	INT8U  OSTaskDel (INT8U prio)
; 358.	{
	PUSH	R10	
	PUSH	R11	
	MOV.B	R12,R10	
; 359.	#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
; 360.	    OS_CPU_SR     cpu_sr;
; 361.	#endif
; 362.	
; 363.	#if OS_EVENT_EN > 0
; 364.	    OS_EVENT     *pevent;
; 365.	#endif    
; 366.	#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
; 367.	    OS_FLAG_NODE *pnode;
; 368.	#endif
; 369.	    OS_TCB       *ptcb;
; 370.	    BOOLEAN       self;
; 371.	
; 372.	
; 373.	
; 374.	    if (OSIntNesting > 0) {                                     /* See if trying to delete from ISR    */
	CMP.B	#0,&OSIntNesting	
	JEQ	(?0117)	
; 375.	        return (OS_TASK_DEL_ISR);
	MOV.B	#63,R12	
; 376.	    }
	JMP	(?0149)	
?0117:
; 377.	#if OS_ARG_CHK_EN > 0
; 378.	    if (prio == OS_IDLE_PRIO) {                                 /* Not allowed to delete idle task     */
	CMP.B	#12,R10	
	JNE	(?0119)	
; 379.	        return (OS_TASK_DEL_IDLE);
	MOV.B	#61,R12	
; 380.	    }
	JMP	(?0149)	
?0119:
; 381.	    if (prio >= OS_LOWEST_PRIO && prio != OS_PRIO_SELF) {       /* Task priority valid ?               */
	CMP.B	#12,R10	
	JNC	(?0121)	
	CMP.B	#255,R10