[PATCH] Don't export machine_restart, machine_halt, or machine_power_off.
[linux-2.6.git] / arch / parisc / kernel / process.c
1 /*
2  *    PARISC Architecture-dependent parts of process handling
3  *    based on the work for i386
4  *
5  *    Copyright (C) 1999-2003 Matthew Wilcox <willy at parisc-linux.org>
6  *    Copyright (C) 2000 Martin K Petersen <mkp at mkp.net>
7  *    Copyright (C) 2000 John Marvin <jsm at parisc-linux.org>
8  *    Copyright (C) 2000 David Huggins-Daines <dhd with pobox.org>
9  *    Copyright (C) 2000-2003 Paul Bame <bame at parisc-linux.org>
10  *    Copyright (C) 2000 Philipp Rumpf <prumpf with tux.org>
11  *    Copyright (C) 2000 David Kennedy <dkennedy with linuxcare.com>
12  *    Copyright (C) 2000 Richard Hirst <rhirst with parisc-lixux.org>
13  *    Copyright (C) 2000 Grant Grundler <grundler with parisc-linux.org>
14  *    Copyright (C) 2001 Alan Modra <amodra at parisc-linux.org>
15  *    Copyright (C) 2001-2002 Ryan Bradetich <rbrad at parisc-linux.org>
16  *    Copyright (C) 2001-2002 Helge Deller <deller at parisc-linux.org>
17  *    Copyright (C) 2002 Randolph Chung <tausq with parisc-linux.org>
18  *
19  *
20  *    This program is free software; you can redistribute it and/or modify
21  *    it under the terms of the GNU General Public License as published by
22  *    the Free Software Foundation; either version 2 of the License, or
23  *    (at your option) any later version.
24  *
25  *    This program is distributed in the hope that it will be useful,
26  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
27  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
28  *    GNU General Public License for more details.
29  *
30  *    You should have received a copy of the GNU General Public License
31  *    along with this program; if not, write to the Free Software
32  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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/module.h>
42 #include <linux/personality.h>
43 #include <linux/ptrace.h>
44 #include <linux/sched.h>
45 #include <linux/stddef.h>
46 #include <linux/unistd.h>
47 #include <linux/kallsyms.h>
48
49 #include <asm/io.h>
50 #include <asm/offsets.h>
51 #include <asm/pdc.h>
52 #include <asm/pdc_chassis.h>
53 #include <asm/pgalloc.h>
54 #include <asm/uaccess.h>
55 #include <asm/unwind.h>
56
57 static int hlt_counter;
58
59 /*
60  * Power off function, if any
61  */ 
62 void (*pm_power_off)(void);
63
64 void disable_hlt(void)
65 {
66         hlt_counter++;
67 }
68
69 EXPORT_SYMBOL(disable_hlt);
70
71 void enable_hlt(void)
72 {
73         hlt_counter--;
74 }
75
76 EXPORT_SYMBOL(enable_hlt);
77
78 void default_idle(void)
79 {
80         barrier();
81 }
82
83 /*
84  * The idle thread. There's no useful work to be
85  * done, so just try to conserve power and have a
86  * low exit latency (ie sit in a loop waiting for
87  * somebody to say that they'd like to reschedule)
88  */
89 void cpu_idle(void)
90 {
91         /* endless idle loop with no priority at all */
92         while (1) {
93                 while (!need_resched())
94                         barrier();
95                 schedule();
96                 check_pgt_cache();
97         }
98 }
99
100
101 #ifdef __LP64__
102 #define COMMAND_GLOBAL  0xfffffffffffe0030UL
103 #else
104 #define COMMAND_GLOBAL  0xfffe0030
105 #endif
106
107 #define CMD_RESET       5       /* reset any module */
108
109 /*
110 ** The Wright Brothers and Gecko systems have a H/W problem
111 ** (Lasi...'nuf said) may cause a broadcast reset to lockup
112 ** the system. An HVERSION dependent PDC call was developed
113 ** to perform a "safe", platform specific broadcast reset instead
114 ** of kludging up all the code.
115 **
116 ** Older machines which do not implement PDC_BROADCAST_RESET will
117 ** return (with an error) and the regular broadcast reset can be
118 ** issued. Obviously, if the PDC does implement PDC_BROADCAST_RESET
119 ** the PDC call will not return (the system will be reset).
120 */
121 void machine_restart(char *cmd)
122 {
123 #ifdef FASTBOOT_SELFTEST_SUPPORT
124         /*
125          ** If user has modified the Firmware Selftest Bitmap,
126          ** run the tests specified in the bitmap after the
127          ** system is rebooted w/PDC_DO_RESET.
128          **
129          ** ftc_bitmap = 0x1AUL "Skip destructive memory tests"
130          **
131          ** Using "directed resets" at each processor with the MEM_TOC
132          ** vector cleared will also avoid running destructive
133          ** memory self tests. (Not implemented yet)
134          */
135         if (ftc_bitmap) {
136                 pdc_do_firm_test_reset(ftc_bitmap);
137         }
138 #endif
139         /* set up a new led state on systems shipped with a LED State panel */
140         pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
141         
142         /* "Normal" system reset */
143         pdc_do_reset();
144
145         /* Nope...box should reset with just CMD_RESET now */
146         gsc_writel(CMD_RESET, COMMAND_GLOBAL);
147
148         /* Wait for RESET to lay us to rest. */
149         while (1) ;
150
151 }
152
153 void machine_halt(void)
154 {
155         /*
156         ** The LED/ChassisCodes are updated by the led_halt()
157         ** function, called by the reboot notifier chain.
158         */
159 }
160
161
162 /*
163  * This routine is called from sys_reboot to actually turn off the
164  * machine 
165  */
166 void machine_power_off(void)
167 {
168         /* If there is a registered power off handler, call it. */
169         if(pm_power_off)
170                 pm_power_off();
171
172         /* Put the soft power button back under hardware control.
173          * If the user had already pressed the power button, the
174          * following call will immediately power off. */
175         pdc_soft_power_button(0);
176         
177         pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
178                 
179         /* It seems we have no way to power the system off via
180          * software. The user has to press the button himself. */
181
182         printk(KERN_EMERG "System shut down completed.\n"
183                KERN_EMERG "Please power this system off now.");
184 }
185
186
187 /*
188  * Create a kernel thread
189  */
190
191 extern pid_t __kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
192 pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
193 {
194
195         /*
196          * FIXME: Once we are sure we don't need any debug here,
197          *        kernel_thread can become a #define.
198          */
199
200         return __kernel_thread(fn, arg, flags);
201 }
202 EXPORT_SYMBOL(kernel_thread);
203
204 /*
205  * Free current thread data structures etc..
206  */
207 void exit_thread(void)
208 {
209 }
210
211 void flush_thread(void)
212 {
213         /* Only needs to handle fpu stuff or perf monitors.
214         ** REVISIT: several arches implement a "lazy fpu state".
215         */
216         set_fs(USER_DS);
217 }
218
219 void release_thread(struct task_struct *dead_task)
220 {
221 }
222
223 /*
224  * Fill in the FPU structure for a core dump.
225  */
226
227 int dump_fpu (struct pt_regs * regs, elf_fpregset_t *r)
228 {
229         if (regs == NULL)
230                 return 0;
231
232         memcpy(r, regs->fr, sizeof *r);
233         return 1;
234 }
235
236 int dump_task_fpu (struct task_struct *tsk, elf_fpregset_t *r)
237 {
238         memcpy(r, tsk->thread.regs.fr, sizeof(*r));
239         return 1;
240 }
241
242 /* Note that "fork()" is implemented in terms of clone, with
243    parameters (SIGCHLD, regs->gr[30], regs). */
244 int
245 sys_clone(unsigned long clone_flags, unsigned long usp,
246           struct pt_regs *regs)
247 {
248         int __user *user_tid = (int __user *)regs->gr[26];
249
250         /* usp must be word aligned.  This also prevents users from
251          * passing in the value 1 (which is the signal for a special
252          * return for a kernel thread) */
253         usp = ALIGN(usp, 4);
254
255         /* A zero value for usp means use the current stack */
256         if(usp == 0)
257                 usp = regs->gr[30];
258
259         return do_fork(clone_flags, usp, regs, 0, user_tid, NULL);
260 }
261
262 int
263 sys_vfork(struct pt_regs *regs)
264 {
265         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gr[30], regs, 0, NULL, NULL);
266 }
267
268 int
269 copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
270             unsigned long unused,       /* in ia64 this is "user_stack_size" */
271             struct task_struct * p, struct pt_regs * pregs)
272 {
273         struct pt_regs * cregs = &(p->thread.regs);
274         struct thread_info *ti = p->thread_info;
275         
276         /* We have to use void * instead of a function pointer, because
277          * function pointers aren't a pointer to the function on 64-bit.
278          * Make them const so the compiler knows they live in .text */
279         extern void * const ret_from_kernel_thread;
280         extern void * const child_return;
281 #ifdef CONFIG_HPUX
282         extern void * const hpux_child_return;
283 #endif
284
285         *cregs = *pregs;
286
287         /* Set the return value for the child.  Note that this is not
288            actually restored by the syscall exit path, but we put it
289            here for consistency in case of signals. */
290         cregs->gr[28] = 0; /* child */
291
292         /*
293          * We need to differentiate between a user fork and a
294          * kernel fork. We can't use user_mode, because the
295          * the syscall path doesn't save iaoq. Right now
296          * We rely on the fact that kernel_thread passes
297          * in zero for usp.
298          */
299         if (usp == 1) {
300                 /* kernel thread */
301                 cregs->ksp = (((unsigned long)(ti)) + THREAD_SZ_ALGN);
302                 /* Must exit via ret_from_kernel_thread in order
303                  * to call schedule_tail()
304                  */
305                 cregs->kpc = (unsigned long) &ret_from_kernel_thread;
306                 /*
307                  * Copy function and argument to be called from
308                  * ret_from_kernel_thread.
309                  */
310 #ifdef __LP64__
311                 cregs->gr[27] = pregs->gr[27];
312 #endif
313                 cregs->gr[26] = pregs->gr[26];
314                 cregs->gr[25] = pregs->gr[25];
315         } else {
316                 /* user thread */
317                 /*
318                  * Note that the fork wrappers are responsible
319                  * for setting gr[21].
320                  */
321
322                 /* Use same stack depth as parent */
323                 cregs->ksp = ((unsigned long)(ti))
324                         + (pregs->gr[21] & (THREAD_SIZE - 1));
325                 cregs->gr[30] = usp;
326                 if (p->personality == PER_HPUX) {
327 #ifdef CONFIG_HPUX
328                         cregs->kpc = (unsigned long) &hpux_child_return;
329 #else
330                         BUG();
331 #endif
332                 } else {
333                         cregs->kpc = (unsigned long) &child_return;
334                 }
335         }
336
337         return 0;
338 }
339
340 unsigned long thread_saved_pc(struct task_struct *t)
341 {
342         return t->thread.regs.kpc;
343 }
344
345 /*
346  * sys_execve() executes a new program.
347  */
348
349 asmlinkage int sys_execve(struct pt_regs *regs)
350 {
351         int error;
352         char *filename;
353
354         filename = getname((const char __user *) regs->gr[26]);
355         error = PTR_ERR(filename);
356         if (IS_ERR(filename))
357                 goto out;
358         error = do_execve(filename, (char __user **) regs->gr[25],
359                 (char __user **) regs->gr[24], regs);
360         if (error == 0) {
361                 task_lock(current);
362                 current->ptrace &= ~PT_DTRACE;
363                 task_unlock(current);
364         }
365         putname(filename);
366 out:
367
368         return error;
369 }
370
371 unsigned long 
372 get_wchan(struct task_struct *p)
373 {
374         struct unwind_frame_info info;
375         unsigned long ip;
376         int count = 0;
377         /*
378          * These bracket the sleeping functions..
379          */
380
381         unwind_frame_init_from_blocked_task(&info, p);
382         do {
383                 if (unwind_once(&info) < 0)
384                         return 0;
385                 ip = info.ip;
386                 if (!in_sched_functions(ip))
387                         return ip;
388         } while (count++ < 16);
389         return 0;
390 }