os_mbox.s43

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

	NAME	os_mbox(16)
	RSEG	CODE(1)
	EXTERN	OSEventFreeList
	EXTERN	OSIntNesting
	PUBLIC	OSMboxAccept
	PUBLIC	OSMboxCreate
	PUBLIC	OSMboxDel
	PUBLIC	OSMboxPend
	PUBLIC	OSMboxPost
	PUBLIC	OSMboxPostOpt
	PUBLIC	OSMboxQuery
	EXTERN	OSTCBCur
	EXTERN	OS_EventTO
	EXTERN	OS_EventTaskRdy
	EXTERN	OS_EventTaskWait
	EXTERN	OS_EventWaitListInit
	EXTERN	OS_Sched
	EXTERN	?CL430_1_26_L08
	RSEG	CODE
OSMboxAccept:
; 1.	/*
; 2.	*********************************************************************************************************
; 3.	*                                                uC/OS-II
; 4.	*                                          The Real-Time Kernel
; 5.	*                                       MESSAGE MAILBOX MANAGEMENT
; 6.	*
; 7.	*                          (c) Copyright 1992-2002, Jean J. Labrosse, Weston, FL
; 8.	*                                           All Rights Reserved
; 9.	*
; 10.	* File : OS_MBOX.C
; 11.	* By   : Jean J. Labrosse
; 12.	*********************************************************************************************************
; 13.	*/
; 14.	
; 15.	#ifndef  OS_MASTER_FILE
; 16.	#include "includes.h"
; 17.	#endif
; 18.	
; 19.	#if OS_MBOX_EN > 0
; 20.	/*
; 21.	*********************************************************************************************************
; 22.	*                                     ACCEPT MESSAGE FROM MAILBOX
; 23.	*
; 24.	* Description: This function checks the mailbox to see if a message is available.  Unlike OSMboxPend(),
; 25.	*              OSMboxAccept() does not suspend the calling task if a message is not available.
; 26.	*
; 27.	* Arguments  : pevent        is a pointer to the event control block
; 28.	*
; 29.	* Returns    : != (void *)0  is the message in the mailbox if one is available.  The mailbox is cleared
; 30.	*                            so the next time OSMboxAccept() is called, the mailbox will be empty.
; 31.	*              == (void *)0  if the mailbox is empty or,
; 32.	*                            if 'pevent' is a NULL pointer or,
; 33.	*                            if you didn't pass the proper event pointer.
; 34.	*********************************************************************************************************
; 35.	*/
; 36.	
; 37.	#if OS_MBOX_ACCEPT_EN > 0
; 38.	void  *OSMboxAccept (OS_EVENT *pevent)
; 39.	{
; 40.	#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
; 41.	    OS_CPU_SR  cpu_sr;
; 42.	#endif    
; 43.	    void      *msg;
; 44.	
; 45.	
; 46.	#if OS_ARG_CHK_EN > 0
; 47.	    if (pevent == (OS_EVENT *)0) {                        /* Validate 'pevent'                         */
	CMP	#0,R12	
	JNE	(?0057)	
; 48.	        return ((void *)0);
; 49.	    }
	RET		
?0057:
; 50.	    if (pevent->OSEventType != OS_EVENT_TYPE_MBOX) {      /* Validate event block type                 */
	MOV.B	#1,R13	
	CMP.B	@R12,R13	
	JEQ	(?0059)	
; 51.	        return ((void *)0);
	MOV	#0,R12	
; 52.	    }
	RET		
?0059:
; 53.	#endif
; 54.	    OS_ENTER_CRITICAL();
	DINT		
; 55.	    msg                = pevent->OSEventPtr;
	MOV	4(R12),R13	
; 56.	    pevent->OSEventPtr = (void *)0;                       /* Clear the mailbox                         */
	MOV	#0,4(R12)	
; 57.	    OS_EXIT_CRITICAL();
	EINT		
; 58.	    return (msg);                                         /* Return the message received (or NULL)     */
	MOV	R13,R12	
; 59.	}
	RET		
