/* * Copyright (c) 2006-2022, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * * Change Logs: * Date Author Notes * 2013-07-05 Bernard the first version */ #include <rtconfig.h> #ifdef RT_USING_VMM #include <vmm.h> .equ orig_irq_isr, LINUX_VECTOR_POS+0x18 #else #undef RT_VMM_USING_DOMAIN #endif .equ Mode_USR, 0x10 .equ Mode_FIQ, 0x11 .equ Mode_IRQ, 0x12 .equ Mode_SVC, 0x13 .equ Mode_ABT, 0x17 .equ Mode_UND, 0x1B .equ Mode_SYS, 0x1F .equ I_Bit, 0x80 @ when I bit is set, IRQ is disabled .equ F_Bit, 0x40 @ when F bit is set, FIQ is disabled #ifndef RT_USING_VMM .equ UND_Stack_Size, 0x00000000 .equ SVC_Stack_Size, 0x00000100 .equ ABT_Stack_Size, 0x00000000 .equ RT_FIQ_STACK_PGSZ, 0x00000000 .equ RT_IRQ_STACK_PGSZ, 0x00000100 .equ USR_Stack_Size, 0x00000100 #define ISR_Stack_Size (UND_Stack_Size + SVC_Stack_Size + ABT_Stack_Size + \ RT_FIQ_STACK_PGSZ + RT_IRQ_STACK_PGSZ) #else #define ISR_Stack_Size (RT_FIQ_STACK_PGSZ + RT_IRQ_STACK_PGSZ) #endif .section .data.share.isr /* stack */ .globl stack_start .globl stack_top .align 3 stack_start: .rept ISR_Stack_Size .byte 0 .endr stack_top: .text /* reset entry */ .globl _reset _reset: #ifdef RT_USING_VMM /* save all the parameter and variable registers */ stmfd sp!, {r0-r12, lr} #endif /* set the cpu to SVC32 mode and disable interrupt */ mrs r0, cpsr bic r0, r0, #0x1f orr r0, r0, #0x13 msr cpsr_c, r0 /* setup stack */ bl stack_setup /* clear .bss */ mov r0,#0 /* get a zero */ ldr r1,=__bss_start /* bss start */ ldr r2,=__bss_end /* bss end */ bss_loop: cmp r1,r2 /* check if data to clear */ strlo r0,[r1],#4 /* clear 4 bytes */ blo bss_loop /* loop until done */ #ifdef RT_USING_VMM /* clear .bss.share */ mov r0,#0 /* get a zero */ ldr r1,=__bss_share_start /* bss start */ ldr r2,=__bss_share_end /* bss end */ bss_share_loop: cmp r1,r2 /* check if data to clear */ strlo r0,[r1],#4 /* clear 4 bytes */ blo bss_share_loop /* loop until done */ #endif /* call C++ constructors of global objects */ ldr r0, =__ctors_start__ ldr r1, =__ctors_end__ ctor_loop: cmp r0, r1 beq ctor_end ldr r2, [r0], #4 stmfd sp!, {r0-r1} mov lr, pc bx r2 ldmfd sp!, {r0-r1} b ctor_loop ctor_end: /* start RT-Thread Kernel */ #ifdef RT_USING_VMM /* restore the parameter */ ldmfd sp!, {r0-r3} bl vmm_entry ldmfd sp!, {r4-r12, pc} #else ldr pc, _rtthread_startup _rtthread_startup: .word rtthread_startup #endif stack_setup: ldr r0, =stack_top #ifdef RT_USING_VMM @ Linux use stmia to save r0, lr and spsr. To align to 8 byte boundary, @ just allocate 16 bytes for it. sub r0, r0, #16 #endif #ifndef RT_USING_VMM @ Set the startup stack for svc mov sp, r0 #endif #ifndef RT_USING_VMM @ Enter Undefined Instruction Mode and set its Stack Pointer msr cpsr_c, #Mode_UND|I_Bit|F_Bit mov sp, r0 sub r0, r0, #UND_Stack_Size @ Enter Abort Mode and set its Stack Pointer msr cpsr_c, #Mode_ABT|I_Bit|F_Bit mov sp, r0 sub r0, r0, #ABT_Stack_Size #endif @ Enter FIQ Mode and set its Stack Pointer msr cpsr_c, #Mode_FIQ|I_Bit|F_Bit mov sp, r0 sub r0, r0, #RT_FIQ_STACK_PGSZ @ Enter IRQ Mode and set its Stack Pointer msr cpsr_c, #Mode_IRQ|I_Bit|F_Bit mov sp, r0 sub r0, r0, #RT_IRQ_STACK_PGSZ /* come back to SVC mode */ msr cpsr_c, #Mode_SVC|I_Bit|F_Bit bx lr /* exception handlers: undef, swi, padt, dabt, resv, irq, fiq */ .section .text.isr, "ax" .align 5 .globl vector_fiq vector_fiq: stmfd sp!,{r0-r7,lr} bl rt_hw_trap_fiq ldmfd sp!,{r0-r7,lr} subs pc, lr, #4 .globl rt_interrupt_enter .globl rt_interrupt_leave .globl rt_thread_switch_interrupt_flag .globl rt_interrupt_from_thread .globl rt_interrupt_to_thread .globl rt_current_thread .globl vmm_thread .globl vmm_virq_check .align 5 .globl vector_irq vector_irq: stmfd sp!, {r0-r12,lr} #ifdef RT_VMM_USING_DOMAIN @ save the last domain mrc p15, 0, r5, c3, c0 @ switch to vmm domain as we are going to call vmm codes ldr r1, =vmm_domain_val ldr r4, [r1] mcr p15, 0, r4, c3, c0 #endif bl rt_interrupt_enter bl rt_hw_trap_irq bl rt_interrupt_leave #ifdef RT_VMM_USING_DOMAIN @ restore the last domain. It do some redundant work but simplify the @ logic. It might be the guest domain so rt_thread_switch_interrupt_flag @ should lay in .bss.share mcr p15, 0, r5, c3, c0 #endif @ if rt_thread_switch_interrupt_flag set, jump to @ rt_hw_context_switch_interrupt_do and don't return ldr r0, =rt_thread_switch_interrupt_flag ldr r1, [r0] cmp r1, #1 beq rt_hw_context_switch_interrupt_do #ifndef RT_USING_VMM ldmfd sp!, {r0-r12,lr} subs pc, lr, #4 #else #ifdef RT_VMM_USING_DOMAIN @ r4 is vmm_domain_val @ back to vmm domain as we need access rt_current_thread mcr p15, 0, r4, c3, c0 #endif /* check whether we need to do IRQ routing * ensure the int is disabled. Or there will be an infinite loop. */ ldr r0, =rt_current_thread ldr r0, [r0] ldr r1, =vmm_thread cmp r0, r1 beq switch_to_guest #ifdef RT_VMM_USING_DOMAIN @ r5 is domain of interrupted context @ it might be super_domain_val or vmm_domain_val so we need to restore it. mcr p15, 0, r5, c3, c0 #endif @ switch back if the interrupted thread is not vmm ldmfd sp!, {r0-r12,lr} subs pc, lr, #4 switch_to_guest: #ifdef RT_VMM_USING_DOMAIN @ We are going to execute rt-thread code but accessing the content of the @ guest. So switch to super domain. ldr r1, =super_domain_val ldr r0, [r1] mcr p15, 0, r0, c3, c0 #endif /* check whether there is a pending interrupt for Guest OS */ bl vmm_virq_check #ifdef RT_VMM_USING_DOMAIN @ All done, restore the guest domain. mcr p15, 0, r5, c3, c0 #endif cmp r0, #0x0 beq route_irq_to_guest ldmfd sp!, {r0-r12,lr} subs pc, lr, #4 route_irq_to_guest: ldmfd sp!, {r0-r12,lr} b orig_irq_isr #endif /* RT_USING_VMM */ rt_hw_context_switch_interrupt_do: mov r1, #0 @ clear flag str r1, [r0] mov r1, sp @ r1 point to {r0-r3} in stack add sp, sp, #4*4 ldmfd sp!, {r4-r12,lr}@ reload saved registers mrs r0, spsr @ get cpsr of interrupt thread sub r2, lr, #4 @ save old task's pc to r2 @ Switch to SVC mode with no interrupt. If the usr mode guest is @ interrupted, this will just switch to the stack of kernel space. @ save the registers in kernel space won't trigger data abort. msr cpsr_c, #I_Bit|F_Bit|Mode_SVC stmfd sp!, {r2} @ push old task's pc stmfd sp!, {r4-r12,lr}@ push old task's lr,r12-r4 ldmfd r1, {r1-r4} @ restore r0-r3 of the interrupt thread stmfd sp!, {r1-r4} @ push old task's r0-r3 stmfd sp!, {r0} @ push old task's cpsr ldr r4, =rt_interrupt_from_thread ldr r5, [r4] str sp, [r5] @ store sp in preempted tasks's TCB #ifdef RT_VMM_USING_DOMAIN @ If a thread is wake up by interrupt, it should be RTT thread. @ Make sure the domain is correct. ldr r1, =vmm_domain_val ldr r2, [r1] mcr p15, 0, r2, c3, c0 #endif ldr r6, =rt_interrupt_to_thread ldr r6, [r6] ldr sp, [r6] @ get new task's stack pointer ldmfd sp!, {r4} @ pop new task's cpsr to spsr msr spsr_cxsf, r4 ldmfd sp!, {r0-r12,lr,pc}^ @ pop new task's r0-r12,lr & pc, copy spsr to cpsr .macro push_svc_reg sub sp, sp, #17 * 4 @/* Sizeof(struct rt_hw_exp_stack) */ stmia sp, {r0 - r12} @/* Calling r0-r12 */ mov r0, sp mrs r6, spsr @/* Save CPSR */ str lr, [r0, #15*4] @/* Push PC */ str r6, [r0, #16*4] @/* Push CPSR */ cps #Mode_SVC str sp, [r0, #13*4] @/* Save calling SP */ str lr, [r0, #14*4] @/* Save calling PC */ .endm .align 5 .globl vector_swi vector_swi: push_svc_reg bl rt_hw_trap_swi b . .align 5 .globl vector_undef vector_undef: push_svc_reg bl rt_hw_trap_undef b . .align 5 .globl vector_pabt vector_pabt: push_svc_reg bl rt_hw_trap_pabt b . .align 5 .globl vector_dabt vector_dabt: push_svc_reg bl rt_hw_trap_dabt b . .align 5 .globl vector_resv vector_resv: push_svc_reg bl rt_hw_trap_resv b .