os_flag.s43

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

; 240.	*                                                    deleted
; 241.	*                            OS_ERR_DEL_ISR          If you attempted to delete the event flag group from
; 242.	*                                                    an ISR
; 243.	*                            OS_FLAG_INVALID_PGRP    If 'pgrp' is a NULL pointer.
; 244.	*                            OS_ERR_EVENT_TYPE       If you didn't pass a pointer to an event flag group
; 245.	*                            OS_ERR_INVALID_OPT      An invalid option was specified
; 246.	*                            OS_ERR_TASK_WAITING     One or more tasks were waiting on the event flag
; 247.	*                                                    group.
; 248.	*
; 249.	* Returns    : pevent        upon error
; 250.	*              (OS_EVENT *)0 if the semaphore was successfully deleted.
; 251.	*
; 252.	* Note(s)    : 1) This function must be used with care.  Tasks that would normally expect the presence of
; 253.	*                 the event flag group MUST check the return code of OSFlagAccept() and OSFlagPend().
; 254.	*              2) This call can potentially disable interrupts for a long time.  The interrupt disable
; 255.	*                 time is directly proportional to the number of tasks waiting on the event flag group.
; 256.	*********************************************************************************************************
; 257.	*/
; 258.	
; 259.	#if OS_FLAG_DEL_EN > 0
; 260.	OS_FLAG_GRP  *OSFlagDel (OS_FLAG_GRP *pgrp, INT8U opt, INT8U *err)
; 261.	{
	PUSH	R10	
	PUSH	R11	
	PUSH	R8	
	PUSH	R9	
	MOV	R12,R8	
	MOV	10(SP),R9	
; 262.	#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
; 263.	    OS_CPU_SR     cpu_sr;
; 264.	#endif
; 265.	    BOOLEAN       tasks_waiting;
; 266.	    OS_FLAG_NODE *pnode;
; 267.	
; 268.	
; 269.	    if (OSIntNesting > 0) {                                /* See if called from ISR ...               */
	CMP.B	#0,&OSIntNesting	
	JEQ	(?0099)	
; 270.	        *err = OS_ERR_DEL_ISR;                             /* ... can't DELETE from an ISR             */
	MOV.B	#140,0(R9)	
; 271.	        return (pgrp);
	MOV	R8,R12	
; 272.	    }
	JMP	(?0118)	
?0099:
; 273.	#if OS_ARG_CHK_EN > 0
; 274.	    if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */
	CMP	#0,R8	
	JNE	(?0101)	
; 275.	        *err = OS_FLAG_INVALID_PGRP;
	MOV.B	#150,0(R9)	
; 276.	        return (pgrp);
	MOV	#0,R12	
; 277.	    }
	JMP	(?0118)	
?0101:
; 278.	    if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event group type                */
	MOV.B	#5,R12	
	CMP.B	@R8,R12	
	JEQ	(?0103)	
; 279.	        *err = OS_ERR_EVENT_TYPE;
	MOV.B	#1,0(R9)	
; 280.	        return (pgrp);
	MOV	R8,R12	
; 281.	    }
	JMP	(?0118)	
?0103:
; 282.	#endif
; 283.	    OS_ENTER_CRITICAL();
	DINT		
