1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
/* Copyright 2012 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
* Context swtching
*/
#include "config.h"
.text
.syntax unified
.code 16
/**
* Task context switching
*
* Change the task scheduled after returning from the exception.
*
* Save the registers of the current task below the exception context on
* its task, then restore the live registers of the next task and set the
* process stack pointer to the new stack.
*
* r0: pointer to the task to switch from
* r1: pointer to the task to switch to
*
* must be called from interrupt context
*
* the structure of the saved context on the stack is :
* r0, r1, r2, r3, r12, lr, pc, psr, r4, r5, r6, r7, r8, r9, r10, r11
* exception frame <|> additional registers
*
* if using the FPU, then to store FPU context, add FP regs to the stack. in
* this case the exception frame by default contains:
* r0, r1, r2, r3, r12, lr, pc, psr,
* s0 - s15, FPSCR, +1 word for 64-bit alignment
* then in addition we store the following registers:
* r4, r5, r6, r7, r8, r9, r10, r11
* s16 - s31 (stored iff FP was used by the task (see EXC_RETURN[4]))
* note that for the context switch to know if the next task has the extra FP
* regs on the stack or not, we make use of the least significant bit of the
* stack pointer. lsb of stack pointer is 1 if task has FP regs on stack, and
* 0 otherwise.
*
*/
.global __switchto
.thumb_func
__switchto:
mrs r3, psp @ get the task stack where the context has been saved
ldr r2, [r1] @ get the new scheduled task stack pointer
stmdb r3!, {r4-r11} @ save additional r4-r11 in the task stack
#ifdef CONFIG_FPU
tst lr, #(1<<4) @ test EXC_RETURN[4] for old task
itt eq @ if EXC_RETURN[4] is zero, add FP regs to stack
vstmdbeq r3!, {s16-s31}@ save additional FP s16-s31 in the task stack.
@ if using lazy stacking, this will trigger saving
@ s0-s15 in the reserved stack space.
orreq r3, #1 @ set lsb of old stack pointer high to represent this
@ task uses FPU. note stack pointer should be 64-bit
@ aligned, so using this bit should be safe.
tst r2, #1 @ test lsb of next stack pointer
ittte ne @ if lsb is 1, then next task has FP regs on stack
bicne r2, #1 @ clear lsb of new stack pointer
bicne lr, #(1<<4) @ clear EXC_RETURN[4] for next task
vldmiane r2!, {s16-s31}@ restore s16-s31 for the next task context
orreq lr, #(1<<4) @ else if new stack doesn't use FP, set EXC_RETURN[4]
#endif
ldmia r2!, {r4-r11} @ restore r4-r11 for the next task context
str r3, [r0] @ save the task stack pointer in its context
msr psp, r2 @ set the process stack pointer to exception context
bx lr @ return from exception
/**
* Start the task scheduling. r0 is a pointer to task_stack_ready, which is
* set to 1 after the task stack is set up.
*/
.global __task_start
.thumb_func
__task_start:
ldr r2,=scratchpad @ area used as thread stack for the first switch
mov r3, #2 @ use : priv. mode / thread stack / no floating point
@ setting FP to unused here means first context switch
@ will not store FP regs
add r2, #17*4 @ put the pointer at the top of the stack
mov r1, #0 @ __Schedule parameter : re-schedule nothing
msr psp, r2 @ setup a thread stack up to the first context switch
mov r2, #1
isb @ ensure the write is done
msr control, r3
mov r3, r0
mov r0, #0 @ __Schedule parameter : de-schedule nothing
isb @ ensure the write is done
str r2, [r3] @ Task scheduling is now active
bl __schedule @ execute the task with the highest priority
/* we should never return here */
mov r0, #1 @ set to EC_ERROR_UNKNOWN
bx lr
|
