os_mutex.src

uCOS-II_2.52在51上的移植程序

;                  pevent->OSEventType = OS_EVENT_TYPE_UNUSED;
;                  pevent->OSEventPtr  = OSEventFreeList;    /* Return Event Control Block to free list  */
;                  OSEventFreeList     = pevent;
;                  OS_EXIT_CRITICAL();
;                  *err = OS_NO_ERR;
;                  return ((OS_EVENT *)0);                   /* Mutex has been deleted                   */
;              } else {
;                  OS_EXIT_CRITICAL();
;                  *err = OS_ERR_TASK_WAITING;
;                  return (pevent);
;              }
; 
;         case OS_DEL_ALWAYS:                                /* Always delete the mutex                  */
;              while (pevent->OSEventGrp != 0x00) {          /* Ready ALL tasks waiting for mutex        */
;                  OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX);
;              }
;              pip                 = (INT8U)(pevent->OSEventCnt >> 8);
;              OSTCBPrioTbl[pip]   = (OS_TCB *)0;            /* Free up the PIP                          */
;              pevent->OSEventType = OS_EVENT_TYPE_UNUSED;
;              pevent->OSEventPtr  = OSEventFreeList;        /* Return Event Control Block to free list  */
;              OSEventFreeList     = pevent;                 /* Get next free event control block        */
;              OS_EXIT_CRITICAL();
;              if (tasks_waiting == TRUE) {                  /* Reschedule only if task(s) were waiting  */
;                  OS_Sched();                               /* Find highest priority task ready to run  */
;              }
;              *err = OS_NO_ERR;
;              return ((OS_EVENT *)0);                       /* Mutex has been deleted                   */
; 
;         default:
;              OS_EXIT_CRITICAL();
;              *err = OS_ERR_INVALID_OPT;
;              return (pevent);
;     }
; }
; #endif
; 
; /*$PAGE*/
; /*
; *********************************************************************************************************
; *                                  PEND ON MUTUAL EXCLUSION SEMAPHORE
; *
; * Description: This function waits for a mutual exclusion semaphore.
; *
; * Arguments  : pevent        is a pointer to the event control block associated with the desired
; *                            mutex.
; *
; *              timeout       is an optional timeout period (in clock ticks).  If non-zero, your task will
; *                            wait for the resource up to the amount of time specified by this argument.
; *                            If you specify 0, however, your task will wait forever at the specified
; *                            mutex or, until the resource becomes available.
; *
; *              err           is a pointer to where an error message will be deposited.  Possible error
; *                            messages are:
; *                               OS_NO_ERR          The call was successful and your task owns the mutex
; *                               OS_TIMEOUT         The mutex was not available within the specified time.
; *                               OS_ERR_EVENT_TYPE  If you didn't pass a pointer to a mutex
; *                               OS_ERR_PEVENT_NULL 'pevent' is a NULL pointer
; *                               OS_ERR_PEND_ISR    If you called this function from an ISR and the result
; *                                                  would lead to a suspension.
; *
; * Returns    : none
; *
; * Note(s)    : 1) The task that owns the Mutex MUST NOT pend on any other event while it owns the mutex.
; *              2) You MUST NOT change the priority of the task that owns the mutex
; *********************************************************************************************************
; */
; void  OSMutexPend (OS_EVENT *pevent, INT16U timeout, INT8U *err)
; {
;   
;     INT8U      pip;                                        /* Priority Inheritance Priority (PIP)      */
;     INT8U      mprio;                                      /* Mutex owner priority                     */
;     BOOLEAN    rdy;                                        /* Flag indicating task was ready           */
;     OS_TCB    *ptcb;
; 
; 
;     if (OSIntNesting > 0) {                                /* See if called from ISR ...               */
;         *err = OS_ERR_PEND_ISR;                            /* ... can't PEND from an ISR               */
;         return;
;     }
; #if OS_ARG_CHK_EN > 0
;     if (pevent == (OS_EVENT *)0) {                         /* Validate 'pevent'                        */
;         *err = OS_ERR_PEVENT_NULL;
;         return;
;     }
;     if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) {      /* Validate event block type                */
;         *err = OS_ERR_EVENT_TYPE;
;         return;
;     }
; #endif
;     OS_ENTER_CRITICAL();								   /* Is Mutex available?                      */
;     if ((INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE) {
;         pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;       /* Yes, Acquire the resource                */
;         pevent->OSEventCnt |= OSTCBCur->OSTCBPrio;         /*      Save priority of owning task        */
;         pevent->OSEventPtr  = (void *)OSTCBCur;            /*      Point to owning task's OS_TCB       */
;         OS_EXIT_CRITICAL();
;         *err  = OS_NO_ERR;
;         return;
;     }
;     pip   = (INT8U)(pevent->OSEventCnt >> 8);                     /* No, Get PIP from mutex            */
;     mprio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);  /*     Get priority of mutex owner   */
;     ptcb  = (OS_TCB *)(pevent->OSEventPtr);                       /*     Point to TCB of mutex owner   */
;     if (ptcb->OSTCBPrio != pip && mprio > OSTCBCur->OSTCBPrio) {  /*     Need to promote prio of owner?*/
;         if ((OSRdyTbl[ptcb->OSTCBY] & ptcb->OSTCBBitX) != 0x00) { /*     See if mutex owner is ready   */
;                                                                   /*     Yes, Remove owner from Rdy ...*/
;                                                                   /*          ... list at current prio */
;             if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0x00) {
;                 OSRdyGrp &= ~ptcb->OSTCBBitY;
;             }
;             rdy = TRUE;
;         } else {
;             rdy = FALSE;                                          /* No                                */
;         }
;         ptcb->OSTCBPrio         = pip;                     /* Change owner task prio to PIP            */
;         ptcb->OSTCBY            = ptcb->OSTCBPrio >> 3;
;         ptcb->OSTCBBitY         = OSMapTbl[ptcb->OSTCBY];
;         ptcb->OSTCBX            = ptcb->OSTCBPrio & 0x07;
;         ptcb->OSTCBBitX         = OSMapTbl[ptcb->OSTCBX];
;         if (rdy == TRUE) {                                 /* If task was ready at owner's priority ...*/
;             OSRdyGrp               |= ptcb->OSTCBBitY;     /* ... make it ready at new priority.       */
;             OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
;         }
;         OSTCBPrioTbl[pip]       = (OS_TCB *)ptcb;
;     }
;     OSTCBCur->OSTCBStat |= OS_STAT_MUTEX;             /* Mutex not available, pend current task        */
;     OSTCBCur->OSTCBDly   = timeout;                   /* Store timeout in current task's TCB           */
;     OS_EventTaskWait(pevent);                         /* Suspend task until event or timeout occurs    */
;     OS_EXIT_CRITICAL();
;     OS_Sched();                                        /* Find next highest priority task ready         */
;     OS_ENTER_CRITICAL();
;     if (OSTCBCur->OSTCBStat & OS_STAT_MUTEX) {        /* Must have timed out if still waiting for event*/
;         OS_EventTO(pevent);
;         OS_EXIT_CRITICAL();
;         *err = OS_TIMEOUT;                            /* Indicate that we didn't get mutex within TO   */
;         return;
;     }
;     OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;
;     OS_EXIT_CRITICAL();
;     *err = OS_NO_ERR;
; }
; /*$PAGE*/
; /*
; *********************************************************************************************************
; *                                  POST TO A MUTUAL EXCLUSION SEMAPHORE
; *
; * Description: This function signals a mutual exclusion semaphore
; *
; * Arguments  : pevent              is a pointer to the event control block associated with the desired
; *                                  mutex.
; *
; * Returns    : OS_NO_ERR               The call was successful and the mutex was signaled.
; *              OS_ERR_EVENT_TYPE       If you didn't pass a pointer to a mutex
; *              OS_ERR_PEVENT_NULL      'pevent' is a NULL pointer
; *              OS_ERR_POST_ISR         Attempted to post from an ISR (not valid for MUTEXes)
; *              OS_ERR_NOT_MUTEX_OWNER  The task that did the post is NOT the owner of the MUTEX.
; *********************************************************************************************************
; */
; 
; INT8U  OSMutexPost (OS_EVENT *pevent)
; {
;     
;     INT8U      pip;                                   /* Priority inheritance priority                 */
;     INT8U      prio;
; 
; 
;     if (OSIntNesting > 0) {                           /* See if called from ISR ...                    */
;         return (OS_ERR_POST_ISR);                     /* ... can't POST mutex from an ISR              */
;     }
; #if OS_ARG_CHK_EN > 0
;     if (pevent == (OS_EVENT *)0) {                    /* Validate 'pevent'                             */
;         return (OS_ERR_PEVENT_NULL);
;     }
;     if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type                     */
;         return (OS_ERR_EVENT_TYPE);
;     }                                                 
; #endif
;     OS_ENTER_CRITICAL();
;     pip  = (INT8U)(pevent->OSEventCnt >> 8);          /* Get priority inheritance priority of mutex    */
;     prio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);  /* Get owner's original priority      */
;     if (OSTCBCur->OSTCBPrio != pip && 
;         OSTCBCur->OSTCBPrio != prio) {                /* See if posting task owns the MUTEX            */
;         OS_EXIT_CRITICAL();
;         return (OS_ERR_NOT_MUTEX_OWNER);
;     }
;     if (OSTCBCur->OSTCBPrio == pip) {                 /* Did we have to raise current task's priority? */
;                                                       /* Yes, Return to original priority              */
;                                                       /*      Remove owner from ready list at 'pip'    */
;         if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {
;             OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
;         }
;         OSTCBCur->OSTCBPrio         = prio;
;         OSTCBCur->OSTCBY            = prio >> 3;
;         OSTCBCur->OSTCBBitY         = OSMapTbl[OSTCBCur->OSTCBY];
;         OSTCBCur->OSTCBX            = prio & 0x07;
;         OSTCBCur->OSTCBBitX         = OSMapTbl[OSTCBCur->OSTCBX];
;         OSRdyGrp                   |= OSTCBCur->OSTCBBitY;
;         OSRdyTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;
;         OSTCBPrioTbl[prio]          = (OS_TCB *)OSTCBCur;
;     }
;     OSTCBPrioTbl[pip] = (OS_TCB *)1;                  /* Reserve table entry                           */
;     if (pevent->OSEventGrp != 0x00) {                 /* Any task waiting for the mutex?               */
;                                                       /* Yes, Make HPT waiting for mutex ready         */
;         prio                = OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX);
;         pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;  /*      Save priority of mutex's new owner       */
;         pevent->OSEventCnt |= prio;
;         pevent->OSEventPtr  = OSTCBPrioTbl[prio];     /*      Link to mutex owner's OS_TCB             */
;         OS_EXIT_CRITICAL();
;         OS_Sched();                                   /*      Find highest priority task ready to run  */
;         return (OS_NO_ERR);
;     }
;     pevent->OSEventCnt |= OS_MUTEX_AVAILABLE;         /* No,  Mutex is now available                   */
;     pevent->OSEventPtr  = (void *)0;
;     OS_EXIT_CRITICAL();
;     return (OS_NO_ERR);
; }
; /*$PAGE*/
; /*
; *********************************************************************************************************
; *                                     QUERY A MUTUAL EXCLUSION SEMAPHORE
; *
; * Description: This function obtains information about a mutex
; *
; * Arguments  : pevent        is a pointer to the event control block associated with the desired mutex
; *
; *              pdata         is a pointer to a structure that will contain information about the mutex
; *
; * Returns    : OS_NO_ERR            The call was successful and the message was sent
; *              OS_ERR_QUERY_ISR     If you called this function from an ISR
; *              OS_ERR_PEVENT_NULL   'pevent' is a NULL pointer
; *              OS_ERR_EVENT_TYPE    If you are attempting to obtain data from a non mutex.
; *********************************************************************************************************
; */
; 
; #if OS_MUTEX_QUERY_EN > 0
; INT8U  OSMutexQuery (OS_EVENT *pevent, OS_MUTEX_DATA *ppdata)
; {
;    
;     INT8U     *psrc;
;     INT8U     *pdest;
; 
; 
;     if (OSIntNesting > 0) {                                /* See if called from ISR ...               */
;         return (OS_ERR_QUERY_ISR);                         /* ... can't QUERY mutex from an ISR        */
;     }
; #if OS_ARG_CHK_EN > 0
;     if (pevent == (OS_EVENT *)0) {                         /* Validate 'pevent'                        */
;         return (OS_ERR_PEVENT_NULL);
;     }
;     if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) {      /* Validate event block type                */
;         return (OS_ERR_EVENT_TYPE);
;     }
; #endif
;     OS_ENTER_CRITICAL();
;     ppdata->OSMutexPIP  = (INT8U)(pevent->OSEventCnt >> 8);
;     ppdata->OSOwnerPrio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);
;     if (ppdata->OSOwnerPrio == 0xFF) {
;         ppdata->OSValue = 1;
;     } else {
;         ppdata->OSValue = 0;
;     }
;     ppdata->OSEventGrp  = pevent->OSEventGrp;               /* Copy wait list                           */
;     psrc               = &pevent->OSEventTbl[0];
;     pdest              = &ppdata->OSEventTbl[0];
; #if OS_EVENT_TBL_SIZE > 0
;     *pdest++           = *psrc++;
; #endif
; 
; #if OS_EVENT_TBL_SIZE > 1
;     *pdest++           = *psrc++;
; #endif
; 
; #if OS_EVENT_TBL_SIZE > 2
;     *pdest++           = *psrc++;
; #endif
; 
; #if OS_EVENT_TBL_SIZE > 3
;     *pdest++           = *psrc++;
; #endif
; 
; #if OS_EVENT_TBL_SIZE > 4
;     *pdest++           = *psrc++;
; #endif
; 
; #if OS_EVENT_TBL_SIZE > 5
;     *pdest++           = *psrc++;
; #endif
; 
; #if OS_EVENT_TBL_SIZE > 6
;     *pdest++           = *psrc++;
; #endif
; 
; #if OS_EVENT_TBL_SIZE > 7
;     *pdest             = *psrc;
; #endif
;     OS_EXIT_CRITICAL();
;     return (OS_NO_ERR);
; }
; #endif                                                     /* OS_MUTEX_QUERY_EN                        */
; #endif                                                     /* OS_MUTEX_EN                              */
; *** sync lost ***
; *** sync lost ***
; *** sync lost ***
	END