os_core.txt

ucos2 is a file system for embedded applications which can be used on any media, for which you can p

;;;446                OS_EXIT_CRITICAL();
000658  e8bd4010          POP      {r4,lr}
00065c  eafffffe          B        OS_CPU_SR_Restore
                  |L1.1632|
;;;447            }
;;;448        }
;;;449    }
000660  e8bd4010          POP      {r4,lr}
000664  e12fff1e          BX       lr
;;;450    #endif
                          ENDP

                  OSStart PROC
;;;473    void  OSStart (void)
;;;474    {
000668  e92d4010          PUSH     {r4,lr}
;;;475        if (OSRunning == OS_FALSE) {
00066c  e51f40a4          LDR      r4,|L1.1488|
000670  e5d40007          LDRB     r0,[r4,#7]  ; OSRunning
000674  e3500000          CMP      r0,#0
000678  1a000008          BNE      |L1.1696|
;;;476            OS_SchedNew();                               /* Find highest priority's task priority number   */
00067c  ebfffffe          BL       OS_SchedNew
;;;477            OSPrioCur     = OSPrioHighRdy;
000680  e5d40005          LDRB     r0,[r4,#5]  ; OSPrioHighRdy
;;;478            OSTCBHighRdy  = OSTCBPrioTbl[OSPrioHighRdy]; /* Point to highest priority task ready to run    */
000684  e51f10b8          LDR      r1,|L1.1492|
000688  e5c40004          STRB     r0,[r4,#4]            ;477  ; OSPrioCur
00068c  e7910100          LDR      r0,[r1,r0,LSL #2]
;;;479            OSTCBCur      = OSTCBHighRdy;
000690  e584002c          STR      r0,[r4,#0x2c]  ; OSTCBHighRdy
000694  e5840024          STR      r0,[r4,#0x24]  ; OSTCBCur
;;;480            OSStartHighRdy();                            /* Execute target specific code to start task     */
000698  e8bd4010          POP      {r4,lr}
00069c  eafffffe          B        OSStartHighRdy
                  |L1.1696|
;;;481        }
;;;482    }
0006a0  e8bd4010          POP      {r4,lr}
0006a4  e12fff1e          BX       lr
;;;483    /*$PAGE*/
                          ENDP

                  OSStatInit PROC
;;;505    void  OSStatInit (void)
;;;506    {
0006a8  e92d4010          PUSH     {r4,lr}
;;;507    #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
;;;508        OS_CPU_SR  cpu_sr = 0;
;;;509    #endif
;;;510    
;;;511    
;;;512    
;;;513        OSTimeDly(2);                                /* Synchronize with clock tick                        */
0006ac  e3a00002          MOV      r0,#2
0006b0  ebfffffe          BL       OSTimeDly
;;;514        OS_ENTER_CRITICAL();
0006b4  ebfffffe          BL       OS_CPU_SR_Save
;;;515        OSIdleCtr    = 0L;                           /* Clear idle counter                                 */
0006b8  e51f40f0          LDR      r4,|L1.1488|
0006bc  e3a01000          MOV      r1,#0
0006c0  e5841020          STR      r1,[r4,#0x20]  ; OSIdleCtr
;;;516        OS_EXIT_CRITICAL();
0006c4  ebfffffe          BL       OS_CPU_SR_Restore
;;;517        OSTimeDly(OS_TICKS_PER_SEC / 10);            /* Determine MAX. idle counter value for 1/10 second  */
0006c8  e3a0000a          MOV      r0,#0xa
0006cc  ebfffffe          BL       OSTimeDly
;;;518        OS_ENTER_CRITICAL();
0006d0  ebfffffe          BL       OS_CPU_SR_Save
;;;519        OSIdleCtrMax = OSIdleCtr;                    /* Store maximum idle counter count in 1/10 second    */
0006d4  e5941020          LDR      r1,[r4,#0x20]  ; OSIdleCtr
0006d8  e5841014          STR      r1,[r4,#0x14]  ; OSIdleCtrMax
;;;520        OSStatRdy    = OS_TRUE;
0006dc  e3a01001          MOV      r1,#1
0006e0  e5c41001          STRB     r1,[r4,#1]  ; OSStatRdy
;;;521        OS_EXIT_CRITICAL();
0006e4  e8bd4010          POP      {r4,lr}
0006e8  eafffffe          B        OS_CPU_SR_Restore
;;;522    }
;;;523    #endif
                          ENDP

                  OSTimeTick PROC
;;;539    void  OSTimeTick (void)
;;;540    {
0006ec  e92d41f0          PUSH     {r4-r8,lr}
;;;541        OS_TCB    *ptcb;
;;;542    #if OS_TICK_STEP_EN > 0
;;;543        BOOLEAN    step;
;;;544    #endif
;;;545    #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register     */
;;;546        OS_CPU_SR  cpu_sr = 0;
;;;547    #endif
;;;548    
;;;549    
;;;550    
;;;551    #if OS_TIME_TICK_HOOK_EN > 0
;;;552        OSTimeTickHook();                                      /* Call user definable hook                     */
0006f0  ebfffffe          BL       OSTimeTickHook
;;;553    #endif
;;;554    #if OS_TIME_GET_SET_EN > 0
;;;555        OS_ENTER_CRITICAL();                                   /* Update the 32-bit tick counter               */
0006f4  ebfffffe          BL       OS_CPU_SR_Save
;;;556        OSTime++;
0006f8  e51f7130          LDR      r7,|L1.1488|
0006fc  e5971034          LDR      r1,[r7,#0x34]  ; OSTime
000700  e2811001          ADD      r1,r1,#1
000704  e5871034          STR      r1,[r7,#0x34]  ; OSTime
;;;557        OS_EXIT_CRITICAL();
000708  ebfffffe          BL       OS_CPU_SR_Restore
;;;558    #endif
;;;559        if (OSRunning == OS_TRUE) {
00070c  e5d70007          LDRB     r0,[r7,#7]  ; OSRunning
000710  e3500001          CMP      r0,#1
000714  1a00002c          BNE      |L1.1996|
;;;560    #if OS_TICK_STEP_EN > 0
;;;561            switch (OSTickStepState) {                         /* Determine whether we need to process a tick  */
000718  e5d70009          LDRB     r0,[r7,#9]  ; OSTickStepState
00071c  e3a05001          MOV      r5,#1
000720  e3a06000          MOV      r6,#0
000724  e3500000          CMP      r0,#0
000728  0a000004          BEQ      |L1.1856|
00072c  e3500001          CMP      r0,#1
000730  0a000025          BEQ      |L1.1996|
000734  e3500002          CMP      r0,#2
;;;562                case OS_TICK_STEP_DIS:                         /* Yes, stepping is disabled                    */
;;;563                     step = OS_TRUE;
;;;564                     break;
;;;565    
;;;566                case OS_TICK_STEP_WAIT:                        /* No,  waiting for uC/OS-View to set ...       */
;;;567                     step = OS_FALSE;                          /*      .. OSTickStepState to OS_TICK_STEP_ONCE */
;;;568                     break;
;;;569    
;;;570                case OS_TICK_STEP_ONCE:                        /* Yes, process tick once and wait for next ... */
;;;571                     step            = OS_TRUE;                /*      ... step command from uC/OS-View        */
;;;572                     OSTickStepState = OS_TICK_STEP_WAIT;
000738  05c75009          STRBEQ   r5,[r7,#9]  ; OSTickStepState
;;;573                     break;
;;;574    
;;;575                default:                                       /* Invalid case, correct situation              */
;;;576                     step            = OS_TRUE;
;;;577                     OSTickStepState = OS_TICK_STEP_DIS;
00073c  15c76009          STRBNE   r6,[r7,#9]  ; OSTickStepState
                  |L1.1856|
;;;578                     break;
;;;579            }
;;;580            if (step == OS_FALSE) {                            /* Return if waiting for step command           */
;;;581                return;
;;;582            }
;;;583    #endif
;;;584            ptcb = OSTCBList;                                  /* Point at first TCB in TCB list               */
000740  e5974030          LDR      r4,[r7,#0x30]  ; OSTCBList
;;;585            while (ptcb->OSTCBPrio != OS_TASK_IDLE_PRIO) {     /* Go through all TCBs in TCB list              */
000744  ea00001d          B        |L1.1984|
                  |L1.1864|
;;;586                OS_ENTER_CRITICAL();
000748  ebfffffe          BL       OS_CPU_SR_Save
;;;587                if (ptcb->OSTCBDly != 0) {                     /* No, Delayed or waiting for event with TO     */
00074c  e1d412ba          LDRH     r1,[r4,#0x2a]
000750  e3510000          CMP      r1,#0
000754  0a000017          BEQ      |L1.1976|
;;;588                    if (--ptcb->OSTCBDly == 0) {               /* Decrement nbr of ticks to end of delay       */
000758  e2411001          SUB      r1,r1,#1
00075c  e1a01801          LSL      r1,r1,#16
000760  e1b01821          LSRS     r1,r1,#16
000764  e1c412ba          STRH     r1,[r4,#0x2a]
000768  1a000012          BNE      |L1.1976|
;;;589                                                               /* Check for timeout                            */
;;;590                        if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {
00076c  e5d4102c          LDRB     r1,[r4,#0x2c]
000770  e3110037          TST      r1,#0x37
;;;591                            ptcb->OSTCBStat  &= ~(INT8U)OS_STAT_PEND_ANY;          /* Yes, Clear status flag   */
000774  13c11037          BICNE    r1,r1,#0x37
;;;592                            ptcb->OSTCBStatPend = OS_STAT_PEND_TO;                 /* Indicate PEND timeout    */
;;;593                        } else {
;;;594                            ptcb->OSTCBStatPend = OS_STAT_PEND_OK;
000778  05c4602d          STRBEQ   r6,[r4,#0x2d]
00077c  15c4102c          STRBNE   r1,[r4,#0x2c]         ;591
000780  15c4502d          STRBNE   r5,[r4,#0x2d]         ;592
;;;595                        }
;;;596    
;;;597                        if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?       */
000784  e5d4102c          LDRB     r1,[r4,#0x2c]
000788  e3110008          TST      r1,#8
00078c  1a000009          BNE      |L1.1976|
;;;598                            OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready          */
000790  e5d41032          LDRB     r1,[r4,#0x32]
000794  e5d72006          LDRB     r2,[r7,#6]  ; OSRdyGrp
000798  e1811002          ORR      r1,r1,r2
00079c  e5c71006          STRB     r1,[r7,#6]  ; OSRdyGrp
;;;599                            OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
0007a0  e5d41030          LDRB     r1,[r4,#0x30]
0007a4  e59f235c          LDR      r2,|L1.2824|
0007a8  e5d4c031          LDRB     r12,[r4,#0x31]
0007ac  e7d23001          LDRB     r3,[r2,r1]
0007b0  e183300c          ORR      r3,r3,r12
0007b4  e7c23001          STRB     r3,[r2,r1]
                  |L1.1976|
;;;600                        }
;;;601                    }
;;;602                }
;;;603                ptcb = ptcb->OSTCBNext;                        /* Point at next TCB in TCB list                */
0007b8  e5944014          LDR      r4,[r4,#0x14]
;;;604                OS_EXIT_CRITICAL();
0007bc  ebfffffe          BL       OS_CPU_SR_Restore
                  |L1.1984|
0007c0  e5d4002e          LDRB     r0,[r4,#0x2e]         ;585
0007c4  e350001f          CMP      r0,#0x1f              ;585
0007c8  1affffde          BNE      |L1.1864|
                  |L1.1996|
;;;605            }
;;;606        }
;;;607    }
0007cc  e8bd41f0          POP      {r4-r8,lr}
0007d0  e12fff1e          BX       lr
;;;608    
                          ENDP

                  OSVersion PROC
;;;625    {
;;;626        return (OS_VERSION);
0007d4  e59f0330          LDR      r0,|L1.2828|
;;;627    }
0007d8  e12fff1e          BX       lr
;;;628    
                          ENDP

                  OS_Dummy PROC
;;;644    {
;;;645    }
0007dc  e12fff1e          BX       lr
;;;646    #endif
                          ENDP

                  OS_EventTaskRdy PROC
;;;677    INT8U  OS_EventTaskRdy (OS_EVENT *pevent, void *pmsg, INT8U msk, INT8U pend_stat)
;;;678    {
0007e0  e92d40f0          PUSH     {r4-r7,lr}
;;;679        OS_TCB  *ptcb;
;;;680        INT8U    x;
;;;681        INT8U    y;
;;;682        INT8U    prio;
;;;683    #if OS_LOWEST_PRIO <= 63
;;;684        INT8U    bitx;
;;;685        INT8U    bity;
;;;686    #else
;;;687        INT16U   bitx;
;;;688        INT16U   bity;
;;;689        INT16U  *ptbl;
;;;690    #endif
;;;691    
;;;692    
;;;693    #if OS_LOWEST_PRIO <= 63
;;;694        y     = OSUnMapTbl[pevent->OSEventGrp];             /* Find HPT waiting for message                */
0007e4  e5d0c00a          LDRB     r12,[r0,#0xa]
0007e8  e59fe320          LDR      lr,|L1.2832|
;;;695        bity  = (INT8U)(1 << y);
0007ec  e3a06001          MOV      r6,#1
0007f0  e7dec00c          LDRB     r12,[lr,r12]          ;694
;;;696        x     = OSUnMapTbl[pevent->OSEventTbl[y]];
0007f4  e080500c          ADD      r5,r0,r12
0007f8  e5d5700b          LDRB     r7,[r5,#0xb]
0007fc  e1a04c16          LSL      r4,r6,r12             ;695
000800  e7dee007          LDRB     lr,[lr,r7]
000804  e20440ff          AND      r4,r4,#0xff           ;695
;;;697        bitx  = (INT8U)(1 << x);
000808  e1a06e16          LSL      r6,r6,lr
00080c  e20660ff          AND      r6,r6,#0xff
;;;698        prio  = (INT8U)((y << 3) + x);                      /* Find priority of task getting the msg       */
;;;699    #else