; 284.	    if (pgrp->OSFlagWaitList != (void *)0) {               /* See if any tasks waiting on event flags  */
	CMP	#0,2(R8)	
	JEQ	(?0105)	
; 285.	        tasks_waiting = TRUE;                              /* Yes                                      */
	MOV.B	#1,R11	
; 286.	    } else {
	JMP	(?0106)	
?0105:
; 287.	        tasks_waiting = FALSE;                             /* No                                       */
	MOV.B	#0,R11	
?0106:
; 288.	    }
; 289.	    switch (opt) {
	SUB.B	#0,R14	
	JEQ	(?0108)	
	SUB.B	#1,R14	
	JEQ	(?0111)	
	JMP	(?0117)	
?0108:
; 290.	        case OS_DEL_NO_PEND:                               /* Delete group if no task waiting          */
; 291.	             if (tasks_waiting == FALSE) {
	CMP.B	#0,R11	
	JNE	(?0110)	
; 292.	                 pgrp->OSFlagType     = OS_EVENT_TYPE_UNUSED;
	MOV.B	#0,0(R8)	
; 293.	                 pgrp->OSFlagWaitList = (void *)OSFlagFreeList; /* Return group to free list           */
	MOV	&OSFlagFreeList,2(R8)	
; 294.	                 OSFlagFreeList       = pgrp;
	MOV	R8,&OSFlagFreeList	
; 295.	                 OS_EXIT_CRITICAL();
	EINT		
; 296.	                 *err                 = OS_NO_ERR;
	MOV.B	#0,0(R9)	
; 297.	                 return ((OS_FLAG_GRP *)0);                /* Event Flag Group has been deleted        */
	MOV	#0,R12	
; 298.	             } else {
	JMP	(?0118)	
?0110:
; 299.	                 OS_EXIT_CRITICAL();
	EINT		
; 300.	                 *err                 = OS_ERR_TASK_WAITING;
	MOV.B	#8,0(R9)	
; 301.	                 return (pgrp);
	MOV	R8,R12	
; 302.	             }
	JMP	(?0118)	
?0111:
; 303.	
; 304.	        case OS_DEL_ALWAYS:                                /* Always delete the event flag group       */
; 305.	             pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;
	MOV	2(R8),R10	
?0113:
; 306.	             while (pnode != (OS_FLAG_NODE *)0) {          /* Ready ALL tasks waiting for flags        */
	CMP	#0,R10	
	JEQ	(?0112)	
; 307.	                 OS_FlagTaskRdy(pnode, (OS_FLAGS)0);
	MOV	#0,R14	
	MOV	R10,R12	
	CALL	#OS_FlagTaskRdy	
; 308.	                 pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext;
	MOV	@R10,R10	
	JMP	(?0113)	
?0112:
; 309.	             }
; 310.	             pgrp->OSFlagType     = OS_EVENT_TYPE_UNUSED;
	MOV.B	#0,0(R8)	
; 311.	             pgrp->OSFlagWaitList = (void *)OSFlagFreeList;/* Return group to free list                */
	MOV	&OSFlagFreeList,2(R8)	
; 312.	             OSFlagFreeList       = pgrp;
	MOV	R8,&OSFlagFreeList	
; 313.	             OS_EXIT_CRITICAL();
	EINT		
; 314.	             if (tasks_waiting == TRUE) {                  /* Reschedule only if task(s) were waiting  */
	CMP.B	#1,R11	
	JNE	(?0116)	
; 315.	                 OS_Sched();                               /* Find highest priority task ready to run  */
	CALL	#OS_Sched	
?0116:
; 316.	             }
; 317.	             *err = OS_NO_ERR;
	MOV.B	#0,0(R9)	
; 318.	             return ((OS_FLAG_GRP *)0);                    /* Event Flag Group has been deleted        */
	MOV	#0,R12	
; 319.	
; 320.	        default:
	JMP	(?0118)	
?0117:
; 321.	             OS_EXIT_CRITICAL();
	EINT		
; 322.	             *err = OS_ERR_INVALID_OPT;
	MOV.B	#7,0(R9)	
; 323.	             return (pgrp);
	MOV	R8,R12	
; 324.	    }
?0118:
	POP	R9	
	POP	R8	
	POP	R11	
	POP	R10	
	RET		
