www.pudn.com > ucosii_for_m128_template.rar > os_cpu_a.s, change:2004-02-06,size:17270b


;******************************************************************************************************** 
;                                               uC/OS-II 
;                                         The Real-Time Kernel 
; 
;                                       ATmega128  Specific code 
; 
; 
; File     : OS_CPU_A.S 
; By       : Ole Saether 
;            Jean J. Labrosse 
;******************************************************************************************************** 
;                                           I/O PORT ADDRESSES 
;******************************************************************************************************** 
 
BIT00   = 0x01 
BIT01   = 0x02 
BIT02   = 0x04 
BIT03   = 0x08 
BIT04   = 0x10 
BIT05   = 0x20 
BIT06   = 0x40 
BIT07   = 0x80 
 
SREG    = 0x3F 
SPH     = 0x3E 
SPL     = 0x3D 
RAMPZ   = 0x3B 
 
;******************************************************************************************************** 
;                                         MACROS 
;******************************************************************************************************** 
 
                .macro  PUSH_ALL                            ; Save all registers 
                ST      -Y,R0 
                ST      -Y,R1 
                ST      -Y,R2 
                ST      -Y,R3 
                ST      -Y,R4 
                ST      -Y,R5 
                ST      -Y,R6 
                ST      -Y,R7 
                ST      -Y,R8 
                ST      -Y,R9 
                ST      -Y,R10 
                ST      -Y,R11 
                ST      -Y,R12 
                ST      -Y,R13 
                ST      -Y,R14 
                ST      -Y,R15 
                ST      -Y,R16 
                ST      -Y,R17 
                ST      -Y,R18 
                ST      -Y,R19 
                ST      -Y,R20 
                ST      -Y,R21 
                ST      -Y,R22 
                ST      -Y,R23 
                ST      -Y,R24 
                ST      -Y,R25 
                ST      -Y,R26 
                ST      -Y,R27 
                ST      -Y,R30 
                ST      -Y,R31 
                IN      R16,RAMPZ 
                ST      -Y,R16 
                .endmacro 
 
                .macro  POP_ALL                             ; Restore all registers 
                LD      R16,Y+ 
                OUT     RAMPZ,R16 
                LD      R31,Y+ 
                LD      R30,Y+ 
                LD      R27,Y+ 
                LD      R26,Y+ 
                LD      R25,Y+ 
                LD      R24,Y+ 
                LD      R23,Y+ 
                LD      R22,Y+ 
                LD      R21,Y+ 
                LD      R20,Y+ 
                LD      R19,Y+ 
                LD      R18,Y+ 
                LD      R17,Y+ 
                LD      R16,Y+ 
                LD      R15,Y+ 
                LD      R14,Y+ 
                LD      R13,Y+ 
                LD      R12,Y+ 
                LD      R11,Y+ 
                LD      R10,Y+ 
                LD      R9,Y+ 
                LD      R8,Y+ 
                LD      R7,Y+ 
                LD      R6,Y+ 
                LD      R5,Y+ 
                LD      R4,Y+ 
                LD      R3,Y+ 
                LD      R2,Y+ 
                LD      R1,Y+ 
                LD      R0,Y+ 
                .endmacro 
 
                .macro  PUSH_SP                             ; Save stack pointer 
                IN      R16,SPH 
                ST      -Y,R16 
                IN      R16,SPL 
                ST      -Y,R16 
                .endmacro 
 
                .macro  POP_SP                              ; Restore stack pointer 
                LD      R16,Y+ 
                OUT     SPL,R16 
                LD      R16,Y+ 
                OUT     SPH,R16 
                .endmacro 
 
                .macro  PUSH_SREG                           ; Save status register 
                IN      R16,SREG 
                ST      -Y,R16 
                .endmacro 
 
                .macro  POP_SREG                            ; Restore status registers 
                LD      R16,Y+ 
                OUT     SREG,R16 
                .endmacro 
 
                .area   text(rel) 
 
;/*$PAGE*/. 
;******************************************************************************************************** 
;                            DISABLE/ENABLE INTERRUPTS USING OS_CRITICAL_METHOD #3 
; 
; Description : These functions are used to disable and enable interrupts using OS_CRITICAL_METHOD #3. 
; 
;               OS_CPU_SR  OSCPUSaveSR (void) 
;                     Get current value of SREG 
;                     Disable interrupts 
;                     Return original value of SREG 
; 
;               void  OSCPURestoreSR (OS_CPU_SR cpu_sr) 
;                     Set SREG to cpu_sr 
;                     Return 
;******************************************************************************************************** 
 
