process.c (767bf7e7a1e82a81c59778348d156993d0a6175d) process.c (045ab94e10ee17038066d71abc8fdce719ab56f9)
1/*
2 * linux/arch/arm/kernel/process.c
3 *
4 * Copyright (C) 1996-2000 Russell King - Converted to ARM.
5 * Original Copyright (C) 1995 Linus Torvalds
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11#include <stdarg.h>
12
13#include <linux/export.h>
14#include <linux/sched.h>
15#include <linux/kernel.h>
16#include <linux/mm.h>
17#include <linux/stddef.h>
18#include <linux/unistd.h>
19#include <linux/user.h>
1/*
2 * linux/arch/arm/kernel/process.c
3 *
4 * Copyright (C) 1996-2000 Russell King - Converted to ARM.
5 * Original Copyright (C) 1995 Linus Torvalds
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11#include <stdarg.h>
12
13#include <linux/export.h>
14#include <linux/sched.h>
15#include <linux/kernel.h>
16#include <linux/mm.h>
17#include <linux/stddef.h>
18#include <linux/unistd.h>
19#include <linux/user.h>
20#include <linux/delay.h>
21#include <linux/reboot.h>
22#include <linux/interrupt.h>
23#include <linux/kallsyms.h>
24#include <linux/init.h>
20#include <linux/interrupt.h>
21#include <linux/kallsyms.h>
22#include <linux/init.h>
25#include <linux/cpu.h>
26#include <linux/elfcore.h>
27#include <linux/pm.h>
28#include <linux/tick.h>
29#include <linux/utsname.h>
30#include <linux/uaccess.h>
31#include <linux/random.h>
32#include <linux/hw_breakpoint.h>
33#include <linux/leds.h>
23#include <linux/elfcore.h>
24#include <linux/pm.h>
25#include <linux/tick.h>
26#include <linux/utsname.h>
27#include <linux/uaccess.h>
28#include <linux/random.h>
29#include <linux/hw_breakpoint.h>
30#include <linux/leds.h>
34#include <linux/reboot.h>
35
31
36#include <asm/cacheflush.h>
37#include <asm/idmap.h>
38#include <asm/processor.h>
39#include <asm/thread_notify.h>
40#include <asm/stacktrace.h>
41#include <asm/system_misc.h>
42#include <asm/mach/time.h>
43#include <asm/tls.h>
32#include <asm/processor.h>
33#include <asm/thread_notify.h>
34#include <asm/stacktrace.h>
35#include <asm/system_misc.h>
36#include <asm/mach/time.h>
37#include <asm/tls.h>
44#include "reboot.h"
38#include <asm/vdso.h>
45
46#ifdef CONFIG_CC_STACKPROTECTOR
47#include <linux/stackprotector.h>
48unsigned long __stack_chk_guard __read_mostly;
49EXPORT_SYMBOL(__stack_chk_guard);
50#endif
51
52static const char *processor_modes[] __maybe_unused = {
53 "USER_26", "FIQ_26" , "IRQ_26" , "SVC_26" , "UK4_26" , "UK5_26" , "UK6_26" , "UK7_26" ,
54 "UK8_26" , "UK9_26" , "UK10_26", "UK11_26", "UK12_26", "UK13_26", "UK14_26", "UK15_26",
55 "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "MON_32" , "ABT_32" ,
56 "UK8_32" , "UK9_32" , "HYP_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32"
57};
58
59static const char *isa_modes[] __maybe_unused = {
60 "ARM" , "Thumb" , "Jazelle", "ThumbEE"
61};
62
39
40#ifdef CONFIG_CC_STACKPROTECTOR
41#include <linux/stackprotector.h>
42unsigned long __stack_chk_guard __read_mostly;
43EXPORT_SYMBOL(__stack_chk_guard);
44#endif
45
46static const char *processor_modes[] __maybe_unused = {
47 "USER_26", "FIQ_26" , "IRQ_26" , "SVC_26" , "UK4_26" , "UK5_26" , "UK6_26" , "UK7_26" ,
48 "UK8_26" , "UK9_26" , "UK10_26", "UK11_26", "UK12_26", "UK13_26", "UK14_26", "UK15_26",
49 "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "MON_32" , "ABT_32" ,
50 "UK8_32" , "UK9_32" , "HYP_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32"
51};
52
53static const char *isa_modes[] __maybe_unused = {
54 "ARM" , "Thumb" , "Jazelle", "ThumbEE"
55};
56
63extern void call_with_stack(void (*fn)(void *), void *arg, void *sp);
64typedef void (*phys_reset_t)(unsigned long);
65
66/*
57/*
67 * A temporary stack to use for CPU reset. This is static so that we
68 * don't clobber it with the identity mapping. When running with this
69 * stack, any references to the current task *will not work* so you
70 * should really do as little as possible before jumping to your reset
71 * code.
72 */
73static u64 soft_restart_stack[16];
74
75static void __soft_restart(void *addr)
76{
77 phys_reset_t phys_reset;
78
79 /* Take out a flat memory mapping. */
80 setup_mm_for_reboot();
81
82 /* Clean and invalidate caches */
83 flush_cache_all();
84
85 /* Turn off caching */
86 cpu_proc_fin();
87
88 /* Push out any further dirty data, and ensure cache is empty */
89 flush_cache_all();
90
91 /* Switch to the identity mapping. */
92 phys_reset = (phys_reset_t)(unsigned long)virt_to_phys(cpu_reset);
93 phys_reset((unsigned long)addr);
94
95 /* Should never get here. */
96 BUG();
97}
98
99void _soft_restart(unsigned long addr, bool disable_l2)
100{
101 u64 *stack = soft_restart_stack + ARRAY_SIZE(soft_restart_stack);
102
103 /* Disable interrupts first */
104 raw_local_irq_disable();
105 local_fiq_disable();
106
107 /* Disable the L2 if we're the last man standing. */
108 if (disable_l2)
109 outer_disable();
110
111 /* Change to the new stack and continue with the reset. */
112 call_with_stack(__soft_restart, (void *)addr, (void *)stack);
113
114 /* Should never get here. */
115 BUG();
116}
117
118void soft_restart(unsigned long addr)
119{
120 _soft_restart(addr, num_online_cpus() == 1);
121}
122
123/*
124 * Function pointers to optional machine specific functions
125 */
126void (*pm_power_off)(void);
127EXPORT_SYMBOL(pm_power_off);
128
129void (*arm_pm_restart)(enum reboot_mode reboot_mode, const char *cmd);
130
131/*
132 * This is our default idle handler.
133 */
134
135void (*arm_pm_idle)(void);
136
137/*
138 * Called from the core idle loop.
139 */