?0107:
; 325.	}
OSFlagPend:
; 326.	#endif
; 327.	/*$PAGE*/
; 328.	/*
; 329.	*********************************************************************************************************
; 330.	*                                        WAIT ON AN EVENT FLAG GROUP
; 331.	*
; 332.	* Description: This function is called to wait for a combination of bits to be set in an event flag
; 333.	*              group.  Your application can wait for ANY bit to be set or ALL bits to be set.
; 334.	*
; 335.	* Arguments  : pgrp          is a pointer to the desired event flag group.
; 336.	*
; 337.	*              flags         Is a bit pattern indicating which bit(s) (i.e. flags) you wish to wait for.
; 338.	*                            The bits you want are specified by setting the corresponding bits in
; 339.	*                            'flags'.  e.g. if your application wants to wait for bits 0 and 1 then
; 340.	*                            'flags' would contain 0x03.
; 341.	*
; 342.	*              wait_type     specifies whether you want ALL bits to be set or ANY of the bits to be set.
; 343.	*                            You can specify the following argument:
; 344.	*
; 345.	*                            OS_FLAG_WAIT_CLR_ALL   You will wait for ALL bits in 'mask' to be clear (0)
; 346.	*                            OS_FLAG_WAIT_SET_ALL   You will wait for ALL bits in 'mask' to be set   (1)
; 347.	*                            OS_FLAG_WAIT_CLR_ANY   You will wait for ANY bit  in 'mask' to be clear (0)
; 348.	*                            OS_FLAG_WAIT_SET_ANY   You will wait for ANY bit  in 'mask' to be set   (1)
; 349.	*
; 350.	*                            NOTE: Add OS_FLAG_CONSUME if you want the event flag to be 'consumed' by
; 351.	*                                  the call.  Example, to wait for any flag in a group AND then clear
; 352.	*                                  the flags that are present, set 'wait_type' to:
; 353.	*
; 354.	*                                  OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME
; 355.	*
; 356.	*              timeout       is an optional timeout (in clock ticks) that your task will wait for the
; 357.	*                            desired bit combination.  If you specify 0, however, your task will wait
; 358.	*                            forever at the specified event flag group or, until a message arrives.
; 359.	*
; 360.	*              err           is a pointer to an error code and can be:
; 361.	*                            OS_NO_ERR              The desired bits have been set within the specified
; 362.	*                                                   'timeout'.
; 363.	*                            OS_ERR_PEND_ISR        If you tried to PEND from an ISR
; 364.	*                            OS_FLAG_INVALID_PGRP   If 'pgrp' is a NULL pointer.
; 365.	*                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group
; 366.	*                            OS_TIMEOUT             The bit(s) have not been set in the specified
; 367.	*                                                   'timeout'.
; 368.	*                            OS_FLAG_ERR_WAIT_TYPE  You didn't specify a proper 'wait_type' argument.
; 369.	*
; 370.	* Returns    : The new state of the flags in the event flag group when the task is resumed or,
; 371.	*              0 if a timeout or an error occurred.
; 372.	*
; 373.	* Called from: Task ONLY
; 374.	*********************************************************************************************************
; 375.	*/
; 376.	
; 377.	OS_FLAGS  OSFlagPend (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err)
; 378.	{
	PUSH	R10	
	PUSH	R11	
	PUSH	R8	
	PUSH	R9	
	SUB	#12,SP	
	MOV	R12,R11	
	MOV	24(SP),R12	
	MOV.B	22(SP),R10	
	MOV	26(SP),R8	
; 379.	#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
; 380.	    OS_CPU_SR     cpu_sr;
; 381.	#endif
; 382.	    OS_FLAG_NODE  node;
; 383.	    OS_FLAGS      flags_cur;
; 384.	    OS_FLAGS      flags_rdy;
; 385.	    BOOLEAN       consume;
; 386.	
; 387.	
; 388.	    if (OSIntNesting > 0) {                                /* See if called from ISR ...               */
	CMP.B	#0,&OSIntNesting	
	JEQ	(?0120)	
; 389.	        *err = OS_ERR_PEND_ISR;                            /* ... can't PEND from an ISR               */
	MOV.B	#2,0(R8)	
; 390.	        return ((OS_FLAGS)0);
	MOV	#0,R12	
; 391.	    }
	JMP	(?0152)	
?0120:
; 392.	#if OS_ARG_CHK_EN > 0
; 393.	    if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */
	CMP	#0,R11	
	JNE	(?0122)	
; 394.	        *err = OS_FLAG_INVALID_PGRP;
	MOV.B	#150,0(R8)	
; 395.	        return ((OS_FLAGS)0);
	MOV	#0,R12	
; 396.	    }
	JMP	(?0152)	
?0122:
; 397.	    if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event block type                */
	MOV.B	#5,R13	
	CMP.B	@R11,R13	
	JEQ	(?0124)	
; 398.	        *err = OS_ERR_EVENT_TYPE;
	MOV.B	#1,0(R8)	
; 399.	        return ((OS_FLAGS)0);
	MOV	#0,R12	
