1/*
2 * arch/xtensa/kernel/process.c
3 *
4 * Xtensa Processor version.
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License.  See the file "COPYING" in the main directory of this archive
8 * for more details.
9 *
10 * Copyright (C) 2001 - 2005 Tensilica Inc.
11 *
12 * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
13 * Chris Zankel <chris@zankel.net>
14 * Marc Gauthier <marc@tensilica.com, marc@alumni.uwaterloo.ca>
15 * Kevin Chea
16 */
17
18#include <linux/errno.h>
19#include <linux/sched.h>
20#include <linux/kernel.h>
21#include <linux/mm.h>
22#include <linux/smp.h>
23#include <linux/stddef.h>
24#include <linux/unistd.h>
25#include <linux/ptrace.h>
26#include <linux/slab.h>
27#include <linux/elf.h>
28#include <linux/init.h>
29#include <linux/prctl.h>
30#include <linux/init_task.h>
31#include <linux/module.h>
32#include <linux/mqueue.h>
33
34#include <asm/pgtable.h>
35#include <asm/uaccess.h>
36#include <asm/system.h>
37#include <asm/io.h>
38#include <asm/processor.h>
39#include <asm/platform.h>
40#include <asm/mmu.h>
41#include <asm/irq.h>
42#include <asm/atomic.h>
43#include <asm/asm-offsets.h>
44#include <asm/regs.h>
45
46extern void ret_from_fork(void);
47
48static struct fs_struct init_fs = INIT_FS;
49static struct files_struct init_files = INIT_FILES;
50static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
51static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
52struct mm_struct init_mm = INIT_MM(init_mm);
53EXPORT_SYMBOL(init_mm);
54
55union thread_union init_thread_union
56	__attribute__((__section__(".data.init_task"))) =
57{ INIT_THREAD_INFO(init_task) };
58
59struct task_struct init_task = INIT_TASK(init_task);
60EXPORT_SYMBOL(init_task);
61
62struct task_struct *current_set[NR_CPUS] = {&init_task, };
63
64void (*pm_power_off)(void) = NULL;
65EXPORT_SYMBOL(pm_power_off);
66
67
68/*
69 * Powermanagement idle function, if any is provided by the platform.
70 */
71
72void cpu_idle(void)
73{
74  	local_irq_enable();
75
76	/* endless idle loop with no priority at all */
77	while (1) {
78		while (!need_resched())
79			platform_idle();
80		preempt_enable_no_resched();
81		schedule();
82		preempt_disable();
83	}
84}
85
86/*
87 * Free current thread data structures etc..
88 */
89
90void exit_thread(void)
91{
92}
93
94void flush_thread(void)
95{
96}
97
98/*
99 * Copy thread.
100 *
101 * The stack layout for the new thread looks like this:
102 *
103 *	+------------------------+ <- sp in childregs (= tos)
104 *	|       childregs        |
105 *	+------------------------+ <- thread.sp = sp in dummy-frame
106 *	|      dummy-frame       |    (saved in dummy-frame spill-area)
107 *	+------------------------+
108 *
109 * We create a dummy frame to return to ret_from_fork:
110 *   a0 points to ret_from_fork (simulating a call4)
111 *   sp points to itself (thread.sp)
112 *   a2, a3 are unused.
113 *
114 * Note: This is a pristine frame, so we don't need any spill region on top of
115 *       childregs.
116 */
117
118int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
119		unsigned long unused,
120                struct task_struct * p, struct pt_regs * regs)
121{
122	struct pt_regs *childregs;
123	unsigned long tos;
124	int user_mode = user_mode(regs);
125
126	/* Set up new TSS. */
127	tos = (unsigned long)task_stack_page(p) + THREAD_SIZE;
128	if (user_mode)
129		childregs = (struct pt_regs*)(tos - PT_USER_SIZE);
130	else
131		childregs = (struct pt_regs*)tos - 1;
132
133	*childregs = *regs;
134
135	/* Create a call4 dummy-frame: a0 = 0, a1 = childregs. */
136	*((int*)childregs - 3) = (unsigned long)childregs;
137	*((int*)childregs - 4) = 0;
138
139	childregs->areg[1] = tos;
140	childregs->areg[2] = 0;
141	p->set_child_tid = p->clear_child_tid = NULL;
142	p->thread.ra = MAKE_RA_FOR_CALL((unsigned long)ret_from_fork, 0x1);
143	p->thread.sp = (unsigned long)childregs;
144	if (user_mode(regs)) {
145
146		int len = childregs->wmask & ~0xf;
147		childregs->areg[1] = usp;
148		memcpy(&childregs->areg[XCHAL_NUM_AREGS - len/4],
149		       &regs->areg[XCHAL_NUM_AREGS - len/4], len);
150
151		if (clone_flags & CLONE_SETTLS)
152			childregs->areg[2] = childregs->areg[6];
153
154	} else {
155		/* In kernel space, we start a new thread with a new stack. */
156		childregs->wmask = 1;
157	}
158	return 0;
159}
160
161
162/*
163 * These bracket the sleeping functions..
164 */
165
166unsigned long get_wchan(struct task_struct *p)
167{
168	unsigned long sp, pc;
169	unsigned long stack_page = (unsigned long) task_stack_page(p);
170	int count = 0;
171
172	if (!p || p == current || p->state == TASK_RUNNING)
173		return 0;
174
175	sp = p->thread.sp;
176	pc = MAKE_PC_FROM_RA(p->thread.ra, p->thread.sp);
177
178	do {
179		if (sp < stack_page + sizeof(struct task_struct) ||
180		    sp >= (stack_page + THREAD_SIZE) ||
181		    pc == 0)
182			return 0;
183		if (!in_sched_functions(pc))
184			return pc;
185
186		/* Stack layout: sp-4: ra, sp-3: sp' */
187
188		pc = MAKE_PC_FROM_RA(*(unsigned long*)sp - 4, sp);
189		sp = *(unsigned long *)sp - 3;
190	} while (count++ < 16);
191	return 0;
192}
193
194/*
195 * do_copy_regs() gathers information from 'struct pt_regs' and
196 * 'current->thread.areg[]' to fill in the xtensa_gregset_t
197 * structure.
198 *
199 * xtensa_gregset_t and 'struct pt_regs' are vastly different formats
200 * of processor registers.  Besides different ordering,
201 * xtensa_gregset_t contains non-live register information that
202 * 'struct pt_regs' does not.  Exception handling (primarily) uses
203 * 'struct pt_regs'.  Core files and ptrace use xtensa_gregset_t.
204 *
205 */
206
207void do_copy_regs (xtensa_gregset_t *elfregs, struct pt_regs *regs,
208		   struct task_struct *tsk)
209{
210	int i, n, wb_offset;
211
212	elfregs->xchal_config_id0 = XCHAL_HW_CONFIGID0;
213	elfregs->xchal_config_id1 = XCHAL_HW_CONFIGID1;
214
215	__asm__ __volatile__ ("rsr  %0, 176\n" : "=a" (i));
216 	elfregs->cpux = i;
217	__asm__ __volatile__ ("rsr  %0, 208\n" : "=a" (i));
218 	elfregs->cpuy = i;
219
220	/* Note:  PS.EXCM is not set while user task is running; its
221	 * being set in regs->ps is for exception handling convenience.
222	 */
223
224	elfregs->pc		= regs->pc;
225	elfregs->ps		= (regs->ps & ~(1 << PS_EXCM_BIT));
226	elfregs->exccause	= regs->exccause;
227	elfregs->excvaddr	= regs->excvaddr;
228	elfregs->windowbase	= regs->windowbase;
229	elfregs->windowstart	= regs->windowstart;
230	elfregs->lbeg		= regs->lbeg;
231	elfregs->lend		= regs->lend;
232	elfregs->lcount		= regs->lcount;
233	elfregs->sar		= regs->sar;
234	elfregs->syscall	= regs->syscall;
235
236	/* Copy register file.
237	 * The layout looks like this:
238	 *
239	 * |  a0 ... a15  | Z ... Z |  arX ... arY  |
240	 *  current window  unused    saved frames
241	 */
242
243	memset (elfregs->ar, 0, sizeof(elfregs->ar));
244
245	wb_offset = regs->windowbase * 4;
246	n = (regs->wmask&1)? 4 : (regs->wmask&2)? 8 : (regs->wmask&4)? 12 : 16;
247
248	for (i = 0; i < n; i++)
249		elfregs->ar[(wb_offset + i) % XCHAL_NUM_AREGS] = regs->areg[i];
250
251	n = (regs->wmask >> 4) * 4;
252
253	for (i = XCHAL_NUM_AREGS - n; n > 0; i++, n--)
254		elfregs->ar[(wb_offset + i) % XCHAL_NUM_AREGS] = regs->areg[i];
255}
256
257void xtensa_elf_core_copy_regs (xtensa_gregset_t *elfregs, struct pt_regs *regs)
258{
259	do_copy_regs ((xtensa_gregset_t *)elfregs, regs, current);
260}
261
262
263/* The inverse of do_copy_regs().  No error or sanity checking. */
264
265void do_restore_regs (xtensa_gregset_t *elfregs, struct pt_regs *regs,
266		      struct task_struct *tsk)
267{
268	int i, n, wb_offset;
269
270	/* Note:  PS.EXCM is not set while user task is running; it
271	 * needs to be set in regs->ps is for exception handling convenience.
272	 */
273
274	regs->pc		= elfregs->pc;
275	regs->ps		= (elfregs->ps | (1 << PS_EXCM_BIT));
276	regs->exccause		= elfregs->exccause;
277	regs->excvaddr		= elfregs->excvaddr;
278	regs->windowbase	= elfregs->windowbase;
279	regs->windowstart	= elfregs->windowstart;
280	regs->lbeg		= elfregs->lbeg;
281	regs->lend		= elfregs->lend;
282	regs->lcount		= elfregs->lcount;
283	regs->sar		= elfregs->sar;
284	regs->syscall	= elfregs->syscall;
285
286	/* Clear everything. */
287
288	memset (regs->areg, 0, sizeof(regs->areg));
289
290	/* Copy regs from live window frame. */
291
292	wb_offset = regs->windowbase * 4;
293	n = (regs->wmask&1)? 4 : (regs->wmask&2)? 8 : (regs->wmask&4)? 12 : 16;
294
295	for (i = 0; i < n; i++)
296		regs->areg[(wb_offset+i) % XCHAL_NUM_AREGS] = elfregs->ar[i];
297
298	n = (regs->wmask >> 4) * 4;
299
300	for (i = XCHAL_NUM_AREGS - n; n > 0; i++, n--)
301		regs->areg[(wb_offset+i) % XCHAL_NUM_AREGS] = elfregs->ar[i];
302}
303
304/*
305 * do_save_fpregs() gathers information from 'struct pt_regs' and
306 * 'current->thread' to fill in the elf_fpregset_t structure.
307 *
308 * Core files and ptrace use elf_fpregset_t.
309 */
310
311void do_save_fpregs (elf_fpregset_t *fpregs, struct pt_regs *regs,
312		     struct task_struct *tsk)
313{
314#if XCHAL_HAVE_CP
315
316	extern unsigned char	_xtensa_reginfo_tables[];
317	extern unsigned		_xtensa_reginfo_table_size;
318	int i;
319	unsigned long flags;
320
321	/* Before dumping coprocessor state from memory,
322	 * ensure any live coprocessor contents for this
323	 * task are first saved to memory:
324	 */
325	local_irq_save(flags);
326
327	for (i = 0; i < XCHAL_CP_MAX; i++) {
328		if (tsk == coprocessor_info[i].owner) {
329			enable_coprocessor(i);
330			save_coprocessor_registers(
331			    tsk->thread.cp_save+coprocessor_info[i].offset,i);
332			disable_coprocessor(i);
333		}
334	}
335
336	local_irq_restore(flags);
337
338	/* Now dump coprocessor & extra state: */
339	memcpy((unsigned char*)fpregs,
340		_xtensa_reginfo_tables, _xtensa_reginfo_table_size);
341	memcpy((unsigned char*)fpregs + _xtensa_reginfo_table_size,
342		tsk->thread.cp_save, XTENSA_CP_EXTRA_SIZE);
343#endif
344}
345
346/*
347 * The inverse of do_save_fpregs().
348 * Copies coprocessor and extra state from fpregs into regs and tsk->thread.
349 * Returns 0 on success, non-zero if layout doesn't match.
350 */
351
352int  do_restore_fpregs (elf_fpregset_t *fpregs, struct pt_regs *regs,
353		        struct task_struct *tsk)
354{
355#if XCHAL_HAVE_CP
356
357	extern unsigned char	_xtensa_reginfo_tables[];
358	extern unsigned		_xtensa_reginfo_table_size;
359	int i;
360	unsigned long flags;
361
362
363	if( memcmp((unsigned char*)fpregs,
364		_xtensa_reginfo_tables, _xtensa_reginfo_table_size) ) {
365	    return -1;
366	}
367
368	/* Before restoring coprocessor state from memory,
369	 * ensure any live coprocessor contents for this
370	 * task are first invalidated.
371	 */
372
373	local_irq_save(flags);
374
375	for (i = 0; i < XCHAL_CP_MAX; i++) {
376		if (tsk == coprocessor_info[i].owner) {
377			enable_coprocessor(i);
378			save_coprocessor_registers(
379			    tsk->thread.cp_save+coprocessor_info[i].offset,i);
380			coprocessor_info[i].owner = 0;
381			disable_coprocessor(i);
382		}
383	}
384
385	local_irq_restore(flags);
386
387	/*  Now restore coprocessor & extra state:  */
388
389	memcpy(tsk->thread.cp_save,
390		(unsigned char*)fpregs + _xtensa_reginfo_table_size,
391		XTENSA_CP_EXTRA_SIZE);
392#endif
393	return 0;
394}
395/*
396 * Fill in the CP structure for a core dump for a particular task.
397 */
398
399int
400dump_task_fpu(struct pt_regs *regs, struct task_struct *task, elf_fpregset_t *r)
401{
402	return 0;	/* no coprocessors active on this processor */
403}
404
405/*
406 * Fill in the CP structure for a core dump.
407 * This includes any FPU coprocessor.
408 * Here, we dump all coprocessors, and other ("extra") custom state.
409 *
410 * This function is called by elf_core_dump() in fs/binfmt_elf.c
411 * (in which case 'regs' comes from calls to do_coredump, see signals.c).
412 */
413int  dump_fpu(struct pt_regs *regs, elf_fpregset_t *r)
414{
415	return dump_task_fpu(regs, current, r);
416}
417
418asmlinkage
419long xtensa_clone(unsigned long clone_flags, unsigned long newsp,
420                  void __user *parent_tid, void *child_tls,
421                  void __user *child_tid, long a5,
422                  struct pt_regs *regs)
423{
424        if (!newsp)
425                newsp = regs->areg[1];
426        return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
427}
428
429/*
430 *  * xtensa_execve() executes a new program.
431 *   */
432
433asmlinkage
434long xtensa_execve(char __user *name, char __user * __user *argv,
435                   char __user * __user *envp,
436                   long a3, long a4, long a5,
437                   struct pt_regs *regs)
438{
439	long error;
440	char * filename;
441
442	filename = getname(name);
443	error = PTR_ERR(filename);
444	if (IS_ERR(filename))
445		goto out;
446	error = do_execve(filename, argv, envp, regs);
447	if (error == 0) {
448		task_lock(current);
449		current->ptrace &= ~PT_DTRACE;
450		task_unlock(current);
451	}
452	putname(filename);
453out:
454	return error;
455}
456