OSMboxCreate:
; 60.	#endif
; 61.	/*$PAGE*/
; 62.	/*
; 63.	*********************************************************************************************************
; 64.	*                                        CREATE A MESSAGE MAILBOX
; 65.	*
; 66.	* Description: This function creates a message mailbox if free event control blocks are available.
; 67.	*
; 68.	* Arguments  : msg           is a pointer to a message that you wish to deposit in the mailbox.  If
; 69.	*                            you set this value to the NULL pointer (i.e. (void *)0) then the mailbox
; 70.	*                            will be considered empty.
; 71.	*
; 72.	* Returns    : != (OS_EVENT *)0  is a pointer to the event control clock (OS_EVENT) associated with the
; 73.	*                                created mailbox
; 74.	*              == (OS_EVENT *)0  if no event control blocks were available
; 75.	*********************************************************************************************************
; 76.	*/
; 77.	
; 78.	OS_EVENT  *OSMboxCreate (void *msg)
; 79.	{
	PUSH	R10	
; 80.	#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
; 81.	    OS_CPU_SR  cpu_sr;
; 82.	#endif    
; 83.	    OS_EVENT  *pevent;
; 84.	
; 85.	
; 86.	    if (OSIntNesting > 0) {                      /* See if called from ISR ...                         */
	CMP.B	#0,&OSIntNesting	
	JEQ	(?0062)	
; 87.	        return ((OS_EVENT *)0);                  /* ... can't CREATE from an ISR                       */
	MOV	#0,R12	
; 88.	    }
	JMP	(?0067)	
?0062:
; 89.	    OS_ENTER_CRITICAL();
	DINT		
; 90.	    pevent = OSEventFreeList;                    /* Get next free event control block                  */
	MOV	&OSEventFreeList,R10	
; 91.	    if (OSEventFreeList != (OS_EVENT *)0) {      /* See if pool of free ECB pool was empty             */
	CMP	#0,&OSEventFreeList	
	JEQ	(?0064)	
; 92.	        OSEventFreeList = (OS_EVENT *)OSEventFreeList->OSEventPtr;
	MOV	&OSEventFreeList,R13	
	MOV	4(R13),&OSEventFreeList	
?0064:
; 93.	    }
; 94.	    OS_EXIT_CRITICAL();
	EINT		
; 95.	    if (pevent != (OS_EVENT *)0) {
	CMP	#0,R10	
	JEQ	(?0066)	
; 96.	        pevent->OSEventType = OS_EVENT_TYPE_MBOX;
	MOV.B	#1,0(R10)	
; 97.	        pevent->OSEventCnt  = 0;
	MOV	#0,2(R10)	
; 98.	        pevent->OSEventPtr  = msg;               /* Deposit message in event control block             */
	MOV	R12,4(R10)	
; 99.	        OS_EventWaitListInit(pevent);
	MOV	R10,R12	
	CALL	#OS_EventWaitListInit	
?0066:
; 100.	    }
; 101.	    return (pevent);                             /* Return pointer to event control block              */
	MOV	R10,R12	
; 102.	}
?0067:
	POP	R10	
	RET		
