]>
Commit | Line | Data |
---|---|---|
10f9f9c8 | 1 | /* |
1da177e4 LT |
2 | * linux/arch/cris/kernel/process.c |
3 | * | |
4 | * Copyright (C) 1995 Linus Torvalds | |
5 | * Copyright (C) 2000-2002 Axis Communications AB | |
6 | * | |
7 | * Authors: Bjorn Wesen (bjornw@axis.com) | |
8 | * Mikael Starvik (starvik@axis.com) | |
9 | * | |
10 | * This file handles the architecture-dependent parts of process handling.. | |
11 | */ | |
12 | ||
1da177e4 | 13 | #include <linux/sched.h> |
5a0e3ad6 | 14 | #include <linux/slab.h> |
1da177e4 LT |
15 | #include <linux/err.h> |
16 | #include <linux/fs.h> | |
556dcee7 | 17 | #include <arch/svinto.h> |
1da177e4 | 18 | #include <linux/init.h> |
b1a154db | 19 | #include <arch/system.h> |
27d892fb | 20 | #include <linux/ptrace.h> |
1da177e4 LT |
21 | |
22 | #ifdef CONFIG_ETRAX_GPIO | |
23 | void etrax_gpio_wake_up_check(void); /* drivers/gpio.c */ | |
24 | #endif | |
25 | ||
26 | /* | |
27 | * We use this if we don't have any better | |
28 | * idle routine.. | |
29 | */ | |
30 | void default_idle(void) | |
31 | { | |
32 | #ifdef CONFIG_ETRAX_GPIO | |
8dc7c5ec | 33 | etrax_gpio_wake_up_check(); |
1da177e4 | 34 | #endif |
8dc7c5ec | 35 | local_irq_enable(); |
1da177e4 LT |
36 | } |
37 | ||
38 | /* | |
39 | * Free current thread data structures etc.. | |
40 | */ | |
41 | ||
42 | void exit_thread(void) | |
43 | { | |
44 | /* Nothing needs to be done. */ | |
45 | } | |
46 | ||
47 | /* if the watchdog is enabled, we can simply disable interrupts and go | |
48 | * into an eternal loop, and the watchdog will reset the CPU after 0.1s | |
49 | * if on the other hand the watchdog wasn't enabled, we just enable it and wait | |
50 | */ | |
51 | ||
52 | void hard_reset_now (void) | |
53 | { | |
54 | /* | |
55 | * Don't declare this variable elsewhere. We don't want any other | |
56 | * code to know about it than the watchdog handler in entry.S and | |
57 | * this code, implementing hard reset through the watchdog. | |
58 | */ | |
59 | #if defined(CONFIG_ETRAX_WATCHDOG) && !defined(CONFIG_SVINTO_SIM) | |
60 | extern int cause_of_death; | |
61 | #endif | |
62 | ||
63 | printk("*** HARD RESET ***\n"); | |
64 | local_irq_disable(); | |
65 | ||
66 | #if defined(CONFIG_ETRAX_WATCHDOG) && !defined(CONFIG_SVINTO_SIM) | |
67 | cause_of_death = 0xbedead; | |
68 | #else | |
49b4ff33 | 69 | /* Since we dont plan to keep on resetting the watchdog, |
1da177e4 LT |
70 | the key can be arbitrary hence three */ |
71 | *R_WATCHDOG = IO_FIELD(R_WATCHDOG, key, 3) | | |
72 | IO_STATE(R_WATCHDOG, enable, start); | |
73 | #endif | |
74 | ||
75 | while(1) /* waiting for RETRIBUTION! */ ; | |
76 | } | |
77 | ||
78 | /* | |
79 | * Return saved PC of a blocked thread. | |
80 | */ | |
81 | unsigned long thread_saved_pc(struct task_struct *t) | |
82 | { | |
95ca0dc6 | 83 | return task_pt_regs(t)->irp; |
1da177e4 LT |
84 | } |
85 | ||
1da177e4 LT |
86 | /* setup the child's kernel stack with a pt_regs and switch_stack on it. |
87 | * it will be un-nested during _resume and _ret_from_sys_call when the | |
88 | * new thread is scheduled. | |
89 | * | |
90 | * also setup the thread switching structure which is used to keep | |
91 | * thread-specific data during _resumes. | |
92 | * | |
93 | */ | |
94 | asmlinkage void ret_from_fork(void); | |
69b58a67 | 95 | asmlinkage void ret_from_kernel_thread(void); |
1da177e4 | 96 | |
6f2c55b8 | 97 | int copy_thread(unsigned long clone_flags, unsigned long usp, |
afa86fc4 | 98 | unsigned long arg, struct task_struct *p) |
1da177e4 | 99 | { |
69b58a67 AV |
100 | struct pt_regs *childregs = task_pt_regs(p); |
101 | struct switch_stack *swstack = ((struct switch_stack *)childregs) - 1; | |
1da177e4 LT |
102 | |
103 | /* put the pt_regs structure at the end of the new kernel stack page and fix it up | |
104 | * remember that the task_struct doubles as the kernel stack for the task | |
105 | */ | |
106 | ||
69b58a67 AV |
107 | if (unlikely(p->flags & PF_KTHREAD)) { |
108 | memset(swstack, 0, | |
109 | sizeof(struct switch_stack) + sizeof(struct pt_regs)); | |
110 | swstack->r1 = usp; | |
111 | swstack->r2 = arg; | |
112 | childregs->dccr = 1 << I_DCCR_BITNR; | |
113 | swstack->return_ip = (unsigned long) ret_from_kernel_thread; | |
114 | p->thread.ksp = (unsigned long) swstack; | |
115 | p->thread.usp = 0; | |
116 | return 0; | |
117 | } | |
27d892fb | 118 | *childregs = *current_pt_regs(); /* struct copy of pt_regs */ |
1da177e4 LT |
119 | |
120 | childregs->r10 = 0; /* child returns 0 after a fork/clone */ | |
1da177e4 | 121 | |
69b58a67 | 122 | /* put the switch stack right below the pt_regs */ |
1da177e4 LT |
123 | |
124 | swstack->r9 = 0; /* parameter to ret_from_sys_call, 0 == dont restart the syscall */ | |
125 | ||
126 | /* we want to return into ret_from_sys_call after the _resume */ | |
127 | ||
128 | swstack->return_ip = (unsigned long) ret_from_fork; /* Will call ret_from_sys_call */ | |
129 | ||
130 | /* fix the user-mode stackpointer */ | |
131 | ||
27d892fb | 132 | p->thread.usp = usp ?: rdusp(); |
1da177e4 LT |
133 | |
134 | /* and the kernel-mode one */ | |
135 | ||
136 | p->thread.ksp = (unsigned long) swstack; | |
137 | ||
138 | #ifdef DEBUG | |
139 | printk("copy_thread: new regs at 0x%p, as shown below:\n", childregs); | |
140 | show_registers(childregs); | |
141 | #endif | |
142 | ||
143 | return 0; | |
144 | } | |
145 | ||
1da177e4 LT |
146 | unsigned long get_wchan(struct task_struct *p) |
147 | { | |
148 | #if 0 | |
149 | /* YURGH. TODO. */ | |
150 | ||
151 | unsigned long ebp, esp, eip; | |
152 | unsigned long stack_page; | |
153 | int count = 0; | |
154 | if (!p || p == current || p->state == TASK_RUNNING) | |
155 | return 0; | |
156 | stack_page = (unsigned long)p; | |
157 | esp = p->thread.esp; | |
158 | if (!stack_page || esp < stack_page || esp > 8188+stack_page) | |
159 | return 0; | |
160 | /* include/asm-i386/system.h:switch_to() pushes ebp last. */ | |
161 | ebp = *(unsigned long *) esp; | |
162 | do { | |
163 | if (ebp < stack_page || ebp > 8184+stack_page) | |
164 | return 0; | |
165 | eip = *(unsigned long *) (ebp+4); | |
166 | if (!in_sched_functions(eip)) | |
167 | return eip; | |
168 | ebp = *(unsigned long *) ebp; | |
169 | } while (count++ < 16); | |
170 | #endif | |
171 | return 0; | |
172 | } | |
173 | #undef last_sched | |
174 | #undef first_sched | |
175 | ||
176 | void show_regs(struct pt_regs * regs) | |
177 | { | |
178 | unsigned long usp = rdusp(); | |
a43cb95d TH |
179 | |
180 | show_regs_print_info(KERN_DEFAULT); | |
181 | ||
1da177e4 LT |
182 | printk("IRP: %08lx SRP: %08lx DCCR: %08lx USP: %08lx MOF: %08lx\n", |
183 | regs->irp, regs->srp, regs->dccr, usp, regs->mof ); | |
184 | printk(" r0: %08lx r1: %08lx r2: %08lx r3: %08lx\n", | |
185 | regs->r0, regs->r1, regs->r2, regs->r3); | |
186 | printk(" r4: %08lx r5: %08lx r6: %08lx r7: %08lx\n", | |
187 | regs->r4, regs->r5, regs->r6, regs->r7); | |
188 | printk(" r8: %08lx r9: %08lx r10: %08lx r11: %08lx\n", | |
189 | regs->r8, regs->r9, regs->r10, regs->r11); | |
190 | printk("r12: %08lx r13: %08lx oR10: %08lx\n", | |
191 | regs->r12, regs->r13, regs->orig_r10); | |
192 | } | |
193 |