Commit | Line | Data |
---|---|---|
a15e9ffa GH |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // Copyright (C) 2005-2017 Andes Technology Corporation | |
3 | ||
4 | #include <linux/sched.h> | |
5 | #include <linux/sched/debug.h> | |
6 | #include <linux/sched/task_stack.h> | |
7 | #include <linux/delay.h> | |
8 | #include <linux/kallsyms.h> | |
9 | #include <linux/uaccess.h> | |
10 | #include <asm/elf.h> | |
11 | #include <asm/proc-fns.h> | |
e46bf83c | 12 | #include <asm/fpu.h> |
a15e9ffa GH |
13 | #include <linux/ptrace.h> |
14 | #include <linux/reboot.h> | |
15 | ||
e46bf83c VC |
16 | #if IS_ENABLED(CONFIG_LAZY_FPU) |
17 | struct task_struct *last_task_used_math; | |
a15e9ffa GH |
18 | #endif |
19 | ||
e46bf83c VC |
20 | extern void setup_mm_for_reboot(char mode); |
21 | ||
a15e9ffa GH |
22 | extern inline void arch_reset(char mode) |
23 | { | |
24 | if (mode == 's') { | |
25 | /* Use cpu handler, jump to 0 */ | |
26 | cpu_reset(0); | |
27 | } | |
28 | } | |
29 | ||
30 | void (*pm_power_off) (void); | |
31 | EXPORT_SYMBOL(pm_power_off); | |
32 | ||
33 | static char reboot_mode_nds32 = 'h'; | |
34 | ||
35 | int __init reboot_setup(char *str) | |
36 | { | |
37 | reboot_mode_nds32 = str[0]; | |
38 | return 1; | |
39 | } | |
40 | ||
41 | static int cpub_pwroff(void) | |
42 | { | |
43 | return 0; | |
44 | } | |
45 | ||
46 | __setup("reboot=", reboot_setup); | |
47 | ||
48 | void machine_halt(void) | |
49 | { | |
50 | cpub_pwroff(); | |
51 | } | |
52 | ||
53 | EXPORT_SYMBOL(machine_halt); | |
54 | ||
55 | void machine_power_off(void) | |
56 | { | |
57 | if (pm_power_off) | |
58 | pm_power_off(); | |
59 | } | |
60 | ||
61 | EXPORT_SYMBOL(machine_power_off); | |
62 | ||
63 | void machine_restart(char *cmd) | |
64 | { | |
65 | /* | |
66 | * Clean and disable cache, and turn off interrupts | |
67 | */ | |
68 | cpu_proc_fin(); | |
69 | ||
70 | /* | |
71 | * Tell the mm system that we are going to reboot - | |
72 | * we may need it to insert some 1:1 mappings so that | |
73 | * soft boot works. | |
74 | */ | |
75 | setup_mm_for_reboot(reboot_mode_nds32); | |
76 | ||
77 | /* Execute kernel restart handler call chain */ | |
78 | do_kernel_restart(cmd); | |
79 | ||
80 | /* | |
81 | * Now call the architecture specific reboot code. | |
82 | */ | |
83 | arch_reset(reboot_mode_nds32); | |
84 | ||
85 | /* | |
86 | * Whoops - the architecture was unable to reboot. | |
87 | * Tell the user! | |
88 | */ | |
89 | mdelay(1000); | |
90 | pr_info("Reboot failed -- System halted\n"); | |
91 | while (1) ; | |
92 | } | |
93 | ||
94 | EXPORT_SYMBOL(machine_restart); | |
95 | ||
96 | void show_regs(struct pt_regs *regs) | |
97 | { | |
98 | printk("PC is at %pS\n", (void *)instruction_pointer(regs)); | |
99 | printk("LP is at %pS\n", (void *)regs->lp); | |
100 | pr_info("pc : [<%08lx>] lp : [<%08lx>] %s\n" | |
101 | "sp : %08lx fp : %08lx gp : %08lx\n", | |
102 | instruction_pointer(regs), | |
103 | regs->lp, print_tainted(), regs->sp, regs->fp, regs->gp); | |
104 | pr_info("r25: %08lx r24: %08lx\n", regs->uregs[25], regs->uregs[24]); | |
105 | ||
106 | pr_info("r23: %08lx r22: %08lx r21: %08lx r20: %08lx\n", | |
107 | regs->uregs[23], regs->uregs[22], | |
108 | regs->uregs[21], regs->uregs[20]); | |
109 | pr_info("r19: %08lx r18: %08lx r17: %08lx r16: %08lx\n", | |
110 | regs->uregs[19], regs->uregs[18], | |
111 | regs->uregs[17], regs->uregs[16]); | |
112 | pr_info("r15: %08lx r14: %08lx r13: %08lx r12: %08lx\n", | |
113 | regs->uregs[15], regs->uregs[14], | |
114 | regs->uregs[13], regs->uregs[12]); | |
115 | pr_info("r11: %08lx r10: %08lx r9 : %08lx r8 : %08lx\n", | |
116 | regs->uregs[11], regs->uregs[10], | |
117 | regs->uregs[9], regs->uregs[8]); | |
118 | pr_info("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n", | |
119 | regs->uregs[7], regs->uregs[6], regs->uregs[5], regs->uregs[4]); | |
120 | pr_info("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n", | |
121 | regs->uregs[3], regs->uregs[2], regs->uregs[1], regs->uregs[0]); | |
122 | pr_info(" IRQs o%s Segment %s\n", | |
123 | interrupts_enabled(regs) ? "n" : "ff", | |
736706be | 124 | segment_eq(get_fs(), KERNEL_DS)? "kernel" : "user"); |
a15e9ffa GH |
125 | } |
126 | ||
127 | EXPORT_SYMBOL(show_regs); | |
128 | ||
e46bf83c VC |
129 | void exit_thread(struct task_struct *tsk) |
130 | { | |
131 | #if defined(CONFIG_FPU) && defined(CONFIG_LAZY_FPU) | |
132 | if (last_task_used_math == tsk) | |
133 | last_task_used_math = NULL; | |
134 | #endif | |
135 | } | |
136 | ||
a15e9ffa GH |
137 | void flush_thread(void) |
138 | { | |
e46bf83c VC |
139 | #if defined(CONFIG_FPU) |
140 | clear_fpu(task_pt_regs(current)); | |
141 | clear_used_math(); | |
142 | # ifdef CONFIG_LAZY_FPU | |
143 | if (last_task_used_math == current) | |
144 | last_task_used_math = NULL; | |
145 | # endif | |
146 | #endif | |
a15e9ffa GH |
147 | } |
148 | ||
149 | DEFINE_PER_CPU(struct task_struct *, __entry_task); | |
150 | ||
151 | asmlinkage void ret_from_fork(void) __asm__("ret_from_fork"); | |
152 | int copy_thread(unsigned long clone_flags, unsigned long stack_start, | |
e46bf83c | 153 | unsigned long stk_sz, struct task_struct *p) |
a15e9ffa GH |
154 | { |
155 | struct pt_regs *childregs = task_pt_regs(p); | |
156 | ||
157 | memset(&p->thread.cpu_context, 0, sizeof(struct cpu_context)); | |
158 | ||
159 | if (unlikely(p->flags & PF_KTHREAD)) { | |
160 | memset(childregs, 0, sizeof(struct pt_regs)); | |
161 | /* kernel thread fn */ | |
162 | p->thread.cpu_context.r6 = stack_start; | |
163 | /* kernel thread argument */ | |
164 | p->thread.cpu_context.r7 = stk_sz; | |
165 | } else { | |
166 | *childregs = *current_pt_regs(); | |
167 | if (stack_start) | |
168 | childregs->sp = stack_start; | |
169 | /* child get zero as ret. */ | |
170 | childregs->uregs[0] = 0; | |
171 | childregs->osp = 0; | |
172 | if (clone_flags & CLONE_SETTLS) | |
173 | childregs->uregs[25] = childregs->uregs[3]; | |
174 | } | |
175 | /* cpu context switching */ | |
176 | p->thread.cpu_context.pc = (unsigned long)ret_from_fork; | |
177 | p->thread.cpu_context.sp = (unsigned long)childregs; | |
178 | ||
e46bf83c VC |
179 | #if IS_ENABLED(CONFIG_FPU) |
180 | if (used_math()) { | |
181 | # if !IS_ENABLED(CONFIG_LAZY_FPU) | |
182 | unlazy_fpu(current); | |
183 | # else | |
184 | preempt_disable(); | |
185 | if (last_task_used_math == current) | |
186 | save_fpu(current); | |
187 | preempt_enable(); | |
188 | # endif | |
189 | p->thread.fpu = current->thread.fpu; | |
190 | clear_fpu(task_pt_regs(p)); | |
191 | set_stopped_child_used_math(p); | |
192 | } | |
193 | #endif | |
194 | ||
a15e9ffa GH |
195 | #ifdef CONFIG_HWZOL |
196 | childregs->lb = 0; | |
197 | childregs->le = 0; | |
198 | childregs->lc = 0; | |
199 | #endif | |
200 | ||
201 | return 0; | |
202 | } | |
203 | ||
e46bf83c VC |
204 | #if IS_ENABLED(CONFIG_FPU) |
205 | struct task_struct *_switch_fpu(struct task_struct *prev, struct task_struct *next) | |
206 | { | |
207 | #if !IS_ENABLED(CONFIG_LAZY_FPU) | |
208 | unlazy_fpu(prev); | |
209 | #endif | |
210 | if (!(next->flags & PF_KTHREAD)) | |
211 | clear_fpu(task_pt_regs(next)); | |
212 | return prev; | |
213 | } | |
214 | #endif | |
215 | ||
a15e9ffa GH |
216 | /* |
217 | * fill in the fpe structure for a core dump... | |
218 | */ | |
219 | int dump_fpu(struct pt_regs *regs, elf_fpregset_t * fpu) | |
220 | { | |
221 | int fpvalid = 0; | |
e46bf83c VC |
222 | #if IS_ENABLED(CONFIG_FPU) |
223 | struct task_struct *tsk = current; | |
224 | ||
225 | fpvalid = tsk_used_math(tsk); | |
226 | if (fpvalid) { | |
227 | lose_fpu(); | |
228 | memcpy(fpu, &tsk->thread.fpu, sizeof(*fpu)); | |
229 | } | |
230 | #endif | |
a15e9ffa GH |
231 | return fpvalid; |
232 | } | |
233 | ||
234 | EXPORT_SYMBOL(dump_fpu); | |
235 | ||
236 | unsigned long get_wchan(struct task_struct *p) | |
237 | { | |
238 | unsigned long fp, lr; | |
239 | unsigned long stack_start, stack_end; | |
240 | int count = 0; | |
241 | ||
242 | if (!p || p == current || p->state == TASK_RUNNING) | |
243 | return 0; | |
244 | ||
245 | if (IS_ENABLED(CONFIG_FRAME_POINTER)) { | |
246 | stack_start = (unsigned long)end_of_stack(p); | |
247 | stack_end = (unsigned long)task_stack_page(p) + THREAD_SIZE; | |
248 | ||
249 | fp = thread_saved_fp(p); | |
250 | do { | |
251 | if (fp < stack_start || fp > stack_end) | |
252 | return 0; | |
253 | lr = ((unsigned long *)fp)[0]; | |
254 | if (!in_sched_functions(lr)) | |
255 | return lr; | |
256 | fp = *(unsigned long *)(fp + 4); | |
257 | } while (count++ < 16); | |
258 | } | |
259 | return 0; | |
260 | } | |
261 | ||
262 | EXPORT_SYMBOL(get_wchan); |