_OS_CPU_SR_Save:: 
                IN      R16,SREG                    ; Get current state of interrupts disable flag 
                CLI                                 ; Disable interrupts 
                RET                                 ; Return original SREG value in R16 
 
 
_OS_CPU_SR_Restore:: 
                OUT     SREG,R16                    ; Restore SREG 
                RET                                 ; Return 
 
;/*$PAGE*/. 
;******************************************************************************************************** 
;                               START HIGHEST PRIORITY TASK READY-TO-RUN 
; 
; Description : This function is called by OSStart() to start the highest priority task that was created 
;               by your application before calling OSStart(). 
; 
; Note(s)     : 1) The (data)stack frame is assumed to look as follows: 
; 
;                  OSTCBHighRdy->OSTCBStkPtr --> SPL of (return) stack pointer           (Low memory) 
;                                                SPH of (return) stack pointer 
;                                                Flags to load in status register 
;                                                R31 
;                                                R30 
;                                                R27 
;                                                . 
;                                                . 
;                                                R0 
;                                                PCH 
;                                                PCL                                     (High memory) 
; 
;                  where the stack pointer points to the task start address. 
; 
; 
;               2) OSStartHighRdy() MUST: 
;                      a) Call OSTaskSwHook() then, 
;                      b) Set OSRunning to TRUE, 
;                      c) Switch to the highest priority task. 
;******************************************************************************************************** 
 
_OSStartHighRdy:: 
                CALL    _OSTaskSwHook               ; Invoke user defined context switch hook 
                LDS     R16,_OSRunning              ; Indicate that we are multitasking 
                INC     R16                         ; 
                STS     _OSRunning,R16              ; 
 
                LDS     R30,_OSTCBHighRdy           ; Let Z point to TCB of highest priority task 
                LDS     R31,_OSTCBHighRdy+1         ; ready to run 
                LD      R28,Z+                      ; Load Y (R29:R28) pointer 
                LD      R29,Z+                      ; 
 
                POP_SP                              ; Restore stack pointer 
                POP_SREG                            ; Restore status register 
                POP_ALL                             ; Restore all registers 
                RET                                 ; Start task 
 
;/*$PAGE*/. 
;******************************************************************************************************** 
;                                       TASK LEVEL CONTEXT SWITCH 
; 
; Description : This function is called when a task makes a higher priority task ready-to-run. 
; 
; Note(s)     : 1) Upon entry, 
;                  OSTCBCur     points to the OS_TCB of the task to suspend 
;                  OSTCBHighRdy points to the OS_TCB of the task to resume 
; 
;               2) The stack frame of the task to suspend looks as follows: 
; 
;                                       SP+0 --> LSB of task code address 
;                                         +1     MSB of task code address                (High memory) 
; 
;               3) The saved context of the task to resume looks as follows: 
; 
;                  OSTCBHighRdy->OSTCBStkPtr --> SPL of (return) stack pointer           (Low memory) 
;                                                SPH of (return) stack pointer 
;                                                Flags to load in status register 
;                                                R31 
;                                                R30 
;                                                R27 
;                                                . 
;                                                . 
;                                                R0 
;                                                PCH 
;                                                PCL                                     (High memory) 
;******************************************************************************************************** 
 
_OSCtxSw:: 
                PUSH_ALL                            ; Save current task's context 
                PUSH_SREG 
                PUSH_SP 
 
                LDS     R30,_OSTCBCur               ; Z = OSTCBCur->OSTCBStkPtr 
                LDS     R31,_OSTCBCur+1             ; 
                ST      Z+,R28                      ; Save Y (R29:R28) pointer 
                ST      Z+,R29                      ; 
 
                CALL    _OSTaskSwHook               ; Call user defined task switch hook 
 
                LDS     R16,_OSPrioHighRdy          ; OSPrioCur = OSPrioHighRdy 
                STS     _OSPrioCur,R16 
 
                LDS     R30,_OSTCBHighRdy           ; Let Z point to TCB of highest priority task 
                LDS     R31,_OSTCBHighRdy+1         ; ready to run 
                STS     _OSTCBCur,R30               ; OSTCBCur = OSTCBHighRdy 
                STS     _OSTCBCur+1,R31             ; 
 
                LD      R28,Z+                      ; Restore Y pointer 
                LD      R29,Z+                      ; 
 
                POP_SP                              ; Restore stack pointer 
                POP_SREG                            ; Restore status register 
                POP_ALL                             ; Restore all registers 
 
                RET 
 
