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