1/*
2 *  Copyright (C) 2000-2003  Axis Communications AB
3 *
4 *  Authors:   Bjorn Wesen (bjornw@axis.com)
5 *             Mikael Starvik (starvik@axis.com)
6 *             Tobias Anderberg (tobiasa@axis.com), CRISv32 port.
7 *
8 * This file handles the architecture-dependent parts of process handling..
9 */
10
11#include <linux/sched.h>
12#include <linux/err.h>
13#include <linux/fs.h>
14#include <linux/slab.h>
15#include <asm/arch/hwregs/reg_rdwr.h>
16#include <asm/arch/hwregs/reg_map.h>
17#include <asm/arch/hwregs/timer_defs.h>
18#include <asm/arch/hwregs/intr_vect_defs.h>
19
20extern void stop_watchdog(void);
21
22#ifdef CONFIG_ETRAX_GPIO
23extern void etrax_gpio_wake_up_check(void); /* Defined in drivers/gpio.c. */
24#endif
25
26extern int cris_hlt_counter;
27
28/* We use this if we don't have any better idle routine. */
29void default_idle(void)
30{
31	local_irq_disable();
32	if (!need_resched() && !cris_hlt_counter) {
33	        /* Halt until exception. */
34		__asm__ volatile("ei    \n\t"
35                                 "halt      ");
36	}
37	local_irq_enable();
38}
39
40/*
41 * Free current thread data structures etc..
42 */
43
44extern void deconfigure_bp(long pid);
45void exit_thread(void)
46{
47	deconfigure_bp(current->pid);
48}
49
50/*
51 * If the watchdog is enabled, disable interrupts and enter an infinite loop.
52 * The watchdog will reset the CPU after 0.1s. If the watchdog isn't enabled
53 * then enable it and wait.
54 */
55extern void arch_enable_nmi(void);
56
57void
58hard_reset_now(void)
59{
60	/*
61	 * Don't declare this variable elsewhere.  We don't want any other
62	 * code to know about it than the watchdog handler in entry.S and
63	 * this code, implementing hard reset through the watchdog.
64	 */
65#if defined(CONFIG_ETRAX_WATCHDOG)
66	extern int cause_of_death;
67#endif
68
69	printk("*** HARD RESET ***\n");
70	local_irq_disable();
71
72#if defined(CONFIG_ETRAX_WATCHDOG)
73	cause_of_death = 0xbedead;
74#else
75{
76	reg_timer_rw_wd_ctrl wd_ctrl = {0};
77
78	stop_watchdog();
79
80	wd_ctrl.key = 16;	/* Arbitrary key. */
81	wd_ctrl.cnt = 1;	/* Minimum time. */
82	wd_ctrl.cmd = regk_timer_start;
83
84        arch_enable_nmi();
85	REG_WR(timer, regi_timer, rw_wd_ctrl, wd_ctrl);
86}
87#endif
88
89	while (1)
90		; /* Wait for reset. */
91}
92
93/*
94 * Return saved PC of a blocked thread.
95 */
96unsigned long thread_saved_pc(struct task_struct *t)
97{
98	return task_pt_regs(t)->erp;
99}
100
101static void
102kernel_thread_helper(void* dummy, int (*fn)(void *), void * arg)
103{
104	fn(arg);
105	do_exit(-1); /* Should never be called, return bad exit value. */
106}
107
108/* Create a kernel thread. */
109int
110kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
111{
112	struct pt_regs regs;
113
114	memset(&regs, 0, sizeof(regs));
115
116        /* Don't use r10 since that is set to 0 in copy_thread. */
117	regs.r11 = (unsigned long) fn;
118	regs.r12 = (unsigned long) arg;
119	regs.erp = (unsigned long) kernel_thread_helper;
120	regs.ccs = 1 << (I_CCS_BITNR + CCS_SHIFT);
121
122	/* Create the new process. */
123        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
124}
125
126/*
127 * Setup the child's kernel stack with a pt_regs and call switch_stack() on it.
128 * It will be unnested during _resume and _ret_from_sys_call when the new thread
129 * is scheduled.
130 *
131 * Also setup the thread switching structure which is used to keep
132 * thread-specific data during _resumes.
133 */
134
135extern asmlinkage void ret_from_fork(void);
136
137int
138copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
139	unsigned long unused,
140	struct task_struct *p, struct pt_regs *regs)
141{
142	struct pt_regs *childregs;
143	struct switch_stack *swstack;
144
145	/*
146	 * Put the pt_regs structure at the end of the new kernel stack page and
147	 * fix it up. Note: the task_struct doubles as the kernel stack for the
148	 * task.
149	 */
150	childregs = task_pt_regs(p);
151	*childregs = *regs;	/* Struct copy of pt_regs. */
152        p->set_child_tid = p->clear_child_tid = NULL;
153        childregs->r10 = 0;	/* Child returns 0 after a fork/clone. */
154
155	/* Set a new TLS ?
156	 * The TLS is in $mof beacuse it is the 5th argument to sys_clone.
157	 */
158	if (p->mm && (clone_flags & CLONE_SETTLS)) {
159		task_thread_info(p)->tls = regs->mof;
160	}
161
162	/* Put the switch stack right below the pt_regs. */
163	swstack = ((struct switch_stack *) childregs) - 1;
164
165	/* Paramater to ret_from_sys_call. 0 is don't restart the syscall. */
166	swstack->r9 = 0;
167
168	/*
169	 * We want to return into ret_from_sys_call after the _resume.
170	 * ret_from_fork will call ret_from_sys_call.
171	 */
172	swstack->return_ip = (unsigned long) ret_from_fork;
173
174	/* Fix the user-mode and kernel-mode stackpointer. */
175	p->thread.usp = usp;
176	p->thread.ksp = (unsigned long) swstack;
177
178	return 0;
179}
180
181/*
182 * Be aware of the "magic" 7th argument in the four system-calls below.
183 * They need the latest stackframe, which is put as the 7th argument by
184 * entry.S. The previous arguments are dummies or actually used, but need
185 * to be defined to reach the 7th argument.
186 *
187 * N.B.: Another method to get the stackframe is to use current_regs(). But
188 * it returns the latest stack-frame stacked when going from _user mode_ and
189 * some of these (at least sys_clone) are called from kernel-mode sometimes
190 * (for example during kernel_thread, above) and thus cannot use it. Thus,
191 * to be sure not to get any surprises, we use the method for the other calls
192 * as well.
193 */
194asmlinkage int
195sys_fork(long r10, long r11, long r12, long r13, long mof, long srp,
196	struct pt_regs *regs)
197{
198	return do_fork(SIGCHLD, rdusp(), regs, 0, NULL, NULL);
199}
200
201asmlinkage int
202sys_clone(unsigned long newusp, unsigned long flags, int *parent_tid, int *child_tid,
203	unsigned long tls, long srp, struct pt_regs *regs)
204{
205	if (!newusp)
206		newusp = rdusp();
207
208	return do_fork(flags, newusp, regs, 0, parent_tid, child_tid);
209}
210
211/*
212 * vfork is a system call in i386 because of register-pressure - maybe
213 * we can remove it and handle it in libc but we put it here until then.
214 */
215asmlinkage int
216sys_vfork(long r10, long r11, long r12, long r13, long mof, long srp,
217	struct pt_regs *regs)
218{
219	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL, NULL);
220}
221
222/* sys_execve() executes a new program. */
223asmlinkage int
224sys_execve(const char *fname, char **argv, char **envp, long r13, long mof, long srp,
225	struct pt_regs *regs)
226{
227	int error;
228	char *filename;
229
230	filename = getname(fname);
231	error = PTR_ERR(filename);
232
233	if (IS_ERR(filename))
234	        goto out;
235
236	error = do_execve(filename, argv, envp, regs);
237	putname(filename);
238 out:
239	return error;
240}
241
242unsigned long
243get_wchan(struct task_struct *p)
244{
245	/* TODO */
246	return 0;
247}
248#undef last_sched
249#undef first_sched
250
251void show_regs(struct pt_regs * regs)
252{
253	unsigned long usp = rdusp();
254        printk("ERP: %08lx SRP: %08lx  CCS: %08lx USP: %08lx MOF: %08lx\n",
255		regs->erp, regs->srp, regs->ccs, usp, regs->mof);
256
257	printk(" r0: %08lx  r1: %08lx   r2: %08lx  r3: %08lx\n",
258		regs->r0, regs->r1, regs->r2, regs->r3);
259
260	printk(" r4: %08lx  r5: %08lx   r6: %08lx  r7: %08lx\n",
261		regs->r4, regs->r5, regs->r6, regs->r7);
262
263	printk(" r8: %08lx  r9: %08lx  r10: %08lx r11: %08lx\n",
264		regs->r8, regs->r9, regs->r10, regs->r11);
265
266	printk("r12: %08lx r13: %08lx oR10: %08lx\n",
267		regs->r12, regs->r13, regs->orig_r10);
268}
269