; 400.	    }
	JMP	(?0152)	
?0124:
; 401.	#endif
; 402.	    if (wait_type & OS_FLAG_CONSUME) {                     /* See if we need to consume the flags      */
	BIT.B	#128,R10	
	JEQ	(?0126)	
; 403.	        wait_type &= ~OS_FLAG_CONSUME;
	AND.B	#127,R10	
; 404.	        consume    = TRUE;
	MOV.B	#1,R9	
; 405.	    } else {
	JMP	(?0127)	
?0126:
; 406.	        consume    = FALSE;
	MOV.B	#0,R9	
?0127:
; 407.	    }
; 408.	/*$PAGE*/
; 409.	    OS_ENTER_CRITICAL();
	DINT		
; 410.	    switch (wait_type) {
	MOV.B	R10,R13	
	CMP	#4,R13	
	JC	(?0149)	
	ADD	R13,R13	
	BR	?0218(R13)	
?0218:
	DW	?0139	
	DW	?0144	
	DW	?0129	
	DW	?0134	
?0129:
; 411.	        case OS_FLAG_WAIT_SET_ALL:                         /* See if all required flags are set        */
; 412.	             flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */
	MOV	4(R11),R13	
	AND	R14,R13	
; 413.	             if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */
	CMP	R13,R14	
	JNE	(?0131)	
; 414.	                 if (consume == TRUE) {                    /* See if we need to consume the flags      */
	CMP.B	#1,R9	
	JNE	(?0133)	
; 415.	                     pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we wanted      */
	XOR	#-1,R13	
	AND	R13,4(R11)	
?0133:
; 416.	                 }
; 417.	                 flags_cur = pgrp->OSFlagFlags;            /* Will return the state of the group       */
	MOV	4(R11),R12	
; 418.	                 OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
	EINT		
; 419.	                 *err      = OS_NO_ERR;
	MOV.B	#0,0(R8)	
; 420.	                 return (flags_cur);
; 421.	             } else {                                      /* Block task until events occur or timeout */
	JMP	(?0152)	
?0131:
; 422.	                 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
	PUSH	R12	
	PUSH.B	R10	
	PUSH	R14	
	MOV	SP,R14	
	ADD	#6,R14	
	MOV	R11,R12	
	CALL	#OS_FlagBlock	
	ADD	#6,SP	
; 423.	                 OS_EXIT_CRITICAL();
	EINT		
; 424.	             }
; 425.	             break;
	JMP	(?0128)	
?0134:
; 426.	
; 427.	        case OS_FLAG_WAIT_SET_ANY:
; 428.	             flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */
	MOV	4(R11),R13	
	AND	R14,R13	
; 429.	             if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag set                      */
	JEQ	(?0136)	
; 430.	                 if (consume == TRUE) {                    /* See if we need to consume the flags      */
	CMP.B	#1,R9	
	JNE	(?0138)	
; 431.	                     pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we got         */
	XOR	#-1,R13	
	AND	R13,4(R11)	
?0138:
; 432.	                 }
; 433.	                 flags_cur = pgrp->OSFlagFlags;            /* Will return the state of the group       */
	MOV	4(R11),R12	
; 434.	                 OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
	EINT		
; 435.	                 *err      = OS_NO_ERR;
	MOV.B	#0,0(R8)	
; 436.	                 return (flags_cur);
; 437.	             } else {                                      /* Block task until events occur or timeout */
	JMP	(?0152)	
?0136:
; 438.	                 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
	PUSH	R12	
	PUSH.B	R10	
	PUSH	R14	
	MOV	SP,R14	
	ADD	#6,R14	
	MOV	R11,R12	
	CALL	#OS_FlagBlock	
	ADD	#6,SP	
; 439.	                 OS_EXIT_CRITICAL();
	EINT		
; 440.	             }
; 441.	             break;
	JMP	(?0128)	
?0139:
; 442.	
; 443.	#if OS_FLAG_WAIT_CLR_EN > 0
; 444.	        case OS_FLAG_WAIT_CLR_ALL:                         /* See if all required flags are cleared    */
; 445.	             flags_rdy = ~pgrp->OSFlagFlags & flags;       /* Extract only the bits we want            */