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#include <stdarg.h>
36
37#include <linux/elf.h>
38#include <linux/errno.h>
39#include <linux/kernel.h>
40#include <linux/mm.h>
41#include <linux/fs.h>
42#include <linux/cpu.h>
43#include <linux/module.h>
44#include <linux/personality.h>
45#include <linux/ptrace.h>
46#include <linux/sched.h>
47#include <linux/sched/debug.h>
48#include <linux/sched/task.h>
49#include <linux/sched/task_stack.h>
50#include <linux/slab.h>
51#include <linux/stddef.h>
52#include <linux/unistd.h>
53#include <linux/kallsyms.h>
54#include <linux/uaccess.h>
55#include <linux/rcupdate.h>
56#include <linux/random.h>
57#include <linux/nmi.h>
58
59#include <asm/io.h>
60#include <asm/asm-offsets.h>
61#include <asm/assembly.h>
62#include <asm/pdc.h>
63#include <asm/pdc_chassis.h>
64#include <asm/pgalloc.h>
65#include <asm/unwind.h>
66#include <asm/sections.h>
67
68#define COMMAND_GLOBAL F_EXTEND(0xfffe0030)
69#define CMD_RESET 5
70
71
72
73
74
75
76
77
78
79
80
81
82
83void machine_restart(char *cmd)
84{
85#ifdef FASTBOOT_SELFTEST_SUPPORT
86
87
88
89
90
91
92
93
94
95
96
97 if (ftc_bitmap) {
98 pdc_do_firm_test_reset(ftc_bitmap);
99 }
100#endif
101
102 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
103
104
105 pdc_do_reset();
106
107
108 gsc_writel(CMD_RESET, COMMAND_GLOBAL);
109
110
111 while (1) ;
112
113}
114
115void (*chassis_power_off)(void);
116
117
118
119
120
121void machine_power_off(void)
122{
123
124 if (chassis_power_off)
125 chassis_power_off();
126
127
128
129
130 pdc_soft_power_button(0);
131
132 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
133
134
135 if (pm_power_off)
136 pm_power_off();
137
138
139
140
141 printk(KERN_EMERG "System shut down completed.\n"
142 "Please power this system off now.");
143
144
145 rcu_sysrq_start();
146 lockup_detector_soft_poweroff();
147 for (;;);
148}
149
150void (*pm_power_off)(void);
151EXPORT_SYMBOL(pm_power_off);
152
153void machine_halt(void)
154{
155 machine_power_off();
156}
157
158void flush_thread(void)
159{
160
161
162
163}
164
165void release_thread(struct task_struct *dead_task)
166{
167}
168
169
170
171
172
173int dump_fpu (struct pt_regs * regs, elf_fpregset_t *r)
174{
175 if (regs == NULL)
176 return 0;
177
178 memcpy(r, regs->fr, sizeof *r);
179 return 1;
180}
181
182int dump_task_fpu (struct task_struct *tsk, elf_fpregset_t *r)
183{
184 memcpy(r, tsk->thread.regs.fr, sizeof(*r));
185 return 1;
186}
187
188
189
190
191
192
193
194
195int running_on_qemu __read_mostly;
196
197void __cpuidle arch_cpu_idle_dead(void)
198{
199
200 asm volatile("or %%r31,%%r31,%%r31\n":::);
201}
202
203void __cpuidle arch_cpu_idle(void)
204{
205 local_irq_enable();
206
207
208 asm volatile("or %%r10,%%r10,%%r10\n":::);
209}
210
211static int __init parisc_idle_init(void)
212{
213 const char *marker;
214
215
216 marker = (char *) &PAGE0->pad0;
217 running_on_qemu = (memcmp(marker, "SeaBIOS", 8) == 0);
218
219 if (!running_on_qemu)
220 cpu_idle_poll_ctrl(1);
221
222 return 0;
223}
224arch_initcall(parisc_idle_init);
225
226
227
228
229int
230copy_thread(unsigned long clone_flags, unsigned long usp,
231 unsigned long kthread_arg, struct task_struct *p)
232{
233 struct pt_regs *cregs = &(p->thread.regs);
234 void *stack = task_stack_page(p);
235
236
237
238
239 extern void * const ret_from_kernel_thread;
240 extern void * const child_return;
241
242 if (unlikely(p->flags & PF_KTHREAD)) {
243
244 memset(cregs, 0, sizeof(struct pt_regs));
245 if (!usp)
246 return 0;
247
248
249
250 cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN + FRAME_SIZE;
251 cregs->kpc = (unsigned long) &ret_from_kernel_thread;
252
253
254
255
256#ifdef CONFIG_64BIT
257 cregs->gr[27] = ((unsigned long *)usp)[3];
258 cregs->gr[26] = ((unsigned long *)usp)[2];
259#else
260 cregs->gr[26] = usp;
261#endif
262 cregs->gr[25] = kthread_arg;
263 } else {
264
265
266
267
268 if (usp) {
269 usp = ALIGN(usp, 4);
270 if (likely(usp))
271 cregs->gr[30] = usp;
272 }
273 cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN + FRAME_SIZE;
274 cregs->kpc = (unsigned long) &child_return;
275
276
277 if (clone_flags & CLONE_SETTLS)
278 cregs->cr27 = cregs->gr[23];
279 }
280
281 return 0;
282}
283
284unsigned long
285get_wchan(struct task_struct *p)
286{
287 struct unwind_frame_info info;
288 unsigned long ip;
289 int count = 0;
290
291 if (!p || p == current || p->state == TASK_RUNNING)
292 return 0;
293
294
295
296
297
298 unwind_frame_init_from_blocked_task(&info, p);
299 do {
300 if (unwind_once(&info) < 0)
301 return 0;
302 ip = info.ip;
303 if (!in_sched_functions(ip))
304 return ip;
305 } while (count++ < 16);
306 return 0;
307}
308
309#ifdef CONFIG_64BIT
310void *dereference_function_descriptor(void *ptr)
311{
312 Elf64_Fdesc *desc = ptr;
313 void *p;
314
315 if (!probe_kernel_address(&desc->addr, p))
316 ptr = p;
317 return ptr;
318}
319
320void *dereference_kernel_function_descriptor(void *ptr)
321{
322 if (ptr < (void *)__start_opd ||
323 ptr >= (void *)__end_opd)
324 return ptr;
325
326 return dereference_function_descriptor(ptr);
327}
328#endif
329
330static inline unsigned long brk_rnd(void)
331{
332 return (get_random_int() & BRK_RND_MASK) << PAGE_SHIFT;
333}
334
335unsigned long arch_randomize_brk(struct mm_struct *mm)
336{
337 unsigned long ret = PAGE_ALIGN(mm->brk + brk_rnd());
338
339 if (ret < mm->brk)
340 return mm->brk;
341 return ret;
342}
343