2 * Low-level system-call handling, trap handlers and context-switching
4 * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
5 * Copyright (C) 2008-2009 PetaLogix
6 * Copyright (C) 2003 John Williams <jwilliams@itee.uq.edu.au>
7 * Copyright (C) 2001,2002 NEC Corporation
8 * Copyright (C) 2001,2002 Miles Bader <miles@gnu.org>
10 * This file is subject to the terms and conditions of the GNU General
11 * Public License. See the file COPYING in the main directory of this
12 * archive for more details.
14 * Written by Miles Bader <miles@gnu.org>
15 * Heavily modified by John Williams for Microblaze
18 #include <linux/sys.h>
19 #include <linux/linkage.h>
21 #include <asm/entry.h>
22 #include <asm/current.h>
23 #include <asm/processor.h>
24 #include <asm/exceptions.h>
25 #include <asm/asm-offsets.h>
26 #include <asm/thread_info.h>
29 #include <asm/unistd.h>
31 #include <linux/errno.h>
32 #include <asm/signal.h>
36 /* The size of a state save frame. */
37 #define STATE_SAVE_SIZE (PT_SIZE + STATE_SAVE_ARG_SPACE)
39 /* The offset of the struct pt_regs in a `state save frame' on the stack. */
40 #define PTO STATE_SAVE_ARG_SPACE /* 24 the space for args */
42 #define C_ENTRY(name) .globl name; .align 4; name
45 * Various ways of setting and clearing BIP in flags reg.
46 * This is mucky, but necessary using microblaze version that
47 * allows msr ops to write to BIP
49 #if CONFIG_XILINX_MICROBLAZE0_USE_MSR_INSTR
104 andi r11, r11, ~MSR_BIP
112 ori r11, r11, MSR_BIP
120 andi r11, r11, ~MSR_EIP
136 andi r11, r11, ~MSR_IE
152 ori r11, r11, MSR_VMS
153 andni r11, r11, MSR_UMS
161 ori r11, r11, MSR_VMS
162 andni r11, r11, MSR_UMS
170 andni r11, r11, (MSR_VMS|MSR_UMS)
176 /* Define how to call high-level functions. With MMU, virtual mode must be
177 * enabled when calling the high-level function. Clobbers R11.
178 * VM_ON, VM_OFF, DO_JUMP_BIPCLR, DO_CALL
181 /* turn on virtual protected mode save */
187 /* turn off virtual protected mode save and user mode save*/
190 rted r0, TOPHYS(1f); \
194 swi r2, r1, PTO+PT_R2; /* Save SDA */ \
195 swi r5, r1, PTO+PT_R5; \
196 swi r6, r1, PTO+PT_R6; \
197 swi r7, r1, PTO+PT_R7; \
198 swi r8, r1, PTO+PT_R8; \
199 swi r9, r1, PTO+PT_R9; \
200 swi r10, r1, PTO+PT_R10; \
201 swi r11, r1, PTO+PT_R11; /* save clobbered regs after rval */\
202 swi r12, r1, PTO+PT_R12; \
203 swi r13, r1, PTO+PT_R13; /* Save SDA2 */ \
204 swi r14, r1, PTO+PT_PC; /* PC, before IRQ/trap */ \
205 swi r15, r1, PTO+PT_R15; /* Save LP */ \
206 swi r18, r1, PTO+PT_R18; /* Save asm scratch reg */ \
207 swi r19, r1, PTO+PT_R19; \
208 swi r20, r1, PTO+PT_R20; \
209 swi r21, r1, PTO+PT_R21; \
210 swi r22, r1, PTO+PT_R22; \
211 swi r23, r1, PTO+PT_R23; \
212 swi r24, r1, PTO+PT_R24; \
213 swi r25, r1, PTO+PT_R25; \
214 swi r26, r1, PTO+PT_R26; \
215 swi r27, r1, PTO+PT_R27; \
216 swi r28, r1, PTO+PT_R28; \
217 swi r29, r1, PTO+PT_R29; \
218 swi r30, r1, PTO+PT_R30; \
219 swi r31, r1, PTO+PT_R31; /* Save current task reg */ \
220 mfs r11, rmsr; /* save MSR */ \
222 swi r11, r1, PTO+PT_MSR;
224 #define RESTORE_REGS \
225 lwi r11, r1, PTO+PT_MSR; \
228 lwi r2, r1, PTO+PT_R2; /* restore SDA */ \
229 lwi r5, r1, PTO+PT_R5; \
230 lwi r6, r1, PTO+PT_R6; \
231 lwi r7, r1, PTO+PT_R7; \
232 lwi r8, r1, PTO+PT_R8; \
233 lwi r9, r1, PTO+PT_R9; \
234 lwi r10, r1, PTO+PT_R10; \
235 lwi r11, r1, PTO+PT_R11; /* restore clobbered regs after rval */\
236 lwi r12, r1, PTO+PT_R12; \
237 lwi r13, r1, PTO+PT_R13; /* restore SDA2 */ \
238 lwi r14, r1, PTO+PT_PC; /* RESTORE_LINK PC, before IRQ/trap */\
239 lwi r15, r1, PTO+PT_R15; /* restore LP */ \
240 lwi r18, r1, PTO+PT_R18; /* restore asm scratch reg */ \
241 lwi r19, r1, PTO+PT_R19; \
242 lwi r20, r1, PTO+PT_R20; \
243 lwi r21, r1, PTO+PT_R21; \
244 lwi r22, r1, PTO+PT_R22; \
245 lwi r23, r1, PTO+PT_R23; \
246 lwi r24, r1, PTO+PT_R24; \
247 lwi r25, r1, PTO+PT_R25; \
248 lwi r26, r1, PTO+PT_R26; \
249 lwi r27, r1, PTO+PT_R27; \
250 lwi r28, r1, PTO+PT_R28; \
251 lwi r29, r1, PTO+PT_R29; \
252 lwi r30, r1, PTO+PT_R30; \
253 lwi r31, r1, PTO+PT_R31; /* Restore cur task reg */
260 * System calls are handled here.
263 * Syscall number in r12, args in r5-r10
266 * Trap entered via brki instruction, so BIP bit is set, and interrupts
267 * are masked. This is nice, means we don't have to CLI before state save
269 C_ENTRY(_user_exception):
270 swi r1, r0, TOPHYS(PER_CPU(ENTRY_SP)) /* save stack */
271 addi r14, r14, 4 /* return address is 4 byte after call */
272 swi r11, r0, TOPHYS(r0_ram + PTO + PT_R11); /* Save r11 */
274 lwi r11, r0, TOPHYS(PER_CPU(KM));/* See if already in kernel mode.*/
275 beqi r11, 1f; /* Jump ahead if coming from user */
276 /* Kernel-mode state save. */
277 lwi r11, r0, TOPHYS(PER_CPU(ENTRY_SP)); /* Reload kernel stack-ptr*/
279 swi r11, r1, (PT_R1-PT_SIZE); /* Save original SP. */
280 lwi r11, r0, TOPHYS(r0_ram + PTO + PT_R11); /* restore r11 */
282 addik r1, r1, -STATE_SAVE_SIZE; /* Make room on the stack. */
285 addi r11, r0, 1; /* Was in kernel-mode. */
286 swi r11, r1, PTO+PT_MODE; /* pt_regs -> kernel mode */
288 nop; /* Fill delay slot */
290 /* User-mode state save. */
292 lwi r11, r0, TOPHYS(r0_ram + PTO + PT_R11); /* restore r11 */
293 lwi r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */
295 lwi r1, r1, TS_THREAD_INFO; /* get stack from task_struct */
296 /* calculate kernel stack pointer from task struct 8k */
297 addik r1, r1, THREAD_SIZE;
300 addik r1, r1, -STATE_SAVE_SIZE; /* Make room on the stack. */
303 swi r0, r1, PTO+PT_MODE; /* Was in user-mode. */
304 lwi r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
305 swi r11, r1, PTO+PT_R1; /* Store user SP. */
307 swi r11, r0, TOPHYS(PER_CPU(KM)); /* Now we're in kernel-mode. */
308 2: lwi r31, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */
309 /* Save away the syscall number. */
310 swi r12, r1, PTO+PT_R0;
313 /* where the trap should return need -8 to adjust for rtsd r15, 8*/
314 /* Jump to the appropriate function for the system call number in r12
315 * (r12 is not preserved), or return an error if r12 is not valid. The LP
316 * register should point to the location where
317 * the called function should return. [note that MAKE_SYS_CALL uses label 1] */
319 # Step into virtual mode.
325 add r11, r0, CURRENT_TASK /* Get current task ptr into r11 */
326 lwi r11, r11, TS_THREAD_INFO /* get thread info */
327 lwi r11, r11, TI_FLAGS /* get flags in thread info */
328 andi r11, r11, _TIF_WORK_SYSCALL_MASK
331 addik r3, r0, -ENOSYS
332 swi r3, r1, PTO + PT_R3
333 brlid r15, do_syscall_trace_enter
334 addik r5, r1, PTO + PT_R0
336 # do_syscall_trace_enter returns the new syscall nr.
338 lwi r5, r1, PTO+PT_R5;
339 lwi r6, r1, PTO+PT_R6;
340 lwi r7, r1, PTO+PT_R7;
341 lwi r8, r1, PTO+PT_R8;
342 lwi r9, r1, PTO+PT_R9;
343 lwi r10, r1, PTO+PT_R10;
345 /* Jump to the appropriate function for the system call number in r12
346 * (r12 is not preserved), or return an error if r12 is not valid.
347 * The LP register should point to the location where the called function
348 * should return. [note that MAKE_SYS_CALL uses label 1] */
349 /* See if the system call number is valid */
350 addi r11, r12, -__NR_syscalls;
352 /* Figure out which function to use for this system call. */
353 /* Note Microblaze barrel shift is optional, so don't rely on it */
354 add r12, r12, r12; /* convert num -> ptr */
358 /* Trac syscalls and stored them to r0_ram */
359 lwi r3, r12, 0x400 + r0_ram
361 swi r3, r12, 0x400 + r0_ram
364 # Find and jump into the syscall handler.
365 lwi r12, r12, sys_call_table
366 /* where the trap should return need -8 to adjust for rtsd r15, 8 */
367 la r15, r0, ret_from_trap-8
370 /* The syscall number is invalid, return an error. */
372 addi r3, r0, -ENOSYS;
373 rtsd r15,8; /* looks like a normal subroutine return */
377 /* Entry point used to return from a syscall/trap */
378 /* We re-enable BIP bit before state restore */
379 C_ENTRY(ret_from_trap):
380 set_bip; /* Ints masked for state restore*/
381 lwi r11, r1, PTO+PT_MODE;
382 /* See if returning to kernel mode, if so, skip resched &c. */
385 /* We're returning to user mode, so check for various conditions that
386 * trigger rescheduling. */
387 # FIXME: Restructure all these flag checks.
388 add r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
389 lwi r11, r11, TS_THREAD_INFO; /* get thread info */
390 lwi r11, r11, TI_FLAGS; /* get flags in thread info */
391 andi r11, r11, _TIF_WORK_SYSCALL_MASK
394 swi r3, r1, PTO + PT_R3
395 swi r4, r1, PTO + PT_R4
396 brlid r15, do_syscall_trace_leave
397 addik r5, r1, PTO + PT_R0
398 lwi r3, r1, PTO + PT_R3
399 lwi r4, r1, PTO + PT_R4
402 /* We're returning to user mode, so check for various conditions that
403 * trigger rescheduling. */
404 /* Get current task ptr into r11 */
405 add r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
406 lwi r11, r11, TS_THREAD_INFO; /* get thread info */
407 lwi r11, r11, TI_FLAGS; /* get flags in thread info */
408 andi r11, r11, _TIF_NEED_RESCHED;
411 swi r3, r1, PTO + PT_R3; /* store syscall result */
412 swi r4, r1, PTO + PT_R4;
413 bralid r15, schedule; /* Call scheduler */
414 nop; /* delay slot */
415 lwi r3, r1, PTO + PT_R3; /* restore syscall result */
416 lwi r4, r1, PTO + PT_R4;
418 /* Maybe handle a signal */
419 5: add r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
420 lwi r11, r11, TS_THREAD_INFO; /* get thread info */
421 lwi r11, r11, TI_FLAGS; /* get flags in thread info */
422 andi r11, r11, _TIF_SIGPENDING;
423 beqi r11, 1f; /* Signals to handle, handle them */
425 swi r3, r1, PTO + PT_R3; /* store syscall result */
426 swi r4, r1, PTO + PT_R4;
427 la r5, r1, PTO; /* Arg 1: struct pt_regs *regs */
428 add r6, r0, r0; /* Arg 2: sigset_t *oldset */
429 addi r7, r0, 1; /* Arg 3: int in_syscall */
430 bralid r15, do_signal; /* Handle any signals */
432 lwi r3, r1, PTO + PT_R3; /* restore syscall result */
433 lwi r4, r1, PTO + PT_R4;
435 /* Finally, return to user state. */
436 1: swi r0, r0, PER_CPU(KM); /* Now officially in user state. */
437 add r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
438 swi r11, r0, PER_CPU(CURRENT_SAVE); /* save current */
442 addik r1, r1, STATE_SAVE_SIZE /* Clean up stack space. */
443 lwi r1, r1, PT_R1 - PT_SIZE;/* Restore user stack pointer. */
446 /* Return to kernel state. */
450 addik r1, r1, STATE_SAVE_SIZE /* Clean up stack space. */
453 TRAP_return: /* Make global symbol for debugging */
454 rtbd r14, 0; /* Instructions to return from an IRQ */
458 /* These syscalls need access to the struct pt_regs on the stack, so we
459 implement them in assembly (they're basically all wrappers anyway). */
461 C_ENTRY(sys_fork_wrapper):
462 addi r5, r0, SIGCHLD /* Arg 0: flags */
463 lwi r6, r1, PTO+PT_R1 /* Arg 1: child SP (use parent's) */
464 la r7, r1, PTO /* Arg 2: parent context */
465 add r8. r0, r0 /* Arg 3: (unused) */
466 add r9, r0, r0; /* Arg 4: (unused) */
467 add r10, r0, r0; /* Arg 5: (unused) */
468 brid do_fork /* Do real work (tail-call) */
471 /* This the initial entry point for a new child thread, with an appropriate
472 stack in place that makes it look the the child is in the middle of an
473 syscall. This function is actually `returned to' from switch_thread
474 (copy_thread makes ret_from_fork the return address in each new thread's
476 C_ENTRY(ret_from_fork):
477 bralid r15, schedule_tail; /* ...which is schedule_tail's arg */
478 add r3, r5, r0; /* switch_thread returns the prev task */
479 /* ( in the delay slot ) */
480 add r3, r0, r0; /* Child's fork call should return 0. */
481 brid ret_from_trap; /* Do normal trap return */
485 brid microblaze_vfork /* Do real work (tail-call) */
489 bnei r6, 1f; /* See if child SP arg (arg 1) is 0. */
490 lwi r6, r1, PTO+PT_R1; /* If so, use paret's stack ptr */
491 1: la r7, r1, PTO; /* Arg 2: parent context */
492 add r8, r0, r0; /* Arg 3: (unused) */
493 add r9, r0, r0; /* Arg 4: (unused) */
494 add r10, r0, r0; /* Arg 5: (unused) */
495 brid do_fork /* Do real work (tail-call) */
499 la r8, r1, PTO; /* add user context as 4th arg */
500 brid microblaze_execve; /* Do real work (tail-call).*/
503 C_ENTRY(sys_rt_sigreturn_wrapper):
504 swi r3, r1, PTO+PT_R3; /* restore saved r3, r4 registers */
505 swi r4, r1, PTO+PT_R4;
506 la r5, r1, PTO; /* add user context as 1st arg */
507 brlid r15, sys_rt_sigreturn /* Do real work */
509 lwi r3, r1, PTO+PT_R3; /* restore saved r3, r4 registers */
510 lwi r4, r1, PTO+PT_R4;
511 bri ret_from_trap /* fall through will not work here due to align */
515 * HW EXCEPTION rutine start
519 swi r11, r0, TOPHYS(r0_ram + PTO + PT_R11); /* Save r11 */ \
520 set_bip; /*equalize initial state for all possible entries*/\
524 /* See if already in kernel mode.*/ \
525 lwi r11, r0, TOPHYS(PER_CPU(KM)); \
526 beqi r11, 1f; /* Jump ahead if coming from user */\
527 /* Kernel-mode state save. */ \
528 /* Reload kernel stack-ptr. */ \
529 lwi r11, r0, TOPHYS(PER_CPU(ENTRY_SP)); \
531 swi r11, r1, (PT_R1-PT_SIZE); /* Save original SP. */ \
532 lwi r11, r0, TOPHYS(r0_ram + PTO + PT_R11); /* restore r11 */\
533 addik r1, r1, -STATE_SAVE_SIZE; /* Make room on the stack. */\
534 /* store return registers separately because \
535 * this macros is use for others exceptions */ \
536 swi r3, r1, PTO + PT_R3; \
537 swi r4, r1, PTO + PT_R4; \
539 /* PC, before IRQ/trap - this is one instruction above */ \
540 swi r17, r1, PTO+PT_PC; \
542 addi r11, r0, 1; /* Was in kernel-mode. */ \
543 swi r11, r1, PTO+PT_MODE; \
545 nop; /* Fill delay slot */ \
546 1: /* User-mode state save. */ \
547 lwi r11, r0, TOPHYS(r0_ram + PTO + PT_R11); /* restore r11 */\
548 lwi r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */\
550 lwi r1, r1, TS_THREAD_INFO; /* get the thread info */ \
551 addik r1, r1, THREAD_SIZE; /* calculate kernel stack pointer */\
554 addik r1, r1, -STATE_SAVE_SIZE; /* Make room on the stack. */\
555 /* store return registers separately because this macros \
556 * is use for others exceptions */ \
557 swi r3, r1, PTO + PT_R3; \
558 swi r4, r1, PTO + PT_R4; \
560 /* PC, before IRQ/trap - this is one instruction above FIXME*/ \
561 swi r17, r1, PTO+PT_PC; \
563 swi r0, r1, PTO+PT_MODE; /* Was in user-mode. */ \
564 lwi r11, r0, TOPHYS(PER_CPU(ENTRY_SP)); \
565 swi r11, r1, PTO+PT_R1; /* Store user SP. */ \
567 swi r11, r0, TOPHYS(PER_CPU(KM)); /* Now we're in kernel-mode.*/\
568 2: lwi r31, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */\
569 /* Save away the syscall number. */ \
570 swi r0, r1, PTO+PT_R0; \
573 C_ENTRY(full_exception_trap):
574 swi r1, r0, TOPHYS(PER_CPU(ENTRY_SP)) /* save stack */
575 /* adjust exception address for privileged instruction
576 * for finding where is it */
578 SAVE_STATE /* Save registers */
579 /* FIXME this can be store directly in PT_ESR reg.
580 * I tested it but there is a fault */
581 /* where the trap should return need -8 to adjust for rtsd r15, 8 */
582 la r15, r0, ret_from_exc - 8
583 la r5, r1, PTO /* parameter struct pt_regs * regs */
586 mfs r7, rfsr; /* save FSR */
588 mts rfsr, r0; /* Clear sticky fsr */
590 la r12, r0, full_exception
596 * Unaligned data trap.
598 * Unaligned data trap last on 4k page is handled here.
600 * Trap entered via exception, so EE bit is set, and interrupts
601 * are masked. This is nice, means we don't have to CLI before state save
603 * The assembler routine is in "arch/microblaze/kernel/hw_exception_handler.S"
605 C_ENTRY(unaligned_data_trap):
606 swi r1, r0, TOPHYS(PER_CPU(ENTRY_SP)) /* save stack */
607 SAVE_STATE /* Save registers.*/
608 /* where the trap should return need -8 to adjust for rtsd r15, 8 */
609 la r15, r0, ret_from_exc-8
610 mfs r3, resr /* ESR */
612 mfs r4, rear /* EAR */
614 la r7, r1, PTO /* parameter struct pt_regs * regs */
615 la r12, r0, _unaligned_data_exception
617 rtbd r12, 0; /* interrupts enabled */
623 * If the real exception handler (from hw_exception_handler.S) didn't find
624 * the mapping for the process, then we're thrown here to handle such situation.
626 * Trap entered via exceptions, so EE bit is set, and interrupts
627 * are masked. This is nice, means we don't have to CLI before state save
629 * Build a standard exception frame for TLB Access errors. All TLB exceptions
630 * will bail out to this point if they can't resolve the lightweight TLB fault.
632 * The C function called is in "arch/microblaze/mm/fault.c", declared as:
633 * void do_page_fault(struct pt_regs *regs,
634 * unsigned long address,
635 * unsigned long error_code)
637 /* data and intruction trap - which is choose is resolved int fault.c */
638 C_ENTRY(page_fault_data_trap):
639 swi r1, r0, TOPHYS(PER_CPU(ENTRY_SP)) /* save stack */
640 SAVE_STATE /* Save registers.*/
641 /* where the trap should return need -8 to adjust for rtsd r15, 8 */
642 la r15, r0, ret_from_exc-8
643 la r5, r1, PTO /* parameter struct pt_regs * regs */
644 mfs r6, rear /* parameter unsigned long address */
646 mfs r7, resr /* parameter unsigned long error_code */
648 la r12, r0, do_page_fault
650 rtbd r12, 0; /* interrupts enabled */
653 C_ENTRY(page_fault_instr_trap):
654 swi r1, r0, TOPHYS(PER_CPU(ENTRY_SP)) /* save stack */
655 SAVE_STATE /* Save registers.*/
656 /* where the trap should return need -8 to adjust for rtsd r15, 8 */
657 la r15, r0, ret_from_exc-8
658 la r5, r1, PTO /* parameter struct pt_regs * regs */
659 mfs r6, rear /* parameter unsigned long address */
661 ori r7, r0, 0 /* parameter unsigned long error_code */
662 la r12, r0, do_page_fault
664 rtbd r12, 0; /* interrupts enabled */
667 /* Entry point used to return from an exception. */
668 C_ENTRY(ret_from_exc):
669 set_bip; /* Ints masked for state restore*/
670 lwi r11, r1, PTO+PT_MODE;
671 bnei r11, 2f; /* See if returning to kernel mode, */
672 /* ... if so, skip resched &c. */
674 /* We're returning to user mode, so check for various conditions that
675 trigger rescheduling. */
676 /* Get current task ptr into r11 */
677 add r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
678 lwi r11, r11, TS_THREAD_INFO; /* get thread info */
679 lwi r11, r11, TI_FLAGS; /* get flags in thread info */
680 andi r11, r11, _TIF_NEED_RESCHED;
683 /* Call the scheduler before returning from a syscall/trap. */
684 bralid r15, schedule; /* Call scheduler */
685 nop; /* delay slot */
687 /* Maybe handle a signal */
688 5: add r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
689 lwi r11, r11, TS_THREAD_INFO; /* get thread info */
690 lwi r11, r11, TI_FLAGS; /* get flags in thread info */
691 andi r11, r11, _TIF_SIGPENDING;
692 beqi r11, 1f; /* Signals to handle, handle them */
695 * Handle a signal return; Pending signals should be in r18.
697 * Not all registers are saved by the normal trap/interrupt entry
698 * points (for instance, call-saved registers (because the normal
699 * C-compiler calling sequence in the kernel makes sure they're
700 * preserved), and call-clobbered registers in the case of
701 * traps), but signal handlers may want to examine or change the
702 * complete register state. Here we save anything not saved by
703 * the normal entry sequence, so that it may be safely restored
704 * (in a possibly modified form) after do_signal returns.
705 * store return registers separately because this macros is use
706 * for others exceptions */
707 la r5, r1, PTO; /* Arg 1: struct pt_regs *regs */
708 add r6, r0, r0; /* Arg 2: sigset_t *oldset */
709 addi r7, r0, 0; /* Arg 3: int in_syscall */
710 bralid r15, do_signal; /* Handle any signals */
713 /* Finally, return to user state. */
714 1: swi r0, r0, PER_CPU(KM); /* Now officially in user state. */
715 add r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
716 swi r11, r0, PER_CPU(CURRENT_SAVE); /* save current */
720 lwi r3, r1, PTO+PT_R3; /* restore saved r3, r4 registers */
721 lwi r4, r1, PTO+PT_R4;
723 addik r1, r1, STATE_SAVE_SIZE /* Clean up stack space. */
725 lwi r1, r1, PT_R1 - PT_SIZE; /* Restore user stack pointer. */
727 /* Return to kernel state. */
730 lwi r3, r1, PTO+PT_R3; /* restore saved r3, r4 registers */
731 lwi r4, r1, PTO+PT_R4;
733 addik r1, r1, STATE_SAVE_SIZE /* Clean up stack space. */
737 EXC_return: /* Make global symbol for debugging */
738 rtbd r14, 0; /* Instructions to return from an IRQ */
742 * HW EXCEPTION rutine end
746 * Hardware maskable interrupts.
748 * The stack-pointer (r1) should have already been saved to the memory
749 * location PER_CPU(ENTRY_SP).
752 /* MS: we are in physical address */
753 /* Save registers, switch to proper stack, convert SP to virtual.*/
754 swi r1, r0, TOPHYS(PER_CPU(ENTRY_SP))
755 swi r11, r0, TOPHYS(PER_CPU(R11_SAVE));
756 /* MS: See if already in kernel mode. */
757 lwi r11, r0, TOPHYS(PER_CPU(KM));
758 beqi r11, 1f; /* MS: Jump ahead if coming from user */
760 /* Kernel-mode state save. */
762 tophys(r1,r11); /* MS: I have in r1 physical address where stack is */
763 /* MS: Save original SP - position PT_R1 to next stack frame 4 *1 - 152*/
764 swi r11, r1, (PT_R1 - PT_SIZE);
765 /* MS: restore r11 because of saving in SAVE_REGS */
766 lwi r11, r0, TOPHYS(PER_CPU(R11_SAVE));
768 /* MS: Make room on the stack -> activation record */
769 addik r1, r1, -STATE_SAVE_SIZE;
770 /* MS: store return registers separately because
771 * this macros is use for others exceptions */
772 swi r3, r1, PTO + PT_R3;
773 swi r4, r1, PTO + PT_R4;
776 addi r11, r0, 1; /* MS: Was in kernel-mode. */
777 swi r11, r1, PTO + PT_MODE; /* MS: and save it */
779 nop; /* MS: Fill delay slot */
782 /* User-mode state save. */
783 /* MS: restore r11 -> FIXME move before SAVE_REG */
784 lwi r11, r0, TOPHYS(PER_CPU(R11_SAVE));
785 /* MS: get the saved current */
786 lwi r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
788 lwi r1, r1, TS_THREAD_INFO;
789 addik r1, r1, THREAD_SIZE;
792 addik r1, r1, -STATE_SAVE_SIZE;
793 swi r3, r1, PTO+PT_R3;
794 swi r4, r1, PTO+PT_R4;
797 swi r0, r1, PTO + PT_MODE;
798 lwi r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
799 swi r11, r1, PTO+PT_R1;
800 /* setup kernel mode to KM */
802 swi r11, r0, TOPHYS(PER_CPU(KM));
805 lwi r31, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
806 swi r0, r1, PTO + PT_R0;
811 la r15, r0, irq_call;
812 irq_call:rtbd r11, 0;
815 /* MS: we are in virtual mode */
817 lwi r11, r1, PTO + PT_MODE;
820 add r11, r0, CURRENT_TASK;
821 lwi r11, r11, TS_THREAD_INFO;
822 lwi r11, r11, TI_FLAGS; /* MS: get flags from thread info */
823 andi r11, r11, _TIF_NEED_RESCHED;
825 bralid r15, schedule;
826 nop; /* delay slot */
828 /* Maybe handle a signal */
829 5: add r11, r0, CURRENT_TASK;
830 lwi r11, r11, TS_THREAD_INFO; /* MS: get thread info */
831 lwi r11, r11, TI_FLAGS; /* get flags in thread info */
832 andi r11, r11, _TIF_SIGPENDING;
833 beqid r11, no_intr_resched
834 /* Handle a signal return; Pending signals should be in r18. */
835 addi r7, r0, 0; /* Arg 3: int in_syscall */
836 la r5, r1, PTO; /* Arg 1: struct pt_regs *regs */
837 bralid r15, do_signal; /* Handle any signals */
838 add r6, r0, r0; /* Arg 2: sigset_t *oldset */
840 /* Finally, return to user state. */
842 /* Disable interrupts, we are now committed to the state restore */
844 swi r0, r0, PER_CPU(KM); /* MS: Now officially in user state. */
845 add r11, r0, CURRENT_TASK;
846 swi r11, r0, PER_CPU(CURRENT_SAVE);
849 lwi r3, r1, PTO + PT_R3; /* MS: restore saved r3, r4 registers */
850 lwi r4, r1, PTO + PT_R4;
852 addik r1, r1, STATE_SAVE_SIZE /* MS: Clean up stack space. */
853 lwi r1, r1, PT_R1 - PT_SIZE;
855 /* MS: Return to kernel state. */
856 2: VM_OFF /* MS: turn off MMU */
858 lwi r3, r1, PTO + PT_R3; /* MS: restore saved r3, r4 registers */
859 lwi r4, r1, PTO + PT_R4;
861 addik r1, r1, STATE_SAVE_SIZE /* MS: Clean up stack space. */
864 IRQ_return: /* MS: Make global symbol for debugging */
870 * We enter dbtrap in "BIP" (breakpoint) mode.
871 * So we exit the breakpoint mode with an 'rtbd' and proceed with the
873 * however, wait to save state first
875 C_ENTRY(_debug_exception):
876 /* BIP bit is set on entry, no interrupts can occur */
877 swi r1, r0, TOPHYS(PER_CPU(ENTRY_SP))
879 swi r11, r0, TOPHYS(r0_ram + PTO + PT_R11); /* Save r11 */
880 set_bip; /*equalize initial state for all possible entries*/
883 lwi r11, r0, TOPHYS(PER_CPU(KM));/* See if already in kernel mode.*/
884 beqi r11, 1f; /* Jump ahead if coming from user */
885 /* Kernel-mode state save. */
886 lwi r11, r0, TOPHYS(PER_CPU(ENTRY_SP)); /* Reload kernel stack-ptr*/
888 swi r11, r1, (PT_R1-PT_SIZE); /* Save original SP. */
889 lwi r11, r0, TOPHYS(r0_ram + PTO + PT_R11); /* restore r11 */
891 addik r1, r1, -STATE_SAVE_SIZE; /* Make room on the stack. */
892 swi r3, r1, PTO + PT_R3;
893 swi r4, r1, PTO + PT_R4;
896 addi r11, r0, 1; /* Was in kernel-mode. */
897 swi r11, r1, PTO + PT_MODE;
899 nop; /* Fill delay slot */
900 1: /* User-mode state save. */
901 lwi r11, r0, TOPHYS(r0_ram + PTO + PT_R11); /* restore r11 */
902 lwi r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */
904 lwi r1, r1, TS_THREAD_INFO; /* get the thread info */
905 addik r1, r1, THREAD_SIZE; /* calculate kernel stack pointer */
908 addik r1, r1, -STATE_SAVE_SIZE; /* Make room on the stack. */
909 swi r3, r1, PTO + PT_R3;
910 swi r4, r1, PTO + PT_R4;
913 swi r0, r1, PTO+PT_MODE; /* Was in user-mode. */
914 lwi r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
915 swi r11, r1, PTO+PT_R1; /* Store user SP. */
917 swi r11, r0, TOPHYS(PER_CPU(KM)); /* Now we're in kernel-mode. */
918 2: lwi r31, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */
919 /* Save away the syscall number. */
920 swi r0, r1, PTO+PT_R0;
923 addi r5, r0, SIGTRAP /* send the trap signal */
924 add r6, r0, CURRENT_TASK; /* Get current task ptr into r11 */
925 addk r7, r0, r0 /* 3rd param zero */
928 la r11, r0, send_sig;
929 la r15, r0, dbtrap_call;
930 dbtrap_call: rtbd r11, 0;
933 set_bip; /* Ints masked for state restore*/
934 lwi r11, r1, PTO+PT_MODE;
937 /* Get current task ptr into r11 */
938 add r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
939 lwi r11, r11, TS_THREAD_INFO; /* get thread info */
940 lwi r11, r11, TI_FLAGS; /* get flags in thread info */
941 andi r11, r11, _TIF_NEED_RESCHED;
944 /* Call the scheduler before returning from a syscall/trap. */
946 bralid r15, schedule; /* Call scheduler */
947 nop; /* delay slot */
948 /* XXX Is PT_DTRACE handling needed here? */
949 /* XXX m68knommu also checks TASK_STATE & TASK_COUNTER here. */
951 /* Maybe handle a signal */
952 5: add r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
953 lwi r11, r11, TS_THREAD_INFO; /* get thread info */
954 lwi r11, r11, TI_FLAGS; /* get flags in thread info */
955 andi r11, r11, _TIF_SIGPENDING;
956 beqi r11, 1f; /* Signals to handle, handle them */
958 /* Handle a signal return; Pending signals should be in r18. */
959 /* Not all registers are saved by the normal trap/interrupt entry
960 points (for instance, call-saved registers (because the normal
961 C-compiler calling sequence in the kernel makes sure they're
962 preserved), and call-clobbered registers in the case of
963 traps), but signal handlers may want to examine or change the
964 complete register state. Here we save anything not saved by
965 the normal entry sequence, so that it may be safely restored
966 (in a possibly modified form) after do_signal returns. */
968 la r5, r1, PTO; /* Arg 1: struct pt_regs *regs */
969 add r6, r0, r0; /* Arg 2: sigset_t *oldset */
970 addi r7, r0, 0; /* Arg 3: int in_syscall */
971 bralid r15, do_signal; /* Handle any signals */
975 /* Finally, return to user state. */
976 1: swi r0, r0, PER_CPU(KM); /* Now officially in user state. */
977 add r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
978 swi r11, r0, PER_CPU(CURRENT_SAVE); /* save current */
982 lwi r3, r1, PTO+PT_R3; /* restore saved r3, r4 registers */
983 lwi r4, r1, PTO+PT_R4;
985 addik r1, r1, STATE_SAVE_SIZE /* Clean up stack space. */
988 lwi r1, r1, PT_R1 - PT_SIZE;
989 /* Restore user stack pointer. */
992 /* Return to kernel state. */
995 lwi r3, r1, PTO+PT_R3; /* restore saved r3, r4 registers */
996 lwi r4, r1, PTO+PT_R4;
998 addik r1, r1, STATE_SAVE_SIZE /* Clean up stack space. */
1002 DBTRAP_return: /* Make global symbol for debugging */
1003 rtbd r14, 0; /* Instructions to return from an IRQ */
1009 /* prepare return value */
1012 /* save registers in cpu_context */
1013 /* use r11 and r12, volatile registers, as temp register */
1014 /* give start of cpu_context for previous process */
1015 addik r11, r5, TI_CPU_CONTEXT
1018 /* skip volatile registers.
1019 * they are saved on stack when we jumped to _switch_to() */
1020 /* dedicated registers */
1021 swi r13, r11, CC_R13
1022 swi r14, r11, CC_R14
1023 swi r15, r11, CC_R15
1024 swi r16, r11, CC_R16
1025 swi r17, r11, CC_R17
1026 swi r18, r11, CC_R18
1027 /* save non-volatile registers */
1028 swi r19, r11, CC_R19
1029 swi r20, r11, CC_R20
1030 swi r21, r11, CC_R21
1031 swi r22, r11, CC_R22
1032 swi r23, r11, CC_R23
1033 swi r24, r11, CC_R24
1034 swi r25, r11, CC_R25
1035 swi r26, r11, CC_R26
1036 swi r27, r11, CC_R27
1037 swi r28, r11, CC_R28
1038 swi r29, r11, CC_R29
1039 swi r30, r11, CC_R30
1040 /* special purpose registers */
1043 swi r12, r11, CC_MSR
1046 swi r12, r11, CC_EAR
1049 swi r12, r11, CC_ESR
1052 swi r12, r11, CC_FSR
1054 /* update r31, the current */
1055 lwi r31, r6, TI_TASK/* give me pointer to task which will be next */
1056 /* stored it to current_save too */
1057 swi r31, r0, PER_CPU(CURRENT_SAVE)
1059 /* get new process' cpu context and restore */
1060 /* give me start where start context of next task */
1061 addik r11, r6, TI_CPU_CONTEXT
1063 /* non-volatile registers */
1064 lwi r30, r11, CC_R30
1065 lwi r29, r11, CC_R29
1066 lwi r28, r11, CC_R28
1067 lwi r27, r11, CC_R27
1068 lwi r26, r11, CC_R26
1069 lwi r25, r11, CC_R25
1070 lwi r24, r11, CC_R24
1071 lwi r23, r11, CC_R23
1072 lwi r22, r11, CC_R22
1073 lwi r21, r11, CC_R21
1074 lwi r20, r11, CC_R20
1075 lwi r19, r11, CC_R19
1076 /* dedicated registers */
1077 lwi r18, r11, CC_R18
1078 lwi r17, r11, CC_R17
1079 lwi r16, r11, CC_R16
1080 lwi r15, r11, CC_R15
1081 lwi r14, r11, CC_R14
1082 lwi r13, r11, CC_R13
1083 /* skip volatile registers */
1087 /* special purpose registers */
1088 lwi r12, r11, CC_FSR
1091 lwi r12, r11, CC_MSR
1099 brai 0x70; /* Jump back to FS-boot */
1104 swi r5, r0, 0x250 + TOPHYS(r0_ram)
1107 swi r5, r0, 0x254 + TOPHYS(r0_ram)
1110 /* These are compiled and loaded into high memory, then
1111 * copied into place in mach_early_setup */
1112 .section .init.ivt, "ax"
1114 /* this is very important - here is the reset vector */
1115 /* in current MMU branch you don't care what is here - it is
1116 * used from bootloader site - but this is correct for FS-BOOT */
1119 brai TOPHYS(_user_exception); /* syscall handler */
1120 brai TOPHYS(_interrupt); /* Interrupt handler */
1121 brai TOPHYS(_break); /* nmi trap handler */
1122 brai TOPHYS(_hw_exception_handler); /* HW exception handler */
1125 brai TOPHYS(_debug_exception); /* debug trap handler*/
1127 .section .rodata,"a"
1128 #include "syscall_table.S"
1130 syscall_table_size=(.-sys_call_table)