OSMboxDel:
; 103.	/*$PAGE*/
; 104.	/*
; 105.	*********************************************************************************************************
; 106.	*                                         DELETE A MAIBOX
; 107.	*
; 108.	* Description: This function deletes a mailbox and readies all tasks pending on the mailbox.
; 109.	*
; 110.	* Arguments  : pevent        is a pointer to the event control block associated with the desired
; 111.	*                            mailbox.
; 112.	*
; 113.	*              opt           determines delete options as follows:
; 114.	*                            opt == OS_DEL_NO_PEND   Delete the mailbox ONLY if no task pending
; 115.	*                            opt == OS_DEL_ALWAYS    Deletes the mailbox even if tasks are waiting.
; 116.	*                                                    In this case, all the tasks pending will be readied.
; 117.	*
; 118.	*              err           is a pointer to an error code that can contain one of the following values:
; 119.	*                            OS_NO_ERR               The call was successful and the mailbox was deleted
; 120.	*                            OS_ERR_DEL_ISR          If you attempted to delete the mailbox from an ISR
; 121.	*                            OS_ERR_INVALID_OPT      An invalid option was specified
; 122.	*                            OS_ERR_TASK_WAITING     One or more tasks were waiting on the mailbox
; 123.	*                            OS_ERR_EVENT_TYPE       If you didn't pass a pointer to a mailbox
; 124.	*                            OS_ERR_PEVENT_NULL      If 'pevent' is a NULL pointer.
; 125.	*
; 126.	* Returns    : pevent        upon error
; 127.	*              (OS_EVENT *)0 if the mailbox was successfully deleted.
; 128.	*
; 129.	* Note(s)    : 1) This function must be used with care.  Tasks that would normally expect the presence of
; 130.	*                 the mailbox MUST check the return code of OSMboxPend().
; 131.	*              2) OSMboxAccept() callers will not know that the intended mailbox has been deleted!
; 132.	*              3) This call can potentially disable interrupts for a long time.  The interrupt disable
; 133.	*                 time is directly proportional to the number of tasks waiting on the mailbox.
; 134.	*              4) Because ALL tasks pending on the mailbox will be readied, you MUST be careful in
; 135.	*                 applications where the mailbox is used for mutual exclusion because the resource(s)
; 136.	*                 will no longer be guarded by the mailbox.
; 137.	*********************************************************************************************************
; 138.	*/
; 139.	
; 140.	#if OS_MBOX_DEL_EN > 0
; 141.	OS_EVENT  *OSMboxDel (OS_EVENT *pevent, INT8U opt, INT8U *err)
; 142.	{
	PUSH	R10	
	PUSH	R11	
	PUSH	R8	
	MOV	R12,R11	
	MOV	8(SP),R8	
; 143.	#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
; 144.	    OS_CPU_SR  cpu_sr;
; 145.	#endif    
; 146.	    BOOLEAN    tasks_waiting;
; 147.	
; 148.	
; 149.	    if (OSIntNesting > 0) {                                /* See if called from ISR ...               */
	CMP.B	#0,&OSIntNesting	
	JEQ	(?0069)	
; 150.	        *err = OS_ERR_DEL_ISR;                             /* ... can't DELETE from an ISR             */
	MOV.B	#140,0(R8)	
; 151.	        return (pevent);
	MOV	R11,R12	
; 152.	    }
	JMP	(?0088)	
?0069:
; 153.	#if OS_ARG_CHK_EN > 0
; 154.	    if (pevent == (OS_EVENT *)0) {                         /* Validate 'pevent'                        */
	CMP	#0,R11	
	JNE	(?0071)	
; 155.	        *err = OS_ERR_PEVENT_NULL;
	MOV.B	#4,0(R8)	
; 156.	        return (pevent);
	MOV	#0,R12	
; 157.	    }
	JMP	(?0088)	
?0071:
; 158.	    if (pevent->OSEventType != OS_EVENT_TYPE_MBOX) {       /* Validate event block type                */
	MOV.B	#1,R12	
	CMP.B	@R11,R12	
	JEQ	(?0073)	
; 159.	        *err = OS_ERR_EVENT_TYPE;
	MOV.B	#1,0(R8)	
; 160.	        return (pevent);
	MOV	R11,R12	
; 161.	    }
	JMP	(?0088)	
?0073:
; 162.	#endif
; 163.	    OS_ENTER_CRITICAL();
	DINT		
; 164.	    if (pevent->OSEventGrp != 0x00) {                      /* See if any tasks waiting on mailbox      */
	CMP.B	#0,1(R11)	
	JEQ	(?0075)	
; 165.	        tasks_waiting = TRUE;                              /* Yes                                      */
	MOV.B	#1,R10	
; 166.	    } else {
	JMP	(?0076)	
?0075:
; 167.	        tasks_waiting = FALSE;                             /* No                                       */
	MOV.B	#0,R10	
?0076:
; 168.	    }
; 169.	    switch (opt) {
	SUB.B	#0,R14	
	JEQ	(?0078)	
	SUB.B	#1,R14	
	JEQ	(?0081)	
	JMP	(?0087)	
?0078:
; 170.	        case OS_DEL_NO_PEND:                               /* Delete mailbox only if no task waiting   */
; 171.	             if (tasks_waiting == FALSE) {
	CMP.B	#0,R10	
	JNE	(?0080)	
; 172.	                 pevent->OSEventType = OS_EVENT_TYPE_UNUSED;