;/*$PAGE*/. 
;********************************************************************************************************* 
;                                INTERRUPT LEVEL CONTEXT SWITCH 
; 
; Description : This function is called by OSIntExit() to perform a context switch to a task that has 
;               been made ready-to-run by an ISR. 
; 
; Note(s)     : 1) Upon entry, 
;                  OSTCBCur     points to the OS_TCB of the task to suspend 
;                  OSTCBHighRdy points to the OS_TCB of the task to resume 
; 
;               2) The stack frame of the task to suspend looks as follows: 
; 
;                  OSTCBCur->OSTCBStkPtr ------> SPL of (return) stack pointer           (Low memory) 
;                                                SPH of (return) stack pointer 
;                                                Flags to load in status register 
;                                                R31 
;                                                R30 
;                                                R27 
;                                                . 
;                                                . 
;                                                R0 
;                                                PCH 
;                                                PCL                                     (High memory) 
; 
;               3) The saved context of the task to resume looks as follows: 
; 
;                  OSTCBHighRdy->OSTCBStkPtr --> SPL of (return) stack pointer           (Low memory) 
;                                                SPH of (return) stack pointer 
;                                                Flags to load in status register 
;                                                R31 
;                                                R30 
;                                                R27 
;                                                . 
;                                                . 
;                                                R0 
;                                                PCH 
;                                                PCL                                     (High memory) 
;********************************************************************************************************* 
 
_OSIntCtxSw:: 
                CALL    _OSTaskSwHook               ; Call user defined task switch hook 
 
                LDS     R16,_OSPrioHighRdy          ; OSPrioCur = OSPrioHighRdy 
                STS     _OSPrioCur,R16              ; 
 
                LDS     R30,_OSTCBHighRdy           ; Z = OSTCBHighRdy->OSTCBStkPtr 
                LDS     R31,_OSTCBHighRdy+1         ; 
                STS     _OSTCBCur,R30               ; OSTCBCur = OSTCBHighRdy 
                STS     _OSTCBCur+1,R31             ; 
 
                LD      R28,Z+                      ; Restore Y pointer 
                LD      R29,Z+                      ; 
 
                POP_SP                              ; Restore stack pointer 
                POP_SREG                            ; Restore status register 
                POP_ALL                             ; Restore all registers 
                RET 
 
;/*$PAGE*/. 
;******************************************************************************************************** 
;                                           SYSTEM TICK ISR 
; 
; Description : This function is the ISR used to notify uC/OS-II that a system tick has occurred. 
; 
;               The following C-like pseudo-code describe the operation being performed in the code below. 
; 
;               Save all registers on the current task's stack: 
;                      Use the PUSH_ALL macro 
;                      Get the SREG, set Bit #7 and save onto the task's stack using -Y addressing 
;                      Use the PUSH_SP macro to save the task's hardware stack pointer onto the current task's stack 
;               OSIntNesting++; 
;               if (OSIntNesting == 1) { 
;                  OSTCBCur->OSTCBStkPtr = SP 
;               } 
;               Clear the interrupt;                  Not needed for the timer we used. 
;               OSTimeTick();                         Notify uC/OS-II that a tick has occured 
;               OSIntExit();                          Notify uC/OS-II about end of ISR 
;               Restore all registers that were save on the current task's stack: 
;                      Use the POP_SP macro to restore the task's hardware stack pointer 
;                      Use the POP_SREG macro to restore the SREG register 
;                      Use the POP_ALL macro to restore the remaining registers 
;               Return (DO NOT use a RETI instruction); 
;******************************************************************************************************** 
 
_OSTickISR:: 
                PUSH_ALL                            ; Save all registers and status register 
                IN      R16,SREG                    ; Save the SREG but with interrupts enabled 
                SBR     R16,BIT07                     
                ST      -Y,R16 
                PUSH_SP                             ; Save the task's hardware stack pointer onto task's stack 
 
                LDS     R16,_OSIntNesting           ; Notify uC/OS-II of ISR 
                INC     R16                         ; 
                STS     _OSIntNesting,R16           ; 
 
                CPI     R16,1                       ; if (OSIntNesting == 1) { 
                BRNE    OSTickISR_1 
 
                LDS     R30,_OSTCBCur               ;     OSTCBCur->OSTCBStkPtr = Y 
                LDS     R31,_OSTCBCur+1 
                ST      Z+,R28 
                ST      Z+,R29                      ; } 
 
OSTickISR_1: 
                CALL    _OSTickISR_Handler          ; Handle the tick ISR 
 
                CALL    _OSIntExit                  ; Notify uC/OS-II about end of ISR 
 
                POP_SP                              ; Restore the hardware stack pointer from task's stack 
                POP_SREG                            ; Restore the SREG register 
                POP_ALL                             ; Restore all registers 
 
                RET                                 ; Note: RET instead of RETI