--- 27 unchanged lines hidden (view full) ---

167
168#ifdef CONFIG_HOTPLUG_CPU
169void arch_cpu_idle_dead(void)
170{
171 cpu_die();
172}
173#endif
174
58 * This is our default idle handler.
59 */
60
61void (*arm_pm_idle)(void);
62
63/*
64 * Called from the core idle loop.
65 */

--- 27 unchanged lines hidden (view full) ---

93
94#ifdef CONFIG_HOTPLUG_CPU
95void arch_cpu_idle_dead(void)
96{
97 cpu_die();
98}
99#endif
100
175/*
176 * Called by kexec, immediately prior to machine_kexec().
177 *
178 * This must completely disable all secondary CPUs; simply causing those CPUs
179 * to execute e.g. a RAM-based pin loop is not sufficient. This allows the
180 * kexec'd kernel to use any and all RAM as it sees fit, without having to
181 * avoid any code or data used by any SW CPU pin loop. The CPU hotplug
182 * functionality embodied in disable_nonboot_cpus() to achieve this.
183 */
184void machine_shutdown(void)
185{
186 disable_nonboot_cpus();
187}
188
189/*
190 * Halting simply requires that the secondary CPUs stop performing any
191 * activity (executing tasks, handling interrupts). smp_send_stop()
192 * achieves this.
193 */
194void machine_halt(void)
195{
196 local_irq_disable();
197 smp_send_stop();
198
199 local_irq_disable();
200 while (1);
201}
202
203/*
204 * Power-off simply requires that the secondary CPUs stop performing any
205 * activity (executing tasks, handling interrupts). smp_send_stop()
206 * achieves this. When the system power is turned off, it will take all CPUs
207 * with it.
208 */
209void machine_power_off(void)
210{
211 local_irq_disable();
212 smp_send_stop();
213
214 if (pm_power_off)
215 pm_power_off();
216}
217
218/*
219 * Restart requires that the secondary CPUs stop performing any activity
220 * while the primary CPU resets the system. Systems with a single CPU can
221 * use soft_restart() as their machine descriptor's .restart hook, since that
222 * will cause the only available CPU to reset. Systems with multiple CPUs must
223 * provide a HW restart implementation, to ensure that all CPUs reset at once.
224 * This is required so that any code running after reset on the primary CPU
225 * doesn't have to co-ordinate with other CPUs to ensure they aren't still
226 * executing pre-reset code, and using RAM that the primary CPU's code wishes
227 * to use. Implementing such co-ordination would be essentially impossible.
228 */
229void machine_restart(char *cmd)
230{
231 local_irq_disable();
232 smp_send_stop();
233
234 if (arm_pm_restart)
235 arm_pm_restart(reboot_mode, cmd);
236 else
237 do_kernel_restart(cmd);
238
239 /* Give a grace period for failure to restart of 1s */
240 mdelay(1000);
241
242 /* Whoops - the platform was unable to reboot. Tell the user! */
243 printk("Reboot failed -- System halted\n");
244 local_irq_disable();
245 while (1);
246}
247
248void __show_regs(struct pt_regs *regs)
249{
250 unsigned long flags;
251 char buf[64];
252
253 show_regs_print_info(KERN_DEFAULT);
254
255 print_symbol("PC is at %s\n", instruction_pointer(regs));

--- 305 unchanged lines hidden --- 		101void __show_regs(struct pt_regs *regs)
102{
103 unsigned long flags;
104 char buf[64];
105
106 show_regs_print_info(KERN_DEFAULT);
107
108 print_symbol("PC is at %s\n", instruction_pointer(regs));

--- 305 unchanged lines hidden ---