os_mutex.s79

ARM仿真案例

//  424 *********************************************************************************************************
//  425 */
//  426 

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock9 Using cfiCommon1
        CFI Function OSMutexPost
        THUMB
//  427 INT8U  OSMutexPost (OS_EVENT *pevent)
//  428 {
OSMutexPost:
        PUSH     {R4-R7,LR}
        CFI ?RET Frame(CFA, -4)
        CFI R7 Frame(CFA, -8)
        CFI R6 Frame(CFA, -12)
        CFI R5 Frame(CFA, -16)
        CFI R4 Frame(CFA, -20)
        CFI CFA R13+20
        MOVS     R4,R0
//  429 #if OS_CRITICAL_METHOD == 3                           /* Allocate storage for CPU status register      */
//  430     OS_CPU_SR  cpu_sr;
//  431 #endif    
//  432     INT8U      pip;                                   /* Priority inheritance priority                 */
//  433     INT8U      prio;
//  434     INT8U      y;
//  435 
//  436 
//  437     if (OSIntNesting > 0) {                           /* See if called from ISR ...                    */
        LDR      R0,??DataTable64  ;; OSIntNesting
        LDRB     R0,[R0, #+0]
        CMP      R0,#+0
        BEQ      ??OSMutexPost_0
//  438         return (OS_ERR_POST_ISR);                     /* ... can't POST mutex from an ISR              */
        MOVS     R0,#+5
        B        ??OSMutexPost_1
//  439     }
//  440 #if OS_ARG_CHK_EN > 0
//  441     if (pevent == (OS_EVENT *)0) {                    /* Validate 'pevent'                             */
??OSMutexPost_0:
        CMP      R4,#+0
        BNE      ??OSMutexPost_2
//  442         return (OS_ERR_PEVENT_NULL);
        MOVS     R0,#+4
        B        ??OSMutexPost_1
//  443     }
//  444 #endif
//  445     if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type                     */
??OSMutexPost_2:
        LDRB     R0,[R4, #+0]
        CMP      R0,#+4
        BEQ      ??OSMutexPost_3
//  446         return (OS_ERR_EVENT_TYPE);
        MOVS     R0,#+1
        B        ??OSMutexPost_1
//  447     }                                                 
//  448     OS_ENTER_CRITICAL();
??OSMutexPost_3:
        _BLF     OS_CPU_SR_Save,??OS_CPU_SR_Save??rT
        MOVS     R5,R0
//  449     pip  = (INT8U)(pevent->OSEventCnt >> 8);          /* Get priority inheritance priority of mutex    */
        LDRH     R0,[R4, #+2]
        LSRS     R2,R0,#+8
//  450     prio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);  /* Get owner's original priority      */
        LSLS     R1,R0,#+24
        LSRS     R1,R1,#+24
//  451     if (OSTCBCur != (OS_TCB *)pevent->OSEventPtr) {   /* See if posting task owns the MUTEX            */
        LDR      R0,??DataTable49  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        LDR      R3,[R4, #+4]
        CMP      R0,R3
        BEQ      ??OSMutexPost_4
//  452         OS_EXIT_CRITICAL();
        MOVS     R0,R5
        _BLF     OS_CPU_SR_Restore,??OS_CPU_SR_Restore??rT
//  453         return (OS_ERR_NOT_MUTEX_OWNER);
        MOVS     R0,#+120
        B        ??OSMutexPost_1
//  454     }
//  455     if (OSTCBCur->OSTCBPrio == pip) {                 /* Did we have to raise current task's priority? */
??OSMutexPost_4:
        LDR      R0,??DataTable49  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        ADDS     R0,R0,#+45
        LDRB     R0,[R0, #+0]
        CMP      R0,R2
        BNE      ??OSMutexPost_5
//  456         y            = OSTCBCur->OSTCBY;              /* Yes, Return to original priority              */
        LDR      R0,??DataTable49  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        ADDS     R0,R0,#+47
        LDRB     R3,[R0, #+0]
//  457         OSRdyTbl[y] &= ~OSTCBCur->OSTCBBitX;          /*      Remove owner from ready list at 'pip'    */
        LDR      R7,??DataTable58  ;; OSRdyTbl
        MOV      R12,R3
        LDR      R0,??DataTable58  ;; OSRdyTbl
        LDRB     R0,[R0, R3]
        LDR      R6,??DataTable49  ;; OSTCBCur
        LDR      R6,[R6, #+0]
        ADDS     R6,R6,#+48
        LDRB     R6,[R6, #+0]
        BICS     R0,R0,R6
        MOV      R6,R12
        STRB     R0,[R7, R6]
//  458         if (OSRdyTbl[y] == 0) {
        LDR      R0,??DataTable58  ;; OSRdyTbl
        LDRB     R0,[R0, R3]
        CMP      R0,#+0
        BNE      ??OSMutexPost_6
//  459             OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
        LDR      R0,??DataTable55  ;; OSRdyGrp
        LDR      R3,??DataTable55  ;; OSRdyGrp
        LDRB     R3,[R3, #+0]
        LDR      R6,??DataTable49  ;; OSTCBCur
        LDR      R6,[R6, #+0]
        ADDS     R6,R6,#+49
        LDRB     R6,[R6, #+0]
        BICS     R3,R3,R6
        STRB     R3,[R0, #+0]
//  460         }
//  461         OSTCBCur->OSTCBPrio         = prio;
??OSMutexPost_6:
        LDR      R0,??DataTable49  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        ADDS     R0,R0,#+45
        STRB     R1,[R0, #+0]
//  462         OSTCBCur->OSTCBY            = prio >> 3;
        LDR      R0,??DataTable49  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        ADDS     R0,R0,#+47
        LSRS     R3,R1,#+3
        STRB     R3,[R0, #+0]
//  463         OSTCBCur->OSTCBBitY         = OSMapTbl[OSTCBCur->OSTCBY];
        LDR      R0,??DataTable49  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        ADDS     R0,R0,#+49
        LDR      R3,??DataTable49  ;; OSTCBCur
        LDR      R3,[R3, #+0]
        ADDS     R3,R3,#+47
        LDRB     R3,[R3, #+0]
        LDR      R6,??DataTable50  ;; OSMapTbl
        LDRB     R3,[R6, R3]
        STRB     R3,[R0, #+0]
//  464         OSTCBCur->OSTCBX            = prio & 0x07;
        LDR      R0,??DataTable49  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        ADDS     R0,R0,#+46
        LSLS     R3,R1,#+29
        LSRS     R3,R3,#+29
        STRB     R3,[R0, #+0]
//  465         OSTCBCur->OSTCBBitX         = OSMapTbl[OSTCBCur->OSTCBX];
        LDR      R0,??DataTable49  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        ADDS     R0,R0,#+48
        LDR      R3,??DataTable49  ;; OSTCBCur
        LDR      R3,[R3, #+0]
        ADDS     R3,R3,#+46
        LDRB     R3,[R3, #+0]
        LDRB     R3,[R6, R3]
        STRB     R3,[R0, #+0]
//  466         OSRdyGrp                   |= OSTCBCur->OSTCBBitY;
        LDR      R0,??DataTable55  ;; OSRdyGrp
        LDR      R3,??DataTable55  ;; OSRdyGrp
        LDRB     R3,[R3, #+0]
        LDR      R6,??DataTable49  ;; OSTCBCur
        LDR      R6,[R6, #+0]
        ADDS     R6,R6,#+49
        LDRB     R6,[R6, #+0]
        ORRS     R6,R6,R3
        STRB     R6,[R0, #+0]
//  467         OSRdyTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;
        LDR      R0,??DataTable49  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        ADDS     R0,R0,#+47
        LDRB     R0,[R0, #+0]
        LDR      R6,??DataTable58  ;; OSRdyTbl
        LDRB     R7,[R7, R0]
        LDR      R3,??DataTable49  ;; OSTCBCur
        LDR      R3,[R3, #+0]
        ADDS     R3,R3,#+48
        LDRB     R3,[R3, #+0]
        ORRS     R3,R3,R7
        STRB     R3,[R6, R0]
//  468         OSTCBPrioTbl[prio]          = (OS_TCB *)OSTCBCur;
        LSLS     R0,R1,#+2
        LDR      R1,??DataTable63  ;; OSTCBPrioTbl
        LDR      R3,??DataTable49  ;; OSTCBCur
        LDR      R3,[R3, #+0]
        STR      R3,[R1, R0]
//  469     }
//  470     OSTCBPrioTbl[pip] = (OS_TCB *)1;                  /* Reserve table entry                           */
??OSMutexPost_5:
        LSLS     R0,R2,#+2
        LDR      R1,??DataTable63  ;; OSTCBPrioTbl
        MOVS     R2,#+1
        STR      R2,[R1, R0]
//  471     if (pevent->OSEventGrp != 0x00) {                 /* Any task waiting for the mutex?               */
        LDRB     R0,[R4, #+1]
        CMP      R0,#+0
        BEQ      ??OSMutexPost_7
//  472                                                       /* Yes, Make HPT waiting for mutex ready         */
//  473         prio                = OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX);
        MOVS     R2,#+16
        MOVS     R1,#+0
        MOVS     R0,R4
        _BLF     OS_EventTaskRdy,??OS_EventTaskRdy??rT
        MOVS     R1,R0
//  474         pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;  /*      Save priority of mutex's new owner       */
//  475         pevent->OSEventCnt |= prio;
        LDRH     R0,[R4, #+2]
        MOVS     R2,#+255
        LSLS     R2,R2,#+8        ;; #+65280
        ANDS     R2,R2,R0
        MOVS     R0,R1
        ORRS     R0,R0,R2
        STRH     R0,[R4, #+2]
//  476         pevent->OSEventPtr  = OSTCBPrioTbl[prio];     /*      Link to mutex owner's OS_TCB             */
        LSLS     R0,R1,#+2
        LDR      R1,??DataTable63  ;; OSTCBPrioTbl
        LDR      R0,[R1, R0]
        STR      R0,[R4, #+4]
//  477         OS_EXIT_CRITICAL();
        MOVS     R0,R5
        _BLF     OS_CPU_SR_Restore,??OS_CPU_SR_Restore??rT
//  478         OS_Sched();                                   /*      Find highest priority task ready to run  */
        _BLF     OS_Sched,??OS_Sched??rT
//  479         return (OS_NO_ERR);
        B.N      ??OSMutexPost_8
//  480     }
//  481     pevent->OSEventCnt |= OS_MUTEX_AVAILABLE;         /* No,  Mutex is now available                   */
??OSMutexPost_7:
        LDRH     R0,[R4, #+2]
        MOVS     R1,#+255
        ORRS     R1,R1,R0
        STRH     R1,[R4, #+2]
//  482     pevent->OSEventPtr  = (void *)0;
        MOVS     R0,#+0
        STR      R0,[R4, #+4]
//  483     OS_EXIT_CRITICAL();
        MOVS     R0,R5
        _BLF     OS_CPU_SR_Restore,??OS_CPU_SR_Restore??rT
//  484     return (OS_NO_ERR);
??OSMutexPost_8:
        MOVS     R0,#+0
??OSMutexPost_1:
        POP      {R4-R7}
        POP      {R1}
        BX       R1               ;; return
        CFI EndBlock cfiBlock9
//  485 }

        RSEG CODE:CODE:NOROOT(2)
        DATA
??DataTable49:
        DC32     OSTCBCur

        RSEG CODE:CODE:NOROOT(2)
        DATA
??DataTable50:
        DC32     OSMapTbl

        RSEG CODE:CODE:NOROOT(2)
        DATA
??DataTable55:
        DC32     OSRdyGrp

        RSEG CODE:CODE:NOROOT(2)
        DATA
??DataTable58:
        DC32     OSRdyTbl

        RSEG CODE:CODE:NOROOT(2)
        DATA
??DataTable63:
        DC32     OSTCBPrioTbl

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock10 Using cfiCommon0
        CFI NoFunction
        ARM
??OSMutexQuery??rA:
        ADD      R12,PC,#+1
        BX       R12
        CFI EndBlock cfiBlock10
        REQUIRE OSMutexQuery
//  486 /*$PAGE*/
//  487 /*
//  488 *********************************************************************************************************
//  489 *                                     QUERY A MUTUAL EXCLUSION SEMAPHORE
//  490 *
//  491 * Description: This function obtains information about a mutex
//  492 *
//  493 * Arguments  : pevent          is a pointer to the event control block associated with the desired mutex
//  494 *
//  495 *              p_mutex_data    is a pointer to a structure that will contain information about the mutex
//  496 *
//  497 * Returns    : OS_NO_ERR            The call was successful and the message was sent
//  498 *              OS_ERR_QUERY_ISR     If you called this function from an ISR
//  499 *              OS_ERR_PEVENT_NULL   'pevent' is a NULL pointer
//  500 *              OS_ERR_EVENT_TYPE    If you are attempting to obtain data from a non mutex.
//  501 *********************************************************************************************************
//  502 */
//  503 
//  504 #if OS_MUTEX_QUERY_EN > 0

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock11 Using cfiCommon1
        CFI Function OSMutexQuery
        THUMB
//  505 INT8U  OSMutexQuery (OS_EVENT *pevent, OS_MUTEX_DATA *p_mutex_data)
//  506 {
OSMutexQuery:
        PUSH     {R4,R5,LR}
        CFI ?RET Frame(CFA, -4)
        CFI R5 Frame(CFA, -8)
        CFI R4 Frame(CFA, -12)
        CFI CFA R13+12
        MOVS     R4,R0
        MOVS     R5,R1
//  507 #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */