366e5097a41a4f535d1d24ddccab44f13580fb64
[linux-2.6.git] / arch / arm / kernel / entry-common.S
1 /*
2  *  linux/arch/arm/kernel/entry-common.S
3  *
4  *  Copyright (C) 2000 Russell King
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10
11 #include <asm/unistd.h>
12 #include <asm/ftrace.h>
13 #include <mach/entry-macro.S>
14 #include <asm/unwind.h>
15
16 #include "entry-header.S"
17
18
19         .align  5
20 /*
21  * This is the fast syscall return path.  We do as little as
22  * possible here, and this includes saving r0 back into the SVC
23  * stack.
24  */
25 ret_fast_syscall:
26  UNWIND(.fnstart        )
27  UNWIND(.cantunwind     )
28         disable_irq                             @ disable interrupts
29         ldr     r1, [tsk, #TI_FLAGS]
30         tst     r1, #_TIF_WORK_MASK
31         bne     fast_work_pending
32
33         /* perform architecture specific actions before user return */
34         arch_ret_to_user r1, lr
35
36         @ fast_restore_user_regs
37         ldr     r1, [sp, #S_OFF + S_PSR]        @ get calling cpsr
38         ldr     lr, [sp, #S_OFF + S_PC]!        @ get pc
39         msr     spsr_cxsf, r1                   @ save in spsr_svc
40         ldmdb   sp, {r1 - lr}^                  @ get calling r1 - lr
41         mov     r0, r0
42         add     sp, sp, #S_FRAME_SIZE - S_PC
43         movs    pc, lr                          @ return & move spsr_svc into cpsr
44  UNWIND(.fnend          )
45
46 /*
47  * Ok, we need to do extra processing, enter the slow path.
48  */
49 fast_work_pending:
50         str     r0, [sp, #S_R0+S_OFF]!          @ returned r0
51 work_pending:
52         tst     r1, #_TIF_NEED_RESCHED
53         bne     work_resched
54         tst     r1, #_TIF_SIGPENDING
55         beq     no_work_pending
56         mov     r0, sp                          @ 'regs'
57         mov     r2, why                         @ 'syscall'
58         bl      do_notify_resume
59         b       ret_slow_syscall                @ Check work again
60
61 work_resched:
62         bl      schedule
63 /*
64  * "slow" syscall return path.  "why" tells us if this was a real syscall.
65  */
66 ENTRY(ret_to_user)
67 ret_slow_syscall:
68         disable_irq                             @ disable interrupts
69         ldr     r1, [tsk, #TI_FLAGS]
70         tst     r1, #_TIF_WORK_MASK
71         bne     work_pending
72 no_work_pending:
73         /* perform architecture specific actions before user return */
74         arch_ret_to_user r1, lr
75
76         @ slow_restore_user_regs
77         ldr     r1, [sp, #S_PSR]                @ get calling cpsr
78         ldr     lr, [sp, #S_PC]!                @ get pc
79         msr     spsr_cxsf, r1                   @ save in spsr_svc
80         ldmdb   sp, {r0 - lr}^                  @ get calling r0 - lr
81         mov     r0, r0
82         add     sp, sp, #S_FRAME_SIZE - S_PC
83         movs    pc, lr                          @ return & move spsr_svc into cpsr
84 ENDPROC(ret_to_user)
85
86 /*
87  * This is how we return from a fork.
88  */
89 ENTRY(ret_from_fork)
90         bl      schedule_tail
91         get_thread_info tsk
92         ldr     r1, [tsk, #TI_FLAGS]            @ check for syscall tracing
93         mov     why, #1
94         tst     r1, #_TIF_SYSCALL_TRACE         @ are we tracing syscalls?
95         beq     ret_slow_syscall
96         mov     r1, sp
97         mov     r0, #1                          @ trace exit [IP = 1]
98         bl      syscall_trace
99         b       ret_slow_syscall
100 ENDPROC(ret_from_fork)
101
102         .equ NR_syscalls,0
103 #define CALL(x) .equ NR_syscalls,NR_syscalls+1
104 #include "calls.S"
105 #undef CALL
106 #define CALL(x) .long x
107
108 #ifdef CONFIG_FUNCTION_TRACER
109 #ifdef CONFIG_DYNAMIC_FTRACE
110 ENTRY(mcount)
111         stmdb sp!, {r0-r3, lr}
112         mov r0, lr
113         sub r0, r0, #MCOUNT_INSN_SIZE
114
115         .globl mcount_call
116 mcount_call:
117         bl ftrace_stub
118         ldr lr, [fp, #-4]                       @ restore lr
119         ldmia sp!, {r0-r3, pc}
120
121 ENTRY(ftrace_caller)
122         stmdb sp!, {r0-r3, lr}
123         ldr r1, [fp, #-4]
124         mov r0, lr
125         sub r0, r0, #MCOUNT_INSN_SIZE
126
127         .globl ftrace_call
128 ftrace_call:
129         bl ftrace_stub
130         ldr lr, [fp, #-4]                       @ restore lr
131         ldmia sp!, {r0-r3, pc}
132
133 #else
134
135 ENTRY(mcount)
136         stmdb sp!, {r0-r3, lr}
137         ldr r0, =ftrace_trace_function
138         ldr r2, [r0]
139         adr r0, ftrace_stub
140         cmp r0, r2
141         bne trace
142         ldr lr, [fp, #-4]                       @ restore lr
143         ldmia sp!, {r0-r3, pc}
144
145 trace:
146         ldr r1, [fp, #-4]                       @ lr of instrumented routine
147         mov r0, lr
148         sub r0, r0, #MCOUNT_INSN_SIZE
149         mov lr, pc
150         mov pc, r2
151         mov lr, r1                              @ restore lr
152         ldmia sp!, {r0-r3, pc}
153
154 #endif /* CONFIG_DYNAMIC_FTRACE */
155
156         .globl ftrace_stub
157 ftrace_stub:
158         mov pc, lr
159
160 #endif /* CONFIG_FUNCTION_TRACER */
161
162 /*=============================================================================
163  * SWI handler
164  *-----------------------------------------------------------------------------
165  */
166
167         /* If we're optimising for StrongARM the resulting code won't 
168            run on an ARM7 and we can save a couple of instructions.  
169                                                                 --pb */
170 #ifdef CONFIG_CPU_ARM710
171 #define A710(code...) code
172 .Larm710bug:
173         ldmia   sp, {r0 - lr}^                  @ Get calling r0 - lr
174         mov     r0, r0
175         add     sp, sp, #S_FRAME_SIZE
176         subs    pc, lr, #4
177 #else
178 #define A710(code...)
179 #endif
180
181         .align  5
182 ENTRY(vector_swi)
183         sub     sp, sp, #S_FRAME_SIZE
184         stmia   sp, {r0 - r12}                  @ Calling r0 - r12
185         add     r8, sp, #S_PC
186         stmdb   r8, {sp, lr}^                   @ Calling sp, lr
187         mrs     r8, spsr                        @ called from non-FIQ mode, so ok.
188         str     lr, [sp, #S_PC]                 @ Save calling PC
189         str     r8, [sp, #S_PSR]                @ Save CPSR
190         str     r0, [sp, #S_OLD_R0]             @ Save OLD_R0
191         zero_fp
192
193         /*
194          * Get the system call number.
195          */
196
197 #if defined(CONFIG_OABI_COMPAT)
198
199         /*
200          * If we have CONFIG_OABI_COMPAT then we need to look at the swi
201          * value to determine if it is an EABI or an old ABI call.
202          */
203 #ifdef CONFIG_ARM_THUMB
204         tst     r8, #PSR_T_BIT
205         movne   r10, #0                         @ no thumb OABI emulation
206         ldreq   r10, [lr, #-4]                  @ get SWI instruction
207 #else
208         ldr     r10, [lr, #-4]                  @ get SWI instruction
209   A710( and     ip, r10, #0x0f000000            @ check for SWI         )
210   A710( teq     ip, #0x0f000000                                         )
211   A710( bne     .Larm710bug                                             )
212 #endif
213 #ifdef CONFIG_CPU_ENDIAN_BE8
214         rev     r10, r10                        @ little endian instruction
215 #endif
216
217 #elif defined(CONFIG_AEABI)
218
219         /*
220          * Pure EABI user space always put syscall number into scno (r7).
221          */
222   A710( ldr     ip, [lr, #-4]                   @ get SWI instruction   )
223   A710( and     ip, ip, #0x0f000000             @ check for SWI         )
224   A710( teq     ip, #0x0f000000                                         )
225   A710( bne     .Larm710bug                                             )
226
227 #elif defined(CONFIG_ARM_THUMB)
228
229         /* Legacy ABI only, possibly thumb mode. */
230         tst     r8, #PSR_T_BIT                  @ this is SPSR from save_user_regs
231         addne   scno, r7, #__NR_SYSCALL_BASE    @ put OS number in
232         ldreq   scno, [lr, #-4]
233
234 #else
235
236         /* Legacy ABI only. */
237         ldr     scno, [lr, #-4]                 @ get SWI instruction
238   A710( and     ip, scno, #0x0f000000           @ check for SWI         )
239   A710( teq     ip, #0x0f000000                                         )
240   A710( bne     .Larm710bug                                             )
241
242 #endif
243
244 #ifdef CONFIG_ALIGNMENT_TRAP
245         ldr     ip, __cr_alignment
246         ldr     ip, [ip]
247         mcr     p15, 0, ip, c1, c0              @ update control register
248 #endif
249         enable_irq
250
251         get_thread_info tsk
252         adr     tbl, sys_call_table             @ load syscall table pointer
253         ldr     ip, [tsk, #TI_FLAGS]            @ check for syscall tracing
254
255 #if defined(CONFIG_OABI_COMPAT)
256         /*
257          * If the swi argument is zero, this is an EABI call and we do nothing.
258          *
259          * If this is an old ABI call, get the syscall number into scno and
260          * get the old ABI syscall table address.
261          */
262         bics    r10, r10, #0xff000000
263         eorne   scno, r10, #__NR_OABI_SYSCALL_BASE
264         ldrne   tbl, =sys_oabi_call_table
265 #elif !defined(CONFIG_AEABI)
266         bic     scno, scno, #0xff000000         @ mask off SWI op-code
267         eor     scno, scno, #__NR_SYSCALL_BASE  @ check OS number
268 #endif
269
270         stmdb   sp!, {r4, r5}                   @ push fifth and sixth args
271         tst     ip, #_TIF_SYSCALL_TRACE         @ are we tracing syscalls?
272         bne     __sys_trace
273
274         cmp     scno, #NR_syscalls              @ check upper syscall limit
275         adr     lr, ret_fast_syscall            @ return address
276         ldrcc   pc, [tbl, scno, lsl #2]         @ call sys_* routine
277
278         add     r1, sp, #S_OFF
279 2:      mov     why, #0                         @ no longer a real syscall
280         cmp     scno, #(__ARM_NR_BASE - __NR_SYSCALL_BASE)
281         eor     r0, scno, #__NR_SYSCALL_BASE    @ put OS number back
282         bcs     arm_syscall     
283         b       sys_ni_syscall                  @ not private func
284 ENDPROC(vector_swi)
285
286         /*
287          * This is the really slow path.  We're going to be doing
288          * context switches, and waiting for our parent to respond.
289          */
290 __sys_trace:
291         mov     r2, scno
292         add     r1, sp, #S_OFF
293         mov     r0, #0                          @ trace entry [IP = 0]
294         bl      syscall_trace
295
296         adr     lr, __sys_trace_return          @ return address
297         mov     scno, r0                        @ syscall number (possibly new)
298         add     r1, sp, #S_R0 + S_OFF           @ pointer to regs
299         cmp     scno, #NR_syscalls              @ check upper syscall limit
300         ldmccia r1, {r0 - r3}                   @ have to reload r0 - r3
301         ldrcc   pc, [tbl, scno, lsl #2]         @ call sys_* routine
302         b       2b
303
304 __sys_trace_return:
305         str     r0, [sp, #S_R0 + S_OFF]!        @ save returned r0
306         mov     r2, scno
307         mov     r1, sp
308         mov     r0, #1                          @ trace exit [IP = 1]
309         bl      syscall_trace
310         b       ret_slow_syscall
311
312         .align  5
313 #ifdef CONFIG_ALIGNMENT_TRAP
314         .type   __cr_alignment, #object
315 __cr_alignment:
316         .word   cr_alignment
317 #endif
318         .ltorg
319
320 /*
321  * This is the syscall table declaration for native ABI syscalls.
322  * With EABI a couple syscalls are obsolete and defined as sys_ni_syscall.
323  */
324 #define ABI(native, compat) native
325 #ifdef CONFIG_AEABI
326 #define OBSOLETE(syscall) sys_ni_syscall
327 #else
328 #define OBSOLETE(syscall) syscall
329 #endif
330
331         .type   sys_call_table, #object
332 ENTRY(sys_call_table)
333 #include "calls.S"
334 #undef ABI
335 #undef OBSOLETE
336
337 /*============================================================================
338  * Special system call wrappers
339  */
340 @ r0 = syscall number
341 @ r8 = syscall table
342 sys_syscall:
343                 bic     scno, r0, #__NR_OABI_SYSCALL_BASE
344                 cmp     scno, #__NR_syscall - __NR_SYSCALL_BASE
345                 cmpne   scno, #NR_syscalls      @ check range
346                 stmloia sp, {r5, r6}            @ shuffle args
347                 movlo   r0, r1
348                 movlo   r1, r2
349                 movlo   r2, r3
350                 movlo   r3, r4
351                 ldrlo   pc, [tbl, scno, lsl #2]
352                 b       sys_ni_syscall
353 ENDPROC(sys_syscall)
354
355 sys_fork_wrapper:
356                 add     r0, sp, #S_OFF
357                 b       sys_fork
358 ENDPROC(sys_fork_wrapper)
359
360 sys_vfork_wrapper:
361                 add     r0, sp, #S_OFF
362                 b       sys_vfork
363 ENDPROC(sys_vfork_wrapper)
364
365 sys_execve_wrapper:
366                 add     r3, sp, #S_OFF
367                 b       sys_execve
368 ENDPROC(sys_execve_wrapper)
369
370 sys_clone_wrapper:
371                 add     ip, sp, #S_OFF
372                 str     ip, [sp, #4]
373                 b       sys_clone
374 ENDPROC(sys_clone_wrapper)
375
376 sys_sigsuspend_wrapper:
377                 add     r3, sp, #S_OFF
378                 b       sys_sigsuspend
379 ENDPROC(sys_sigsuspend_wrapper)
380
381 sys_rt_sigsuspend_wrapper:
382                 add     r2, sp, #S_OFF
383                 b       sys_rt_sigsuspend
384 ENDPROC(sys_rt_sigsuspend_wrapper)
385
386 sys_sigreturn_wrapper:
387                 add     r0, sp, #S_OFF
388                 b       sys_sigreturn
389 ENDPROC(sys_sigreturn_wrapper)
390
391 sys_rt_sigreturn_wrapper:
392                 add     r0, sp, #S_OFF
393                 b       sys_rt_sigreturn
394 ENDPROC(sys_rt_sigreturn_wrapper)
395
396 sys_sigaltstack_wrapper:
397                 ldr     r2, [sp, #S_OFF + S_SP]
398                 b       do_sigaltstack
399 ENDPROC(sys_sigaltstack_wrapper)
400
401 sys_statfs64_wrapper:
402                 teq     r1, #88
403                 moveq   r1, #84
404                 b       sys_statfs64
405 ENDPROC(sys_statfs64_wrapper)
406
407 sys_fstatfs64_wrapper:
408                 teq     r1, #88
409                 moveq   r1, #84
410                 b       sys_fstatfs64
411 ENDPROC(sys_fstatfs64_wrapper)
412
413 /*
414  * Note: off_4k (r5) is always units of 4K.  If we can't do the requested
415  * offset, we return EINVAL.
416  */
417 sys_mmap2:
418 #if PAGE_SHIFT > 12
419                 tst     r5, #PGOFF_MASK
420                 moveq   r5, r5, lsr #PAGE_SHIFT - 12
421                 streq   r5, [sp, #4]
422                 beq     do_mmap2
423                 mov     r0, #-EINVAL
424                 mov     pc, lr
425 #else
426                 str     r5, [sp, #4]
427                 b       do_mmap2
428 #endif
429 ENDPROC(sys_mmap2)
430
431 ENTRY(pabort_ifar)
432                 mrc     p15, 0, r0, cr6, cr0, 2
433 ENTRY(pabort_noifar)
434                 mov     pc, lr
435 ENDPROC(pabort_ifar)
436 ENDPROC(pabort_noifar)
437
438 #ifdef CONFIG_OABI_COMPAT
439
440 /*
441  * These are syscalls with argument register differences
442  */
443
444 sys_oabi_pread64:
445                 stmia   sp, {r3, r4}
446                 b       sys_pread64
447 ENDPROC(sys_oabi_pread64)
448
449 sys_oabi_pwrite64:
450                 stmia   sp, {r3, r4}
451                 b       sys_pwrite64
452 ENDPROC(sys_oabi_pwrite64)
453
454 sys_oabi_truncate64:
455                 mov     r3, r2
456                 mov     r2, r1
457                 b       sys_truncate64
458 ENDPROC(sys_oabi_truncate64)
459
460 sys_oabi_ftruncate64:
461                 mov     r3, r2
462                 mov     r2, r1
463                 b       sys_ftruncate64
464 ENDPROC(sys_oabi_ftruncate64)
465
466 sys_oabi_readahead:
467                 str     r3, [sp]
468                 mov     r3, r2
469                 mov     r2, r1
470                 b       sys_readahead
471 ENDPROC(sys_oabi_readahead)
472
473 /*
474  * Let's declare a second syscall table for old ABI binaries
475  * using the compatibility syscall entries.
476  */
477 #define ABI(native, compat) compat
478 #define OBSOLETE(syscall) syscall
479
480         .type   sys_oabi_call_table, #object
481 ENTRY(sys_oabi_call_table)
482 #include "calls.S"
483 #undef ABI
484 #undef OBSOLETE
485
486 #endif
487