os_flag.s79

ARM仿真案例

//  499 *                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group
//  500 *                            OS_TIMEOUT             The bit(s) have not been set in the specified
//  501 *                                                   'timeout'.
//  502 *                            OS_FLAG_ERR_WAIT_TYPE  You didn't specify a proper 'wait_type' argument.
//  503 *
//  504 * Returns    : The flags in the event flag group that made the task ready or, 0 if a timeout or an error 
//  505 *              occurred.
//  506 *
//  507 * Called from: Task ONLY
//  508 *
//  509 * Note(s)    : 1) IMPORTANT, the behavior of this function has changed from PREVIOUS versions.  The
//  510 *                 function NOW returns the flags that were ready INSTEAD of the current state of the 
//  511 *                 event flags.
//  512 *********************************************************************************************************
//  513 */
//  514 

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock11 Using cfiCommon1
        CFI Function OSFlagPend
        THUMB
//  515 OS_FLAGS  OSFlagPend (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err)
//  516 {
OSFlagPend:
        PUSH     {R1-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+32
        SUB      SP,SP,#+24
        CFI CFA R13+56
        MOVS     R4,R0
        LDR      R5,[SP, #+56]
//  517 #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
//  518     OS_CPU_SR     cpu_sr;
//  519 #endif
//  520     OS_FLAG_NODE  node;
//  521     OS_FLAGS      flags_rdy;
//  522     BOOLEAN       consume;
//  523 
//  524 
//  525     if (OSIntNesting > 0) {                                /* See if called from ISR ...               */
        LDR      R0,??DataTable7  ;; OSIntNesting
        LDRB     R0,[R0, #+0]
        CMP      R0,#+0
        BEQ      ??OSFlagPend_0
//  526         *err = OS_ERR_PEND_ISR;                            /* ... can't PEND from an ISR               */
        MOVS     R0,#+2
??OSFlagPend_1:
        STRB     R0,[R5, #+0]
//  527         return ((OS_FLAGS)0);
        MOVS     R0,#+0
        B        ??OSFlagPend_2
//  528     }
//  529 #if OS_ARG_CHK_EN > 0
//  530     if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */
??OSFlagPend_0:
        CMP      R4,#+0
        BNE      ??OSFlagPend_3
//  531         *err = OS_FLAG_INVALID_PGRP;
        MOVS     R0,#+150
        B.N      ??OSFlagPend_1
//  532         return ((OS_FLAGS)0);
//  533     }
//  534 #endif
//  535     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event block type                */
??OSFlagPend_3:
        LDRB     R0,[R4, #+0]
        CMP      R0,#+5
        BEQ      ??OSFlagPend_4
//  536         *err = OS_ERR_EVENT_TYPE;
        MOVS     R0,#+1
        STRB     R0,[R5, #+0]
//  537         return ((OS_FLAGS)0);
        MOVS     R0,#+0
        B        ??OSFlagPend_2
//  538     }
//  539     if (wait_type & OS_FLAG_CONSUME) {                     /* See if we need to consume the flags      */
??OSFlagPend_4:
        LSLS     R0,R2,#+24
        BPL      ??OSFlagPend_5
//  540         wait_type &= ~OS_FLAG_CONSUME;
        MOV      R0,SP
        LSLS     R1,R2,#+25
        LSRS     R1,R1,#+25
        STRB     R1,[R0, #+28]
//  541         consume    = TRUE;
        MOVS     R6,#+1
        B        ??OSFlagPend_6
//  542     } else {
//  543         consume    = FALSE;
??OSFlagPend_5:
        MOVS     R6,#+0
//  544     }
//  545 /*$PAGE*/
//  546     OS_ENTER_CRITICAL();
??OSFlagPend_6:
        _BLF     OS_CPU_SR_Save,??OS_CPU_SR_Save??rT
        STR      R0,[SP, #+0]
//  547     switch (wait_type) {
        MOV      R0,SP
        LDRB     R0,[R0, #+28]
        CMP      R0,#+0
        BEQ      ??OSFlagPend_7
        CMP      R0,#+1
        BEQ      ??OSFlagPend_8
        CMP      R0,#+2
        BEQ      ??OSFlagPend_9
        CMP      R0,#+3
        BEQ      ??OSFlagPend_10
        B        ??OSFlagPend_11
//  548         case OS_FLAG_WAIT_SET_ALL:                         /* See if all required flags are set        */
//  549              flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */
??OSFlagPend_9:
        LDRH     R0,[R4, #+8]
        MOV      R1,SP
        LDRH     R7,[R1, #+24]
        ANDS     R7,R7,R0
//  550              if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */
        LDRH     R1,[R1, #+24]
        CMP      R7,R1
        BNE      ??OSFlagPend_12
//  551                  if (consume == TRUE) {                    /* See if we need to consume the flags      */
??OSFlagPend_13:
        CMP      R6,#+1
        BNE      ??OSFlagPend_14
//  552                      pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we wanted      */
        BICS     R0,R0,R7
        STRH     R0,[R4, #+8]
//  553                  }
//  554                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;          /* Save flags that were ready           */
??OSFlagPend_14:
        LDR      R0,??DataTable27  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        STRH     R7,[R0, #+40]
//  555                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
        LDR      R0,[SP, #+0]
        _BLF     OS_CPU_SR_Restore,??OS_CPU_SR_Restore??rT
//  556                  *err                    = OS_NO_ERR;
        MOVS     R0,#+0
        B.N      ??OSFlagPend_15
//  557                  return (flags_rdy);
//  558              } else {                                      /* Block task until events occur or timeout */
//  559                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
??OSFlagPend_12:
        MOV      R0,SP
        LDRH     R0,[R0, #+32]
        PUSH     {R0}
        CFI CFA R13+60
        ADD      R0,SP,#+4
        LDRB     R3,[R0, #+28]
        LDRH     R2,[R0, #+24]
        ADD      R1,SP,#+8
        MOVS     R0,R4
        BL       OS_FlagBlock
//  560                  OS_EXIT_CRITICAL();
        LDR      R0,[SP, #+4]
        _BLF     OS_CPU_SR_Restore,??OS_CPU_SR_Restore??rT
//  561              }
//  562              break;
//  563 
//  564         case OS_FLAG_WAIT_SET_ANY:
//  565              flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */
//  566              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag set                      */
//  567                  if (consume == TRUE) {                    /* See if we need to consume the flags      */
//  568                      pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we got         */
//  569                  }
//  570                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;          /* Save flags that were ready           */
//  571                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
//  572                  *err                    = OS_NO_ERR;
//  573                  return (flags_rdy);
//  574              } else {                                      /* Block task until events occur or timeout */
//  575                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
//  576                  OS_EXIT_CRITICAL();
//  577              }
//  578              break;
//  579 
//  580 #if OS_FLAG_WAIT_CLR_EN > 0
//  581         case OS_FLAG_WAIT_CLR_ALL:                         /* See if all required flags are cleared    */
//  582              flags_rdy = ~pgrp->OSFlagFlags & flags;       /* Extract only the bits we want            */
//  583              if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */
//  584                  if (consume == TRUE) {                    /* See if we need to consume the flags      */
//  585                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we wanted        */
//  586                  }
//  587                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;          /* Save flags that were ready           */
//  588                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
//  589                  *err                    = OS_NO_ERR;
//  590                  return (flags_rdy);
//  591              } else {                                      /* Block task until events occur or timeout */
//  592                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
//  593                  OS_EXIT_CRITICAL();
//  594              }
//  595              break;
//  596 
//  597         case OS_FLAG_WAIT_CLR_ANY:
//  598              flags_rdy = ~pgrp->OSFlagFlags & flags;       /* Extract only the bits we want            */
//  599              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag cleared                  */
//  600                  if (consume == TRUE) {                    /* See if we need to consume the flags      */
//  601                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we got           */
//  602                  }
//  603                  OSTCBCur->OSTCBFlagsRdy = flags_rdy;          /* Save flags that were ready           */
//  604                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
//  605                  *err                    = OS_NO_ERR;
//  606                  return (flags_rdy);
//  607              } else {                                      /* Block task until events occur or timeout */
//  608                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
//  609                  OS_EXIT_CRITICAL();
//  610              }
//  611              break;
//  612 #endif
//  613 
//  614         default:
//  615              OS_EXIT_CRITICAL();
//  616              flags_rdy = (OS_FLAGS)0;
//  617              *err      = OS_FLAG_ERR_WAIT_TYPE;
//  618              return (flags_rdy);
//  619     }
//  620     OS_Sched();                                            /* Find next HPT ready to run               */
        _BLF     OS_Sched,??OS_Sched??rT
//  621     OS_ENTER_CRITICAL();
        _BLF     OS_CPU_SR_Save,??OS_CPU_SR_Save??rT
        STR      R0,[SP, #+4]
//  622     if (OSTCBCur->OSTCBStat & OS_STAT_FLAG) {              /* Have we timed-out?                       */
        LDR      R0,??DataTable27  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        ADDS     R0,R0,#+44
        LDRB     R0,[R0, #+0]
        ADD      SP,SP,#+4
        CFI CFA R13+56
        LSLS     R0,R0,#+26
        BMI      ??OSFlagPend_16
//  623         OS_FlagUnlink(&node);
//  624         OSTCBCur->OSTCBStat = OS_STAT_RDY;                 /* Yes, make task ready-to-run              */
//  625         OS_EXIT_CRITICAL();
//  626         flags_rdy           = (OS_FLAGS)0;
//  627         *err                = OS_TIMEOUT;                  /* Indicate that we timed-out waiting       */
//  628     } else {
//  629         if (consume == TRUE) {                             /* See if we need to consume the flags      */
        CMP      R6,#+1
        BNE      ??OSFlagPend_17
//  630             switch (wait_type) {
        MOV      R0,SP
        LDRB     R0,[R0, #+28]
        CMP      R0,#+1
        BLS      ??OSFlagPend_18
        SUBS     R0,R0,#+2
        CMP      R0,#+1
        BHI      ??OSFlagPend_11
//  631                 case OS_FLAG_WAIT_SET_ALL:
//  632                 case OS_FLAG_WAIT_SET_ANY:                 /* Clear ONLY the flags we got              */
//  633                      pgrp->OSFlagFlags &= ~OSTCBCur->OSTCBFlagsRdy;
        LDRH     R0,[R4, #+8]
        LDR      R1,??DataTable27  ;; OSTCBCur
        LDR      R1,[R1, #+0]
        LDRH     R1,[R1, #+40]
        BICS     R0,R0,R1
        STRH     R0,[R4, #+8]
//  634                      flags_rdy          =  OSTCBCur->OSTCBFlagsRdy;
        B.N      ??OSFlagPend_19
??OSFlagPend_10:
        LDRH     R0,[R4, #+8]
        MOV      R1,SP
        LDRH     R7,[R1, #+24]
        ANDS     R7,R7,R0
        BEQ      ??OSFlagPend_12
        B.N      ??OSFlagPend_13
??OSFlagPend_7:
        LDRH     R0,[R4, #+8]
        MOV      R1,SP
        LDRH     R7,[R1, #+24]
        BICS     R7,R7,R0
        LDRH     R1,[R1, #+24]
        CMP      R7,R1
        BNE      ??OSFlagPend_12
??OSFlagPend_20:
        CMP      R6,#+1
        BNE      ??OSFlagPend_14
        MOVS     R1,R7
        ORRS     R1,R1,R0
        STRH     R1,[R4, #+8]
        B        ??OSFlagPend_14
??OSFlagPend_8:
        LDRH     R0,[R4, #+8]
        MOV      R1,SP
        LDRH     R7,[R1, #+24]
        BICS     R7,R7,R0
        BEQ      ??OSFlagPend_12
        B.N      ??OSFlagPend_20
??OSFlagPend_11:
        LDR      R0,[SP, #+0]
        _BLF     OS_CPU_SR_Restore,??OS_CPU_SR_Restore??rT
        MOVS     R0,#+151
        B.N      ??OSFlagPend_1
??OSFlagPend_16:
        ADD      R0,SP,#+4
        BL       OS_FlagUnlink
        LDR      R0,??DataTable27  ;; OSTCBCur
        LDR      R0,[R0, #+0]
        ADDS     R0,R0,#+44
        MOVS     R1,#+0
        STRB     R