2 * arch/xtensa/kernel/process.c
4 * Xtensa Processor version.
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
10 * Copyright (C) 2001 - 2005 Tensilica Inc.
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>
18 #include <linux/errno.h>
19 #include <linux/sched.h>
20 #include <linux/kernel.h>
22 #include <linux/smp.h>
23 #include <linux/smp_lock.h>
24 #include <linux/stddef.h>
25 #include <linux/unistd.h>
26 #include <linux/ptrace.h>
27 #include <linux/slab.h>
28 #include <linux/elf.h>
29 #include <linux/init.h>
30 #include <linux/prctl.h>
31 #include <linux/init_task.h>
32 #include <linux/module.h>
33 #include <linux/mqueue.h>
35 #include <asm/pgtable.h>
36 #include <asm/uaccess.h>
37 #include <asm/system.h>
39 #include <asm/processor.h>
40 #include <asm/platform.h>
43 #include <asm/atomic.h>
44 #include <asm/asm-offsets.h>
47 extern void ret_from_fork(void);
49 static struct fs_struct init_fs = INIT_FS;
50 static struct files_struct init_files = INIT_FILES;
51 static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
52 static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
53 struct mm_struct init_mm = INIT_MM(init_mm);
54 EXPORT_SYMBOL(init_mm);
56 union thread_union init_thread_union
57 __attribute__((__section__(".data.init_task"))) =
58 { INIT_THREAD_INFO(init_task) };
60 struct task_struct init_task = INIT_TASK(init_task);
61 EXPORT_SYMBOL(init_task);
63 struct task_struct *current_set[NR_CPUS] = {&init_task, };
65 void (*pm_power_off)(void) = NULL;
66 EXPORT_SYMBOL(pm_power_off);
70 * Powermanagement idle function, if any is provided by the platform.
77 /* endless idle loop with no priority at all */
79 while (!need_resched())
81 preempt_enable_no_resched();
88 * Free current thread data structures etc..
91 void exit_thread(void)
95 void flush_thread(void)
102 * The stack layout for the new thread looks like this:
104 * +------------------------+ <- sp in childregs (= tos)
106 * +------------------------+ <- thread.sp = sp in dummy-frame
107 * | dummy-frame | (saved in dummy-frame spill-area)
108 * +------------------------+
110 * We create a dummy frame to return to ret_from_fork:
111 * a0 points to ret_from_fork (simulating a call4)
112 * sp points to itself (thread.sp)
115 * Note: This is a pristine frame, so we don't need any spill region on top of
119 int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
120 unsigned long unused,
121 struct task_struct * p, struct pt_regs * regs)
123 struct pt_regs *childregs;
125 int user_mode = user_mode(regs);
127 /* Set up new TSS. */
128 tos = (unsigned long)task_stack_page(p) + THREAD_SIZE;
130 childregs = (struct pt_regs*)(tos - PT_USER_SIZE);
132 childregs = (struct pt_regs*)tos - 1;
136 /* Create a call4 dummy-frame: a0 = 0, a1 = childregs. */
137 *((int*)childregs - 3) = (unsigned long)childregs;
138 *((int*)childregs - 4) = 0;
140 childregs->areg[1] = tos;
141 childregs->areg[2] = 0;
142 p->set_child_tid = p->clear_child_tid = NULL;
143 p->thread.ra = MAKE_RA_FOR_CALL((unsigned long)ret_from_fork, 0x1);
144 p->thread.sp = (unsigned long)childregs;
145 if (user_mode(regs)) {
147 int len = childregs->wmask & ~0xf;
148 childregs->areg[1] = usp;
149 memcpy(&childregs->areg[XCHAL_NUM_AREGS - len/4],
150 ®s->areg[XCHAL_NUM_AREGS - len/4], len);
152 if (clone_flags & CLONE_SETTLS)
153 childregs->areg[2] = childregs->areg[6];
156 /* In kernel space, we start a new thread with a new stack. */
157 childregs->wmask = 1;
164 * Create a kernel thread
167 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
171 ("mov a5, %4\n\t" /* preserve fn in a5 */
172 "mov a6, %3\n\t" /* preserve and setup arg in a6 */
173 "movi a2, %1\n\t" /* load __NR_clone for syscall*/
174 "mov a3, sp\n\t" /* sp check and sys_clone */
175 "mov a4, %5\n\t" /* load flags for syscall */
177 "beq a3, sp, 1f\n\t" /* branch if parent */
178 "callx4 a5\n\t" /* call fn */
179 "movi a2, %2\n\t" /* load __NR_exit for syscall */
180 "mov a3, a6\n\t" /* load fn return value */
183 "mov %0, a2\n\t" /* parent returns zero */
185 :"i" (__NR_clone), "i" (__NR_exit),
187 "r" (flags | CLONE_VM)
188 : "a2", "a3", "a4", "a5", "a6" );
194 * These bracket the sleeping functions..
197 unsigned long get_wchan(struct task_struct *p)
199 unsigned long sp, pc;
200 unsigned long stack_page = (unsigned long) task_stack_page(p);
203 if (!p || p == current || p->state == TASK_RUNNING)
207 pc = MAKE_PC_FROM_RA(p->thread.ra, p->thread.sp);
210 if (sp < stack_page + sizeof(struct task_struct) ||
211 sp >= (stack_page + THREAD_SIZE) ||
214 if (!in_sched_functions(pc))
217 /* Stack layout: sp-4: ra, sp-3: sp' */
219 pc = MAKE_PC_FROM_RA(*(unsigned long*)sp - 4, sp);
220 sp = *(unsigned long *)sp - 3;
221 } while (count++ < 16);
226 * do_copy_regs() gathers information from 'struct pt_regs' and
227 * 'current->thread.areg[]' to fill in the xtensa_gregset_t
230 * xtensa_gregset_t and 'struct pt_regs' are vastly different formats
231 * of processor registers. Besides different ordering,
232 * xtensa_gregset_t contains non-live register information that
233 * 'struct pt_regs' does not. Exception handling (primarily) uses
234 * 'struct pt_regs'. Core files and ptrace use xtensa_gregset_t.
238 void do_copy_regs (xtensa_gregset_t *elfregs, struct pt_regs *regs,
239 struct task_struct *tsk)
243 elfregs->xchal_config_id0 = XCHAL_HW_CONFIGID0;
244 elfregs->xchal_config_id1 = XCHAL_HW_CONFIGID1;
246 __asm__ __volatile__ ("rsr %0, 176\n" : "=a" (i));
248 __asm__ __volatile__ ("rsr %0, 208\n" : "=a" (i));
251 /* Note: PS.EXCM is not set while user task is running; its
252 * being set in regs->ps is for exception handling convenience.
255 elfregs->pc = regs->pc;
256 elfregs->ps = (regs->ps & ~(1 << PS_EXCM_BIT));
257 elfregs->exccause = regs->exccause;
258 elfregs->excvaddr = regs->excvaddr;
259 elfregs->windowbase = regs->windowbase;
260 elfregs->windowstart = regs->windowstart;
261 elfregs->lbeg = regs->lbeg;
262 elfregs->lend = regs->lend;
263 elfregs->lcount = regs->lcount;
264 elfregs->sar = regs->sar;
265 elfregs->syscall = regs->syscall;
267 /* Copy register file.
268 * The layout looks like this:
270 * | a0 ... a15 | Z ... Z | arX ... arY |
271 * current window unused saved frames
274 memset (elfregs->ar, 0, sizeof(elfregs->ar));
276 wb_offset = regs->windowbase * 4;
277 n = (regs->wmask&1)? 4 : (regs->wmask&2)? 8 : (regs->wmask&4)? 12 : 16;
279 for (i = 0; i < n; i++)
280 elfregs->ar[(wb_offset + i) % XCHAL_NUM_AREGS] = regs->areg[i];
282 n = (regs->wmask >> 4) * 4;
284 for (i = XCHAL_NUM_AREGS - n; n > 0; i++, n--)
285 elfregs->ar[(wb_offset + i) % XCHAL_NUM_AREGS] = regs->areg[i];
288 void xtensa_elf_core_copy_regs (xtensa_gregset_t *elfregs, struct pt_regs *regs)
290 do_copy_regs ((xtensa_gregset_t *)elfregs, regs, current);
294 /* The inverse of do_copy_regs(). No error or sanity checking. */
296 void do_restore_regs (xtensa_gregset_t *elfregs, struct pt_regs *regs,
297 struct task_struct *tsk)
301 /* Note: PS.EXCM is not set while user task is running; it
302 * needs to be set in regs->ps is for exception handling convenience.
305 regs->pc = elfregs->pc;
306 regs->ps = (elfregs->ps | (1 << PS_EXCM_BIT));
307 regs->exccause = elfregs->exccause;
308 regs->excvaddr = elfregs->excvaddr;
309 regs->windowbase = elfregs->windowbase;
310 regs->windowstart = elfregs->windowstart;
311 regs->lbeg = elfregs->lbeg;
312 regs->lend = elfregs->lend;
313 regs->lcount = elfregs->lcount;
314 regs->sar = elfregs->sar;
315 regs->syscall = elfregs->syscall;
317 /* Clear everything. */
319 memset (regs->areg, 0, sizeof(regs->areg));
321 /* Copy regs from live window frame. */
323 wb_offset = regs->windowbase * 4;
324 n = (regs->wmask&1)? 4 : (regs->wmask&2)? 8 : (regs->wmask&4)? 12 : 16;
326 for (i = 0; i < n; i++)
327 regs->areg[(wb_offset+i) % XCHAL_NUM_AREGS] = elfregs->ar[i];
329 n = (regs->wmask >> 4) * 4;
331 for (i = XCHAL_NUM_AREGS - n; n > 0; i++, n--)
332 regs->areg[(wb_offset+i) % XCHAL_NUM_AREGS] = elfregs->ar[i];
336 * do_save_fpregs() gathers information from 'struct pt_regs' and
337 * 'current->thread' to fill in the elf_fpregset_t structure.
339 * Core files and ptrace use elf_fpregset_t.
342 void do_save_fpregs (elf_fpregset_t *fpregs, struct pt_regs *regs,
343 struct task_struct *tsk)
347 extern unsigned char _xtensa_reginfo_tables[];
348 extern unsigned _xtensa_reginfo_table_size;
352 /* Before dumping coprocessor state from memory,
353 * ensure any live coprocessor contents for this
354 * task are first saved to memory:
356 local_irq_save(flags);
358 for (i = 0; i < XCHAL_CP_MAX; i++) {
359 if (tsk == coprocessor_info[i].owner) {
360 enable_coprocessor(i);
361 save_coprocessor_registers(
362 tsk->thread.cp_save+coprocessor_info[i].offset,i);
363 disable_coprocessor(i);
367 local_irq_restore(flags);
369 /* Now dump coprocessor & extra state: */
370 memcpy((unsigned char*)fpregs,
371 _xtensa_reginfo_tables, _xtensa_reginfo_table_size);
372 memcpy((unsigned char*)fpregs + _xtensa_reginfo_table_size,
373 tsk->thread.cp_save, XTENSA_CP_EXTRA_SIZE);
378 * The inverse of do_save_fpregs().
379 * Copies coprocessor and extra state from fpregs into regs and tsk->thread.
380 * Returns 0 on success, non-zero if layout doesn't match.
383 int do_restore_fpregs (elf_fpregset_t *fpregs, struct pt_regs *regs,
384 struct task_struct *tsk)
388 extern unsigned char _xtensa_reginfo_tables[];
389 extern unsigned _xtensa_reginfo_table_size;
393 /* Make sure save area layouts match.
394 * FIXME: in the future we could allow restoring from
395 * a different layout of the same registers, by comparing
396 * fpregs' table with _xtensa_reginfo_tables and matching
397 * entries and copying registers one at a time.
398 * Not too sure yet whether that's very useful.
401 if( memcmp((unsigned char*)fpregs,
402 _xtensa_reginfo_tables, _xtensa_reginfo_table_size) ) {
406 /* Before restoring coprocessor state from memory,
407 * ensure any live coprocessor contents for this
408 * task are first invalidated.
411 local_irq_save(flags);
413 for (i = 0; i < XCHAL_CP_MAX; i++) {
414 if (tsk == coprocessor_info[i].owner) {
415 enable_coprocessor(i);
416 save_coprocessor_registers(
417 tsk->thread.cp_save+coprocessor_info[i].offset,i);
418 coprocessor_info[i].owner = 0;
419 disable_coprocessor(i);
423 local_irq_restore(flags);
425 /* Now restore coprocessor & extra state: */
427 memcpy(tsk->thread.cp_save,
428 (unsigned char*)fpregs + _xtensa_reginfo_table_size,
429 XTENSA_CP_EXTRA_SIZE);
434 * Fill in the CP structure for a core dump for a particular task.
438 dump_task_fpu(struct pt_regs *regs, struct task_struct *task, elf_fpregset_t *r)
440 return 0; /* no coprocessors active on this processor */
444 * Fill in the CP structure for a core dump.
445 * This includes any FPU coprocessor.
446 * Here, we dump all coprocessors, and other ("extra") custom state.
448 * This function is called by elf_core_dump() in fs/binfmt_elf.c
449 * (in which case 'regs' comes from calls to do_coredump, see signals.c).
451 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *r)
453 return dump_task_fpu(regs, current, r);