[PATCH] sh: kexec() support
[linux-2.6.git] / arch / sh / kernel / process.c
1 /* $Id: process.c,v 1.28 2004/05/05 16:54:23 lethal Exp $
2  *
3  *  linux/arch/sh/kernel/process.c
4  *
5  *  Copyright (C) 1995  Linus Torvalds
6  *
7  *  SuperH version:  Copyright (C) 1999, 2000  Niibe Yutaka & Kaz Kojima
8  */
9
10 /*
11  * This file handles the architecture-dependent parts of process handling..
12  */
13
14 #include <linux/module.h>
15 #include <linux/unistd.h>
16 #include <linux/mm.h>
17 #include <linux/elfcore.h>
18 #include <linux/slab.h>
19 #include <linux/a.out.h>
20 #include <linux/ptrace.h>
21 #include <linux/platform.h>
22 #include <linux/kallsyms.h>
23
24 #include <asm/io.h>
25 #include <asm/uaccess.h>
26 #include <asm/mmu_context.h>
27 #include <asm/elf.h>
28 #if defined(CONFIG_SH_HS7751RVOIP)
29 #include <asm/hs7751rvoip/hs7751rvoip.h>
30 #elif defined(CONFIG_SH_RTS7751R2D)
31 #include <asm/rts7751r2d/rts7751r2d.h>
32 #endif
33
34 static int hlt_counter=0;
35
36 int ubc_usercnt = 0;
37
38 #define HARD_IDLE_TIMEOUT (HZ / 3)
39
40 void disable_hlt(void)
41 {
42         hlt_counter++;
43 }
44
45 EXPORT_SYMBOL(disable_hlt);
46
47 void enable_hlt(void)
48 {
49         hlt_counter--;
50 }
51
52 EXPORT_SYMBOL(enable_hlt);
53
54 void cpu_idle(void)
55 {
56         /* endless idle loop with no priority at all */
57         while (1) {
58                 if (hlt_counter) {
59                         while (!need_resched())
60                                 cpu_relax();
61                 } else {
62                         while (!need_resched())
63                                 cpu_sleep();
64                 }
65
66                 preempt_enable_no_resched();
67                 schedule();
68                 preempt_disable();
69         }
70 }
71
72 void machine_restart(char * __unused)
73 {
74
75 #ifdef CONFIG_KEXEC
76         struct kimage *image;
77         image = xchg(&kexec_image, 0);
78         if (image) {
79                 machine_shutdown();
80                 machine_kexec(image);
81         }
82 #endif
83
84         /* SR.BL=1 and invoke address error to let CPU reset (manual reset) */
85         asm volatile("ldc %0, sr\n\t"
86                      "mov.l @%1, %0" : : "r" (0x10000000), "r" (0x80000001));
87 }
88
89 void machine_halt(void)
90 {
91 #if defined(CONFIG_SH_HS7751RVOIP)
92         unsigned short value;
93
94         value = ctrl_inw(PA_OUTPORTR);
95         ctrl_outw((value & 0xffdf), PA_OUTPORTR);
96 #elif defined(CONFIG_SH_RTS7751R2D)
97         ctrl_outw(0x0001, PA_POWOFF);
98 #endif
99         while (1)
100                 cpu_sleep();
101 }
102
103 void machine_power_off(void)
104 {
105 #if defined(CONFIG_SH_HS7751RVOIP)
106         unsigned short value;
107
108         value = ctrl_inw(PA_OUTPORTR);
109         ctrl_outw((value & 0xffdf), PA_OUTPORTR);
110 #elif defined(CONFIG_SH_RTS7751R2D)
111         ctrl_outw(0x0001, PA_POWOFF);
112 #endif
113 }
114
115 void show_regs(struct pt_regs * regs)
116 {
117         printk("\n");
118         printk("Pid : %d, Comm: %20s\n", current->pid, current->comm);
119         print_symbol("PC is at %s\n", regs->pc);
120         printk("PC  : %08lx SP  : %08lx SR  : %08lx ",
121                regs->pc, regs->regs[15], regs->sr);
122 #ifdef CONFIG_MMU
123         printk("TEA : %08x    ", ctrl_inl(MMU_TEA));
124 #else
125         printk("                  ");
126 #endif
127         printk("%s\n", print_tainted());
128
129         printk("R0  : %08lx R1  : %08lx R2  : %08lx R3  : %08lx\n",
130                regs->regs[0],regs->regs[1],
131                regs->regs[2],regs->regs[3]);
132         printk("R4  : %08lx R5  : %08lx R6  : %08lx R7  : %08lx\n",
133                regs->regs[4],regs->regs[5],
134                regs->regs[6],regs->regs[7]);
135         printk("R8  : %08lx R9  : %08lx R10 : %08lx R11 : %08lx\n",
136                regs->regs[8],regs->regs[9],
137                regs->regs[10],regs->regs[11]);
138         printk("R12 : %08lx R13 : %08lx R14 : %08lx\n",
139                regs->regs[12],regs->regs[13],
140                regs->regs[14]);
141         printk("MACH: %08lx MACL: %08lx GBR : %08lx PR  : %08lx\n",
142                regs->mach, regs->macl, regs->gbr, regs->pr);
143
144         /*
145          * If we're in kernel mode, dump the stack too..
146          */
147         if (!user_mode(regs)) {
148                 extern void show_task(unsigned long *sp);
149                 unsigned long sp = regs->regs[15];
150
151                 show_task((unsigned long *)sp);
152         }
153 }
154
155 /*
156  * Create a kernel thread
157  */
158
159 /*
160  * This is the mechanism for creating a new kernel thread.
161  *
162  */
163 extern void kernel_thread_helper(void);
164 __asm__(".align 5\n"
165         "kernel_thread_helper:\n\t"
166         "jsr    @r5\n\t"
167         " nop\n\t"
168         "mov.l  1f, r1\n\t"
169         "jsr    @r1\n\t"
170         " mov   r0, r4\n\t"
171         ".align 2\n\t"
172         "1:.long do_exit");
173
174 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
175 {       /* Don't use this in BL=1(cli).  Or else, CPU resets! */
176         struct pt_regs regs;
177
178         memset(&regs, 0, sizeof(regs));
179         regs.regs[4] = (unsigned long) arg;
180         regs.regs[5] = (unsigned long) fn;
181
182         regs.pc = (unsigned long) kernel_thread_helper;
183         regs.sr = (1 << 30);
184
185         /* Ok, create the new process.. */
186         return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
187 }
188
189 /*
190  * Free current thread data structures etc..
191  */
192 void exit_thread(void)
193 {
194         if (current->thread.ubc_pc) {
195                 current->thread.ubc_pc = 0;
196                 ubc_usercnt -= 1;
197         }
198 }
199
200 void flush_thread(void)
201 {
202 #if defined(CONFIG_SH_FPU)
203         struct task_struct *tsk = current;
204         /* Forget lazy FPU state */
205         clear_fpu(tsk, task_pt_regs(tsk));
206         clear_used_math();
207 #endif
208 }
209
210 void release_thread(struct task_struct *dead_task)
211 {
212         /* do nothing */
213 }
214
215 /* Fill in the fpu structure for a core dump.. */
216 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
217 {
218         int fpvalid = 0;
219
220 #if defined(CONFIG_SH_FPU)
221         struct task_struct *tsk = current;
222
223         fpvalid = !!tsk_used_math(tsk);
224         if (fpvalid) {
225                 unlazy_fpu(tsk, regs);
226                 memcpy(fpu, &tsk->thread.fpu.hard, sizeof(*fpu));
227         }
228 #endif
229
230         return fpvalid;
231 }
232
233 /* 
234  * Capture the user space registers if the task is not running (in user space)
235  */
236 int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
237 {
238         struct pt_regs ptregs;
239         
240         ptregs = *task_pt_regs(tsk);
241         elf_core_copy_regs(regs, &ptregs);
242
243         return 1;
244 }
245
246 int
247 dump_task_fpu (struct task_struct *tsk, elf_fpregset_t *fpu)
248 {
249         int fpvalid = 0;
250
251 #if defined(CONFIG_SH_FPU)
252         fpvalid = !!tsk_used_math(tsk);
253         if (fpvalid) {
254                 unlazy_fpu(tsk, task_pt_regs(tsk));
255                 memcpy(fpu, &tsk->thread.fpu.hard, sizeof(*fpu));
256         }
257 #endif
258
259         return fpvalid;
260 }
261
262 asmlinkage void ret_from_fork(void);
263
264 int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
265                 unsigned long unused,
266                 struct task_struct *p, struct pt_regs *regs)
267 {
268         struct pt_regs *childregs;
269 #if defined(CONFIG_SH_FPU)
270         struct task_struct *tsk = current;
271
272         unlazy_fpu(tsk, regs);
273         p->thread.fpu = tsk->thread.fpu;
274         copy_to_stopped_child_used_math(p);
275 #endif
276
277         childregs = task_pt_regs(p);
278         *childregs = *regs;
279
280         if (user_mode(regs)) {
281                 childregs->regs[15] = usp;
282         } else {
283                 childregs->regs[15] = (unsigned long)task_stack_page(p) + THREAD_SIZE;
284         }
285         if (clone_flags & CLONE_SETTLS) {
286                 childregs->gbr = childregs->regs[0];
287         }
288         childregs->regs[0] = 0; /* Set return value for child */
289
290         p->thread.sp = (unsigned long) childregs;
291         p->thread.pc = (unsigned long) ret_from_fork;
292
293         p->thread.ubc_pc = 0;
294
295         return 0;
296 }
297
298 /* Tracing by user break controller.  */
299 static void
300 ubc_set_tracing(int asid, unsigned long pc)
301 {
302         ctrl_outl(pc, UBC_BARA);
303
304         /* We don't have any ASID settings for the SH-2! */
305         if (cpu_data->type != CPU_SH7604)
306                 ctrl_outb(asid, UBC_BASRA);
307
308         ctrl_outl(0, UBC_BAMRA);
309
310         if (cpu_data->type == CPU_SH7729) {
311                 ctrl_outw(BBR_INST | BBR_READ | BBR_CPU, UBC_BBRA);
312                 ctrl_outl(BRCR_PCBA | BRCR_PCTE, UBC_BRCR);
313         } else {
314                 ctrl_outw(BBR_INST | BBR_READ, UBC_BBRA);
315                 ctrl_outw(BRCR_PCBA, UBC_BRCR);
316         }
317 }
318
319 /*
320  *      switch_to(x,y) should switch tasks from x to y.
321  *
322  */
323 struct task_struct *__switch_to(struct task_struct *prev, struct task_struct *next)
324 {
325 #if defined(CONFIG_SH_FPU)
326         unlazy_fpu(prev, task_pt_regs(prev));
327 #endif
328
329 #ifdef CONFIG_PREEMPT
330         {
331                 unsigned long flags;
332                 struct pt_regs *regs;
333
334                 local_irq_save(flags);
335                 regs = task_pt_regs(prev);
336                 if (user_mode(regs) && regs->regs[15] >= 0xc0000000) {
337                         int offset = (int)regs->regs[15];
338
339                         /* Reset stack pointer: clear critical region mark */
340                         regs->regs[15] = regs->regs[1];
341                         if (regs->pc < regs->regs[0])
342                                 /* Go to rewind point */
343                                 regs->pc = regs->regs[0] + offset;
344                 }
345                 local_irq_restore(flags);
346         }
347 #endif
348
349         /*
350          * Restore the kernel mode register
351          *      k7 (r7_bank1)
352          */
353         asm volatile("ldc       %0, r7_bank"
354                      : /* no output */
355                      : "r" (task_thread_info(next)));
356
357 #ifdef CONFIG_MMU
358         /* If no tasks are using the UBC, we're done */
359         if (ubc_usercnt == 0)
360                 /* If no tasks are using the UBC, we're done */;
361         else if (next->thread.ubc_pc && next->mm) {
362                 ubc_set_tracing(next->mm->context & MMU_CONTEXT_ASID_MASK,
363                                 next->thread.ubc_pc);
364         } else {
365                 ctrl_outw(0, UBC_BBRA);
366                 ctrl_outw(0, UBC_BBRB);
367         }
368 #endif
369
370         return prev;
371 }
372
373 asmlinkage int sys_fork(unsigned long r4, unsigned long r5,
374                         unsigned long r6, unsigned long r7,
375                         struct pt_regs regs)
376 {
377 #ifdef CONFIG_MMU
378         return do_fork(SIGCHLD, regs.regs[15], &regs, 0, NULL, NULL);
379 #else
380         /* fork almost works, enough to trick you into looking elsewhere :-( */
381         return -EINVAL;
382 #endif
383 }
384
385 asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
386                          unsigned long parent_tidptr,
387                          unsigned long child_tidptr,
388                          struct pt_regs regs)
389 {
390         if (!newsp)
391                 newsp = regs.regs[15];
392         return do_fork(clone_flags, newsp, &regs, 0,
393                         (int __user *)parent_tidptr, (int __user *)child_tidptr);
394 }
395
396 /*
397  * This is trivial, and on the face of it looks like it
398  * could equally well be done in user mode.
399  *
400  * Not so, for quite unobvious reasons - register pressure.
401  * In user mode vfork() cannot have a stack frame, and if
402  * done by calling the "clone()" system call directly, you
403  * do not have enough call-clobbered registers to hold all
404  * the information you need.
405  */
406 asmlinkage int sys_vfork(unsigned long r4, unsigned long r5,
407                          unsigned long r6, unsigned long r7,
408                          struct pt_regs regs)
409 {
410         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.regs[15], &regs,
411                        0, NULL, NULL);
412 }
413
414 /*
415  * sys_execve() executes a new program.
416  */
417 asmlinkage int sys_execve(char *ufilename, char **uargv,
418                           char **uenvp, unsigned long r7,
419                           struct pt_regs regs)
420 {
421         int error;
422         char *filename;
423
424         filename = getname((char __user *)ufilename);
425         error = PTR_ERR(filename);
426         if (IS_ERR(filename))
427                 goto out;
428
429         error = do_execve(filename,
430                           (char __user * __user *)uargv,
431                           (char __user * __user *)uenvp,
432                           &regs);
433         if (error == 0) {
434                 task_lock(current);
435                 current->ptrace &= ~PT_DTRACE;
436                 task_unlock(current);
437         }
438         putname(filename);
439 out:
440         return error;
441 }
442
443 unsigned long get_wchan(struct task_struct *p)
444 {
445         unsigned long schedule_frame;
446         unsigned long pc;
447
448         if (!p || p == current || p->state == TASK_RUNNING)
449                 return 0;
450
451         /*
452          * The same comment as on the Alpha applies here, too ...
453          */
454         pc = thread_saved_pc(p);
455         if (in_sched_functions(pc)) {
456                 schedule_frame = ((unsigned long *)(long)p->thread.sp)[1];
457                 return (unsigned long)((unsigned long *)schedule_frame)[1];
458         }
459         return pc;
460 }
461
462 asmlinkage void break_point_trap(unsigned long r4, unsigned long r5,
463                                  unsigned long r6, unsigned long r7,
464                                  struct pt_regs regs)
465 {
466         /* Clear tracing.  */
467         ctrl_outw(0, UBC_BBRA);
468         ctrl_outw(0, UBC_BBRB);
469         current->thread.ubc_pc = 0;
470         ubc_usercnt -= 1;
471
472         force_sig(SIGTRAP, current);
473 }
474
475 asmlinkage void break_point_trap_software(unsigned long r4, unsigned long r5,
476                                           unsigned long r6, unsigned long r7,
477                                           struct pt_regs regs)
478 {
479         regs.pc -= 2;
480         force_sig(SIGTRAP, current);
481 }