1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * PARISC Architecture-dependent parts of process handling |
4 | * based on the work for i386 |
5 | * |
6 | * Copyright (C) 1999-2003 Matthew Wilcox <willy at parisc-linux.org> |
7 | * Copyright (C) 2000 Martin K Petersen <mkp at mkp.net> |
8 | * Copyright (C) 2000 John Marvin <jsm at parisc-linux.org> |
9 | * Copyright (C) 2000 David Huggins-Daines <dhd with pobox.org> |
10 | * Copyright (C) 2000-2003 Paul Bame <bame at parisc-linux.org> |
11 | * Copyright (C) 2000 Philipp Rumpf <prumpf with tux.org> |
12 | * Copyright (C) 2000 David Kennedy <dkennedy with linuxcare.com> |
13 | * Copyright (C) 2000 Richard Hirst <rhirst with parisc-linux.org> |
14 | * Copyright (C) 2000 Grant Grundler <grundler with parisc-linux.org> |
15 | * Copyright (C) 2001 Alan Modra <amodra at parisc-linux.org> |
16 | * Copyright (C) 2001-2002 Ryan Bradetich <rbrad at parisc-linux.org> |
17 | * Copyright (C) 2001-2014 Helge Deller <deller@gmx.de> |
18 | * Copyright (C) 2002 Randolph Chung <tausq with parisc-linux.org> |
19 | */ |
20 | #include <linux/elf.h> |
21 | #include <linux/errno.h> |
22 | #include <linux/kernel.h> |
23 | #include <linux/mm.h> |
24 | #include <linux/fs.h> |
25 | #include <linux/cpu.h> |
26 | #include <linux/module.h> |
27 | #include <linux/personality.h> |
28 | #include <linux/ptrace.h> |
29 | #include <linux/reboot.h> |
30 | #include <linux/sched.h> |
31 | #include <linux/sched/debug.h> |
32 | #include <linux/sched/task.h> |
33 | #include <linux/sched/task_stack.h> |
34 | #include <linux/slab.h> |
35 | #include <linux/stddef.h> |
36 | #include <linux/unistd.h> |
37 | #include <linux/kallsyms.h> |
38 | #include <linux/uaccess.h> |
39 | #include <linux/rcupdate.h> |
40 | #include <linux/random.h> |
41 | #include <linux/nmi.h> |
42 | #include <linux/sched/hotplug.h> |
43 | |
44 | #include <asm/io.h> |
45 | #include <asm/asm-offsets.h> |
46 | #include <asm/assembly.h> |
47 | #include <asm/pdc.h> |
48 | #include <asm/pdc_chassis.h> |
49 | #include <asm/unwind.h> |
50 | #include <asm/sections.h> |
51 | #include <asm/cacheflush.h> |
52 | |
53 | #define COMMAND_GLOBAL F_EXTEND(0xfffe0030) |
54 | #define CMD_RESET 5 /* reset any module */ |
55 | |
56 | /* |
57 | ** The Wright Brothers and Gecko systems have a H/W problem |
58 | ** (Lasi...'nuf said) may cause a broadcast reset to lockup |
59 | ** the system. An HVERSION dependent PDC call was developed |
60 | ** to perform a "safe", platform specific broadcast reset instead |
61 | ** of kludging up all the code. |
62 | ** |
63 | ** Older machines which do not implement PDC_BROADCAST_RESET will |
64 | ** return (with an error) and the regular broadcast reset can be |
65 | ** issued. Obviously, if the PDC does implement PDC_BROADCAST_RESET |
66 | ** the PDC call will not return (the system will be reset). |
67 | */ |
68 | void machine_restart(char *cmd) |
69 | { |
70 | #ifdef FASTBOOT_SELFTEST_SUPPORT |
71 | /* |
72 | ** If user has modified the Firmware Selftest Bitmap, |
73 | ** run the tests specified in the bitmap after the |
74 | ** system is rebooted w/PDC_DO_RESET. |
75 | ** |
76 | ** ftc_bitmap = 0x1AUL "Skip destructive memory tests" |
77 | ** |
78 | ** Using "directed resets" at each processor with the MEM_TOC |
79 | ** vector cleared will also avoid running destructive |
80 | ** memory self tests. (Not implemented yet) |
81 | */ |
82 | if (ftc_bitmap) { |
83 | pdc_do_firm_test_reset(ftc_bitmap); |
84 | } |
85 | #endif |
86 | /* set up a new led state on systems shipped with a LED State panel */ |
87 | pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN); |
88 | |
89 | /* "Normal" system reset */ |
90 | pdc_do_reset(); |
91 | |
92 | /* Nope...box should reset with just CMD_RESET now */ |
93 | gsc_writel(CMD_RESET, COMMAND_GLOBAL); |
94 | |
95 | /* Wait for RESET to lay us to rest. */ |
96 | while (1) ; |
97 | |
98 | } |
99 | |
100 | /* |
101 | * This routine is called from sys_reboot to actually turn off the |
102 | * machine |
103 | */ |
104 | void machine_power_off(void) |
105 | { |
106 | /* Put the soft power button back under hardware control. |
107 | * If the user had already pressed the power button, the |
108 | * following call will immediately power off. */ |
109 | pdc_soft_power_button(0); |
110 | |
111 | pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN); |
112 | |
113 | /* ipmi_poweroff may have been installed. */ |
114 | do_kernel_power_off(); |
115 | |
116 | /* It seems we have no way to power the system off via |
117 | * software. The user has to press the button himself. */ |
118 | |
119 | printk("Power off or press RETURN to reboot.\n" ); |
120 | |
121 | /* prevent soft lockup/stalled CPU messages for endless loop. */ |
122 | rcu_sysrq_start(); |
123 | lockup_detector_soft_poweroff(); |
124 | while (1) { |
125 | /* reboot if user presses RETURN key */ |
126 | if (pdc_iodc_getc() == 13) { |
127 | printk("Rebooting...\n" ); |
128 | machine_restart(NULL); |
129 | } |
130 | } |
131 | } |
132 | |
133 | void (*pm_power_off)(void); |
134 | EXPORT_SYMBOL(pm_power_off); |
135 | |
136 | void machine_halt(void) |
137 | { |
138 | machine_power_off(); |
139 | } |
140 | |
141 | void flush_thread(void) |
142 | { |
143 | /* Only needs to handle fpu stuff or perf monitors. |
144 | ** REVISIT: several arches implement a "lazy fpu state". |
145 | */ |
146 | } |
147 | |
148 | /* |
149 | * Idle thread support |
150 | * |
151 | * Detect when running on QEMU with SeaBIOS PDC Firmware and let |
152 | * QEMU idle the host too. |
153 | */ |
154 | |
155 | int running_on_qemu __ro_after_init; |
156 | EXPORT_SYMBOL(running_on_qemu); |
157 | |
158 | /* |
159 | * Called from the idle thread for the CPU which has been shutdown. |
160 | */ |
161 | void __noreturn arch_cpu_idle_dead(void) |
162 | { |
163 | #ifdef CONFIG_HOTPLUG_CPU |
164 | idle_task_exit(); |
165 | |
166 | local_irq_disable(); |
167 | |
168 | /* Tell the core that this CPU is now safe to dispose of. */ |
169 | cpuhp_ap_report_dead(); |
170 | |
171 | /* Ensure that the cache lines are written out. */ |
172 | flush_cache_all_local(); |
173 | flush_tlb_all_local(NULL); |
174 | |
175 | /* Let PDC firmware put CPU into firmware idle loop. */ |
176 | __pdc_cpu_rendezvous(); |
177 | |
178 | pr_warn("PDC does not provide rendezvous function.\n" ); |
179 | #endif |
180 | while (1); |
181 | } |
182 | |
183 | void __cpuidle arch_cpu_idle(void) |
184 | { |
185 | /* nop on real hardware, qemu will idle sleep. */ |
186 | asm volatile("or %%r10,%%r10,%%r10\n" :::); |
187 | } |
188 | |
189 | static int __init parisc_idle_init(void) |
190 | { |
191 | if (!running_on_qemu) |
192 | cpu_idle_poll_ctrl(enable: 1); |
193 | |
194 | return 0; |
195 | } |
196 | arch_initcall(parisc_idle_init); |
197 | |
198 | /* |
199 | * Copy architecture-specific thread state |
200 | */ |
201 | int |
202 | copy_thread(struct task_struct *p, const struct kernel_clone_args *args) |
203 | { |
204 | unsigned long clone_flags = args->flags; |
205 | unsigned long usp = args->stack; |
206 | unsigned long tls = args->tls; |
207 | struct pt_regs *cregs = &(p->thread.regs); |
208 | void *stack = task_stack_page(task: p); |
209 | |
210 | /* We have to use void * instead of a function pointer, because |
211 | * function pointers aren't a pointer to the function on 64-bit. |
212 | * Make them const so the compiler knows they live in .text */ |
213 | extern void * const ret_from_kernel_thread; |
214 | extern void * const child_return; |
215 | |
216 | if (unlikely(args->fn)) { |
217 | /* kernel thread */ |
218 | memset(cregs, 0, sizeof(struct pt_regs)); |
219 | if (args->idle) /* idle thread */ |
220 | return 0; |
221 | /* Must exit via ret_from_kernel_thread in order |
222 | * to call schedule_tail() |
223 | */ |
224 | cregs->ksp = (unsigned long) stack + FRAME_SIZE + PT_SZ_ALGN; |
225 | cregs->kpc = (unsigned long) &ret_from_kernel_thread; |
226 | /* |
227 | * Copy function and argument to be called from |
228 | * ret_from_kernel_thread. |
229 | */ |
230 | #ifdef CONFIG_64BIT |
231 | cregs->gr[27] = ((unsigned long *)args->fn)[3]; |
232 | cregs->gr[26] = ((unsigned long *)args->fn)[2]; |
233 | #else |
234 | cregs->gr[26] = (unsigned long) args->fn; |
235 | #endif |
236 | cregs->gr[25] = (unsigned long) args->fn_arg; |
237 | } else { |
238 | /* user thread */ |
239 | /* usp must be word aligned. This also prevents users from |
240 | * passing in the value 1 (which is the signal for a special |
241 | * return for a kernel thread) */ |
242 | if (usp) { |
243 | usp = ALIGN(usp, 4); |
244 | if (likely(usp)) |
245 | cregs->gr[30] = usp; |
246 | } |
247 | cregs->ksp = (unsigned long) stack + FRAME_SIZE; |
248 | cregs->kpc = (unsigned long) &child_return; |
249 | |
250 | /* Setup thread TLS area */ |
251 | if (clone_flags & CLONE_SETTLS) |
252 | cregs->cr27 = tls; |
253 | } |
254 | |
255 | return 0; |
256 | } |
257 | |
258 | unsigned long |
259 | __get_wchan(struct task_struct *p) |
260 | { |
261 | struct unwind_frame_info info; |
262 | unsigned long ip; |
263 | int count = 0; |
264 | |
265 | /* |
266 | * These bracket the sleeping functions.. |
267 | */ |
268 | |
269 | unwind_frame_init_from_blocked_task(&info, p); |
270 | do { |
271 | if (unwind_once(&info) < 0) |
272 | return 0; |
273 | if (task_is_running(p)) |
274 | return 0; |
275 | ip = info.ip; |
276 | if (!in_sched_functions(ip)) |
277 | return ip; |
278 | } while (count++ < MAX_UNWIND_ENTRIES); |
279 | return 0; |
280 | } |
281 | |