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 * These bracket the sleeping functions..
167 unsigned long get_wchan(struct task_struct
*p
)
169 unsigned long sp
, pc
;
170 unsigned long stack_page
= (unsigned long) task_stack_page(p
);
173 if (!p
|| p
== current
|| p
->state
== TASK_RUNNING
)
177 pc
= MAKE_PC_FROM_RA(p
->thread
.ra
, p
->thread
.sp
);
180 if (sp
< stack_page
+ sizeof(struct task_struct
) ||
181 sp
>= (stack_page
+ THREAD_SIZE
) ||
184 if (!in_sched_functions(pc
))
187 /* Stack layout: sp-4: ra, sp-3: sp' */
189 pc
= MAKE_PC_FROM_RA(*(unsigned long*)sp
- 4, sp
);
190 sp
= *(unsigned long *)sp
- 3;
191 } while (count
++ < 16);
196 * do_copy_regs() gathers information from 'struct pt_regs' and
197 * 'current->thread.areg[]' to fill in the xtensa_gregset_t
200 * xtensa_gregset_t and 'struct pt_regs' are vastly different formats
201 * of processor registers. Besides different ordering,
202 * xtensa_gregset_t contains non-live register information that
203 * 'struct pt_regs' does not. Exception handling (primarily) uses
204 * 'struct pt_regs'. Core files and ptrace use xtensa_gregset_t.
208 void do_copy_regs (xtensa_gregset_t
*elfregs
, struct pt_regs
*regs
,
209 struct task_struct
*tsk
)
213 elfregs
->xchal_config_id0
= XCHAL_HW_CONFIGID0
;
214 elfregs
->xchal_config_id1
= XCHAL_HW_CONFIGID1
;
216 __asm__
__volatile__ ("rsr %0, 176\n" : "=a" (i
));
218 __asm__
__volatile__ ("rsr %0, 208\n" : "=a" (i
));
221 /* Note: PS.EXCM is not set while user task is running; its
222 * being set in regs->ps is for exception handling convenience.
225 elfregs
->pc
= regs
->pc
;
226 elfregs
->ps
= (regs
->ps
& ~(1 << PS_EXCM_BIT
));
227 elfregs
->exccause
= regs
->exccause
;
228 elfregs
->excvaddr
= regs
->excvaddr
;
229 elfregs
->windowbase
= regs
->windowbase
;
230 elfregs
->windowstart
= regs
->windowstart
;
231 elfregs
->lbeg
= regs
->lbeg
;
232 elfregs
->lend
= regs
->lend
;
233 elfregs
->lcount
= regs
->lcount
;
234 elfregs
->sar
= regs
->sar
;
235 elfregs
->syscall
= regs
->syscall
;
237 /* Copy register file.
238 * The layout looks like this:
240 * | a0 ... a15 | Z ... Z | arX ... arY |
241 * current window unused saved frames
244 memset (elfregs
->ar
, 0, sizeof(elfregs
->ar
));
246 wb_offset
= regs
->windowbase
* 4;
247 n
= (regs
->wmask
&1)? 4 : (regs
->wmask
&2)? 8 : (regs
->wmask
&4)? 12 : 16;
249 for (i
= 0; i
< n
; i
++)
250 elfregs
->ar
[(wb_offset
+ i
) % XCHAL_NUM_AREGS
] = regs
->areg
[i
];
252 n
= (regs
->wmask
>> 4) * 4;
254 for (i
= XCHAL_NUM_AREGS
- n
; n
> 0; i
++, n
--)
255 elfregs
->ar
[(wb_offset
+ i
) % XCHAL_NUM_AREGS
] = regs
->areg
[i
];
258 void xtensa_elf_core_copy_regs (xtensa_gregset_t
*elfregs
, struct pt_regs
*regs
)
260 do_copy_regs ((xtensa_gregset_t
*)elfregs
, regs
, current
);
264 /* The inverse of do_copy_regs(). No error or sanity checking. */
266 void do_restore_regs (xtensa_gregset_t
*elfregs
, struct pt_regs
*regs
,
267 struct task_struct
*tsk
)
271 /* Note: PS.EXCM is not set while user task is running; it
272 * needs to be set in regs->ps is for exception handling convenience.
275 regs
->pc
= elfregs
->pc
;
276 regs
->ps
= (elfregs
->ps
| (1 << PS_EXCM_BIT
));
277 regs
->exccause
= elfregs
->exccause
;
278 regs
->excvaddr
= elfregs
->excvaddr
;
279 regs
->windowbase
= elfregs
->windowbase
;
280 regs
->windowstart
= elfregs
->windowstart
;
281 regs
->lbeg
= elfregs
->lbeg
;
282 regs
->lend
= elfregs
->lend
;
283 regs
->lcount
= elfregs
->lcount
;
284 regs
->sar
= elfregs
->sar
;
285 regs
->syscall
= elfregs
->syscall
;
287 /* Clear everything. */
289 memset (regs
->areg
, 0, sizeof(regs
->areg
));
291 /* Copy regs from live window frame. */
293 wb_offset
= regs
->windowbase
* 4;
294 n
= (regs
->wmask
&1)? 4 : (regs
->wmask
&2)? 8 : (regs
->wmask
&4)? 12 : 16;
296 for (i
= 0; i
< n
; i
++)
297 regs
->areg
[(wb_offset
+i
) % XCHAL_NUM_AREGS
] = elfregs
->ar
[i
];
299 n
= (regs
->wmask
>> 4) * 4;
301 for (i
= XCHAL_NUM_AREGS
- n
; n
> 0; i
++, n
--)
302 regs
->areg
[(wb_offset
+i
) % XCHAL_NUM_AREGS
] = elfregs
->ar
[i
];
306 * do_save_fpregs() gathers information from 'struct pt_regs' and
307 * 'current->thread' to fill in the elf_fpregset_t structure.
309 * Core files and ptrace use elf_fpregset_t.
312 void do_save_fpregs (elf_fpregset_t
*fpregs
, struct pt_regs
*regs
,
313 struct task_struct
*tsk
)
317 extern unsigned char _xtensa_reginfo_tables
[];
318 extern unsigned _xtensa_reginfo_table_size
;
322 /* Before dumping coprocessor state from memory,
323 * ensure any live coprocessor contents for this
324 * task are first saved to memory:
326 local_irq_save(flags
);
328 for (i
= 0; i
< XCHAL_CP_MAX
; i
++) {
329 if (tsk
== coprocessor_info
[i
].owner
) {
330 enable_coprocessor(i
);
331 save_coprocessor_registers(
332 tsk
->thread
.cp_save
+coprocessor_info
[i
].offset
,i
);
333 disable_coprocessor(i
);
337 local_irq_restore(flags
);
339 /* Now dump coprocessor & extra state: */
340 memcpy((unsigned char*)fpregs
,
341 _xtensa_reginfo_tables
, _xtensa_reginfo_table_size
);
342 memcpy((unsigned char*)fpregs
+ _xtensa_reginfo_table_size
,
343 tsk
->thread
.cp_save
, XTENSA_CP_EXTRA_SIZE
);
348 * The inverse of do_save_fpregs().
349 * Copies coprocessor and extra state from fpregs into regs and tsk->thread.
350 * Returns 0 on success, non-zero if layout doesn't match.
353 int do_restore_fpregs (elf_fpregset_t
*fpregs
, struct pt_regs
*regs
,
354 struct task_struct
*tsk
)
358 extern unsigned char _xtensa_reginfo_tables
[];
359 extern unsigned _xtensa_reginfo_table_size
;
363 /* Make sure save area layouts match.
364 * FIXME: in the future we could allow restoring from
365 * a different layout of the same registers, by comparing
366 * fpregs' table with _xtensa_reginfo_tables and matching
367 * entries and copying registers one at a time.
368 * Not too sure yet whether that's very useful.
371 if( memcmp((unsigned char*)fpregs
,
372 _xtensa_reginfo_tables
, _xtensa_reginfo_table_size
) ) {
376 /* Before restoring coprocessor state from memory,
377 * ensure any live coprocessor contents for this
378 * task are first invalidated.
381 local_irq_save(flags
);
383 for (i
= 0; i
< XCHAL_CP_MAX
; i
++) {
384 if (tsk
== coprocessor_info
[i
].owner
) {
385 enable_coprocessor(i
);
386 save_coprocessor_registers(
387 tsk
->thread
.cp_save
+coprocessor_info
[i
].offset
,i
);
388 coprocessor_info
[i
].owner
= 0;
389 disable_coprocessor(i
);
393 local_irq_restore(flags
);
395 /* Now restore coprocessor & extra state: */
397 memcpy(tsk
->thread
.cp_save
,
398 (unsigned char*)fpregs
+ _xtensa_reginfo_table_size
,
399 XTENSA_CP_EXTRA_SIZE
);
404 * Fill in the CP structure for a core dump for a particular task.
408 dump_task_fpu(struct pt_regs
*regs
, struct task_struct
*task
, elf_fpregset_t
*r
)
410 return 0; /* no coprocessors active on this processor */
414 * Fill in the CP structure for a core dump.
415 * This includes any FPU coprocessor.
416 * Here, we dump all coprocessors, and other ("extra") custom state.
418 * This function is called by elf_core_dump() in fs/binfmt_elf.c
419 * (in which case 'regs' comes from calls to do_coredump, see signals.c).
421 int dump_fpu(struct pt_regs
*regs
, elf_fpregset_t
*r
)
423 return dump_task_fpu(regs
, current
, r
);
427 long xtensa_clone(unsigned long clone_flags
, unsigned long newsp
,
428 void __user
*parent_tid
, void *child_tls
,
429 void __user
*child_tid
, long a5
,
430 struct pt_regs
*regs
)
433 newsp
= regs
->areg
[1];
434 return do_fork(clone_flags
, newsp
, regs
, 0, parent_tid
, child_tid
);
438 * * xtensa_execve() executes a new program.
442 long xtensa_execve(char __user
*name
, char __user
* __user
*argv
,
443 char __user
* __user
*envp
,
444 long a3
, long a4
, long a5
,
445 struct pt_regs
*regs
)
450 filename
= getname(name
);
451 error
= PTR_ERR(filename
);
452 if (IS_ERR(filename
))
454 // FIXME: release coprocessor??
455 error
= do_execve(filename
, argv
, envp
, regs
);
458 current
->ptrace
&= ~PT_DTRACE
;
459 task_unlock(current
);