arch/microblaze/kernel/entry.S

   1 /*
   2  * Low-level system-call handling, trap handlers and context-switching
   3  *
   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>
   9  *
  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.
  13  *
  14  * Written by Miles Bader <miles@gnu.org>
  15  * Heavily modified by John Williams for Microblaze
  16  */
  17
  18 #include <linux/sys.h>
  19 #include <linux/linkage.h>
  20
  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>
  27
  28 #include <asm/page.h>
  29 #include <asm/unistd.h>
  30
  31 #include <linux/errno.h>
  32 #include <asm/signal.h>
  33
  34 #undef DEBUG
  35
  36 /* The size of a state save frame. */
  37 #define STATE_SAVE_SIZE         (PT_SIZE + STATE_SAVE_ARG_SPACE)
  38
  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 */
  41
  42 #define C_ENTRY(name)   .globl name; .align 4; name
  43
  44 /*
  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
  48  */
  49 #if CONFIG_XILINX_MICROBLAZE0_USE_MSR_INSTR
  50         .macro  clear_bip
  51         msrclr  r0, MSR_BIP
  52         .endm
  53
  54         .macro  set_bip
  55         msrset  r0, MSR_BIP
  56         .endm
  57
  58         .macro  clear_eip
  59         msrclr  r0, MSR_EIP
  60         .endm
  61
  62         .macro  set_ee
  63         msrset  r0, MSR_EE
  64         .endm
  65
  66         .macro  disable_irq
  67         msrclr  r0, MSR_IE
  68         .endm
  69
  70         .macro  enable_irq
  71         msrset  r0, MSR_IE
  72         .endm
  73
  74         .macro  set_ums
  75         msrset  r0, MSR_UMS
  76         msrclr  r0, MSR_VMS
  77         .endm
  78
  79         .macro  set_vms
  80         msrclr  r0, MSR_UMS
  81         msrset  r0, MSR_VMS
  82         .endm
  83
  84         .macro  clear_ums
  85         msrclr  r0, MSR_UMS
  86         .endm
  87
  88         .macro  clear_vms_ums
  89         msrclr  r0, MSR_VMS | MSR_UMS
  90         .endm
  91 #else
  92         .macro  clear_bip
  93         mfs     r11, rmsr
  94         andi    r11, r11, ~MSR_BIP
  95         mts     rmsr, r11
  96         .endm
  97
  98         .macro  set_bip
  99         mfs     r11, rmsr
 100         ori     r11, r11, MSR_BIP
 101         mts     rmsr, r11
 102         .endm
 103
 104         .macro  clear_eip
 105         mfs     r11, rmsr
 106         andi    r11, r11, ~MSR_EIP
 107         mts     rmsr, r11
 108         .endm
 109
 110         .macro  set_ee
 111         mfs     r11, rmsr
 112         ori     r11, r11, MSR_EE
 113         mts     rmsr, r11
 114         .endm
 115
 116         .macro  disable_irq
 117         mfs     r11, rmsr
 118         andi    r11, r11, ~MSR_IE
 119         mts     rmsr, r11
 120         .endm
 121
 122         .macro  enable_irq
 123         mfs     r11, rmsr
 124         ori     r11, r11, MSR_IE
 125         mts     rmsr, r11
 126         .endm
 127
 128         .macro set_ums
 129         mfs     r11, rmsr
 130         ori     r11, r11, MSR_VMS
 131         andni   r11, r11, MSR_UMS
 132         mts     rmsr, r11
 133         .endm
 134
 135         .macro  set_vms
 136         mfs     r11, rmsr
 137         ori     r11, r11, MSR_VMS
 138         andni   r11, r11, MSR_UMS
 139         mts     rmsr, r11
 140         .endm
 141
 142         .macro  clear_ums
 143         mfs     r11, rmsr
 144         andni   r11, r11, MSR_UMS
 145         mts     rmsr,r11
 146         .endm
 147
 148         .macro  clear_vms_ums
 149         mfs     r11, rmsr
 150         andni   r11, r11, (MSR_VMS|MSR_UMS)
 151         mts     rmsr,r11
 152         .endm
 153 #endif
 154
 155 /* Define how to call high-level functions. With MMU, virtual mode must be
 156  * enabled when calling the high-level function. Clobbers R11.
 157  * VM_ON, VM_OFF, DO_JUMP_BIPCLR, DO_CALL
 158  */
 159
 160 /* turn on virtual protected mode save */
 161 #define VM_ON           \
 162         set_ums;        \
 163         rted    r0, 2f; \
 164         nop; \
 165 2:
 166
 167 /* turn off virtual protected mode save and user mode save*/
 168 #define VM_OFF                  \
 169         clear_vms_ums;          \
 170         rted    r0, TOPHYS(1f); \
 171         nop; \
 172 1:
 173
 174 #define SAVE_REGS \
 175         swi     r2, r1, PTO+PT_R2;      /* Save SDA */                  \
 176         swi     r3, r1, PTO+PT_R3;                                      \
 177         swi     r4, r1, PTO+PT_R4;                                      \
 178         swi     r5, r1, PTO+PT_R5;                                      \
 179         swi     r6, r1, PTO+PT_R6;                                      \
 180         swi     r7, r1, PTO+PT_R7;                                      \
 181         swi     r8, r1, PTO+PT_R8;                                      \
 182         swi     r9, r1, PTO+PT_R9;                                      \
 183         swi     r10, r1, PTO+PT_R10;                                    \
 184         swi     r11, r1, PTO+PT_R11;    /* save clobbered regs after rval */\
 185         swi     r12, r1, PTO+PT_R12;                                    \
 186         swi     r13, r1, PTO+PT_R13;    /* Save SDA2 */                 \
 187         swi     r14, r1, PTO+PT_PC;     /* PC, before IRQ/trap */       \
 188         swi     r15, r1, PTO+PT_R15;    /* Save LP */                   \
 189         swi     r18, r1, PTO+PT_R18;    /* Save asm scratch reg */      \
 190         swi     r19, r1, PTO+PT_R19;                                    \
 191         swi     r20, r1, PTO+PT_R20;                                    \
 192         swi     r21, r1, PTO+PT_R21;                                    \
 193         swi     r22, r1, PTO+PT_R22;                                    \
 194         swi     r23, r1, PTO+PT_R23;                                    \
 195         swi     r24, r1, PTO+PT_R24;                                    \
 196         swi     r25, r1, PTO+PT_R25;                                    \
 197         swi     r26, r1, PTO+PT_R26;                                    \
 198         swi     r27, r1, PTO+PT_R27;                                    \
 199         swi     r28, r1, PTO+PT_R28;                                    \
 200         swi     r29, r1, PTO+PT_R29;                                    \
 201         swi     r30, r1, PTO+PT_R30;                                    \
 202         swi     r31, r1, PTO+PT_R31;    /* Save current task reg */     \
 203         mfs     r11, rmsr;              /* save MSR */                  \
 204         swi     r11, r1, PTO+PT_MSR;
 205
 206 #define RESTORE_REGS \
 207         lwi     r11, r1, PTO+PT_MSR;                                    \
 208         mts     rmsr , r11;                                             \
 209         lwi     r2, r1, PTO+PT_R2;      /* restore SDA */               \
 210         lwi     r3, r1, PTO+PT_R3;                                      \
 211         lwi     r4, r1, PTO+PT_R4;                                      \
 212         lwi     r5, r1, PTO+PT_R5;                                      \
 213         lwi     r6, r1, PTO+PT_R6;                                      \
 214         lwi     r7, r1, PTO+PT_R7;                                      \
 215         lwi     r8, r1, PTO+PT_R8;                                      \
 216         lwi     r9, r1, PTO+PT_R9;                                      \
 217         lwi     r10, r1, PTO+PT_R10;                                    \
 218         lwi     r11, r1, PTO+PT_R11;    /* restore clobbered regs after rval */\
 219         lwi     r12, r1, PTO+PT_R12;                                    \
 220         lwi     r13, r1, PTO+PT_R13;    /* restore SDA2 */              \
 221         lwi     r14, r1, PTO+PT_PC;     /* RESTORE_LINK PC, before IRQ/trap */\
 222         lwi     r15, r1, PTO+PT_R15;    /* restore LP */                \
 223         lwi     r18, r1, PTO+PT_R18;    /* restore asm scratch reg */   \
 224         lwi     r19, r1, PTO+PT_R19;                                    \
 225         lwi     r20, r1, PTO+PT_R20;                                    \
 226         lwi     r21, r1, PTO+PT_R21;                                    \
 227         lwi     r22, r1, PTO+PT_R22;                                    \
 228         lwi     r23, r1, PTO+PT_R23;                                    \
 229         lwi     r24, r1, PTO+PT_R24;                                    \
 230         lwi     r25, r1, PTO+PT_R25;                                    \
 231         lwi     r26, r1, PTO+PT_R26;                                    \
 232         lwi     r27, r1, PTO+PT_R27;                                    \
 233         lwi     r28, r1, PTO+PT_R28;                                    \
 234         lwi     r29, r1, PTO+PT_R29;                                    \
 235         lwi     r30, r1, PTO+PT_R30;                                    \
 236         lwi     r31, r1, PTO+PT_R31;    /* Restore cur task reg */
 237
 238 #define SAVE_STATE      \
 239         swi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP)); /* save stack */     \
 240         /* See if already in kernel mode.*/                             \
 241         mfs     r1, rmsr;                                               \
 242         andi    r1, r1, MSR_UMS;                                        \
 243         bnei    r1, 1f;                                         \
 244         /* Kernel-mode state save.  */                                  \
 245         /* Reload kernel stack-ptr. */                                  \
 246         lwi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP));                      \
 247         /* FIXME: I can add these two lines to one */                   \
 248         /* tophys(r1,r1); */                                            \
 249         /* addik        r1, r1, -STATE_SAVE_SIZE; */                    \
 250         addik   r1, r1, CONFIG_KERNEL_BASE_ADDR - CONFIG_KERNEL_START - STATE_SAVE_SIZE; \
 251         SAVE_REGS                                                       \
 252         brid    2f;                                                     \
 253         swi     r1, r1, PTO+PT_MODE;                                    \
 254 1:      /* User-mode state save.  */                                    \
 255         lwi     r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */\
 256         tophys(r1,r1);                                                  \
 257         lwi     r1, r1, TS_THREAD_INFO; /* get the thread info */       \
 258         /* MS these three instructions can be added to one */           \
 259         /* addik        r1, r1, THREAD_SIZE; */                         \
 260         /* tophys(r1,r1); */                                            \
 261         /* addik        r1, r1, -STATE_SAVE_SIZE; */                    \
 262         addik r1, r1, THREAD_SIZE + CONFIG_KERNEL_BASE_ADDR - CONFIG_KERNEL_START - STATE_SAVE_SIZE; \
 263         SAVE_REGS                                                       \
 264         lwi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));                     \
 265         swi     r11, r1, PTO+PT_R1; /* Store user SP.  */               \
 266         swi     r0, r1, PTO + PT_MODE; /* Was in user-mode.  */         \
 267         /* MS: I am clearing UMS even in case when I come from kernel space */ \
 268         clear_ums;                                                      \
 269 2:      lwi     CURRENT_TASK, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
 270
 271 .text
 272
 273 /*
 274  * User trap.
 275  *
 276  * System calls are handled here.
 277  *
 278  * Syscall protocol:
 279  * Syscall number in r12, args in r5-r10
 280  * Return value in r3
 281  *
 282  * Trap entered via brki instruction, so BIP bit is set, and interrupts
 283  * are masked. This is nice, means we don't have to CLI before state save
 284  */
 285 C_ENTRY(_user_exception):
 286         addi    r14, r14, 4     /* return address is 4 byte after call */
 287         swi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP)) /* save stack */
 288
 289         lwi     r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */
 290         tophys(r1,r1);
 291         lwi     r1, r1, TS_THREAD_INFO; /* get stack from task_struct */
 292         /* MS these three instructions can be added to one */
 293         /* addik        r1, r1, THREAD_SIZE; */
 294         /* tophys(r1,r1); */
 295         /* addik        r1, r1, -STATE_SAVE_SIZE; */
 296         addik r1, r1, THREAD_SIZE + CONFIG_KERNEL_BASE_ADDR - CONFIG_KERNEL_START - STATE_SAVE_SIZE;
 297         SAVE_REGS
 298
 299         lwi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
 300         swi     r11, r1, PTO+PT_R1;             /* Store user SP.  */
 301         clear_ums;
 302         lwi     CURRENT_TASK, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
 303         /* Save away the syscall number.  */
 304         swi     r12, r1, PTO+PT_R0;
 305         tovirt(r1,r1)
 306
 307 /* where the trap should return need -8 to adjust for rtsd r15, 8*/
 308 /* Jump to the appropriate function for the system call number in r12
 309  * (r12 is not preserved), or return an error if r12 is not valid. The LP
 310  * register should point to the location where
 311  * the called function should return.  [note that MAKE_SYS_CALL uses label 1] */
 312
 313         /* Step into virtual mode */
 314         rtbd    r0, 3f
 315         nop
 316 3:
 317         lwi     r11, CURRENT_TASK, TS_THREAD_INFO /* get thread info */
 318         lwi     r11, r11, TI_FLAGS       /* get flags in thread info */
 319         andi    r11, r11, _TIF_WORK_SYSCALL_MASK
 320         beqi    r11, 4f
 321
 322         addik   r3, r0, -ENOSYS
 323         swi     r3, r1, PTO + PT_R3
 324         brlid   r15, do_syscall_trace_enter
 325         addik   r5, r1, PTO + PT_R0
 326
 327         # do_syscall_trace_enter returns the new syscall nr.
 328         addk    r12, r0, r3
 329         lwi     r5, r1, PTO+PT_R5;
 330         lwi     r6, r1, PTO+PT_R6;
 331         lwi     r7, r1, PTO+PT_R7;
 332         lwi     r8, r1, PTO+PT_R8;
 333         lwi     r9, r1, PTO+PT_R9;
 334         lwi     r10, r1, PTO+PT_R10;
 335 4:
 336 /* Jump to the appropriate function for the system call number in r12
 337  * (r12 is not preserved), or return an error if r12 is not valid.
 338  * The LP register should point to the location where the called function
 339  * should return.  [note that MAKE_SYS_CALL uses label 1] */
 340         /* See if the system call number is valid */
 341         addi    r11, r12, -__NR_syscalls;
 342         bgei    r11,5f;
 343         /* Figure out which function to use for this system call.  */
 344         /* Note Microblaze barrel shift is optional, so don't rely on it */
 345         add     r12, r12, r12;                  /* convert num -> ptr */
 346         add     r12, r12, r12;
 347
 348 #ifdef DEBUG
 349         /* Trac syscalls and stored them to r0_ram */
 350         lwi     r3, r12, 0x400 + r0_ram
 351         addi    r3, r3, 1
 352         swi     r3, r12, 0x400 + r0_ram
 353 #endif
 354
 355         # Find and jump into the syscall handler.
 356         lwi     r12, r12, sys_call_table
 357         /* where the trap should return need -8 to adjust for rtsd r15, 8 */
 358         addi    r15, r0, ret_from_trap-8
 359         bra     r12
 360
 361         /* The syscall number is invalid, return an error.  */
 362 5:
 363         rtsd    r15, 8;         /* looks like a normal subroutine return */
 364         addi    r3, r0, -ENOSYS;
 365
 366 /* Entry point used to return from a syscall/trap */
 367 /* We re-enable BIP bit before state restore */
 368 C_ENTRY(ret_from_trap):
 369         swi     r3, r1, PTO + PT_R3
 370         swi     r4, r1, PTO + PT_R4
 371
 372         /* We're returning to user mode, so check for various conditions that
 373          * trigger rescheduling. */
 374         /* FIXME: Restructure all these flag checks. */
 375         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 376         lwi     r11, r11, TI_FLAGS;             /* get flags in thread info */
 377         andi    r11, r11, _TIF_WORK_SYSCALL_MASK
 378         beqi    r11, 1f
 379
 380         brlid   r15, do_syscall_trace_leave
 381         addik   r5, r1, PTO + PT_R0
 382 1:
 383         /* We're returning to user mode, so check for various conditions that
 384          * trigger rescheduling. */
 385         /* get thread info from current task */
 386         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;
 387         lwi     r11, r11, TI_FLAGS;             /* get flags in thread info */
 388         andi    r11, r11, _TIF_NEED_RESCHED;
 389         beqi    r11, 5f;
 390
 391         bralid  r15, schedule;  /* Call scheduler */
 392         nop;                            /* delay slot */
 393
 394         /* Maybe handle a signal */
 395 5:      /* get thread info from current task*/
 396         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;
 397         lwi     r11, r11, TI_FLAGS;     /* get flags in thread info */
 398         andi    r11, r11, _TIF_SIGPENDING;
 399         beqi    r11, 1f;                /* Signals to handle, handle them */
 400
 401         addik   r5, r1, PTO;            /* Arg 1: struct pt_regs *regs */
 402         addi    r7, r0, 1;              /* Arg 3: int in_syscall */
 403         bralid  r15, do_signal; /* Handle any signals */
 404         add     r6, r0, r0;             /* Arg 2: sigset_t *oldset */
 405
 406 /* Finally, return to user state.  */
 407 1:      set_bip;                        /*  Ints masked for state restore */
 408         swi     CURRENT_TASK, r0, PER_CPU(CURRENT_SAVE); /* save current */
 409         VM_OFF;
 410         tophys(r1,r1);
 411         RESTORE_REGS;
 412         addik   r1, r1, STATE_SAVE_SIZE         /* Clean up stack space.  */
 413         lwi     r1, r1, PT_R1 - PT_SIZE;/* Restore user stack pointer. */
 414 TRAP_return:            /* Make global symbol for debugging */
 415         rtbd    r14, 0; /* Instructions to return from an IRQ */
 416         nop;
 417
 418
 419 /* These syscalls need access to the struct pt_regs on the stack, so we
 420    implement them in assembly (they're basically all wrappers anyway).  */
 421
 422 C_ENTRY(sys_fork_wrapper):
 423         addi    r5, r0, SIGCHLD                 /* Arg 0: flags */
 424         lwi     r6, r1, PTO+PT_R1       /* Arg 1: child SP (use parent's) */
 425         addik   r7, r1, PTO                     /* Arg 2: parent context */
 426         add     r8. r0, r0                      /* Arg 3: (unused) */
 427         add     r9, r0, r0;                     /* Arg 4: (unused) */
 428         brid    do_fork         /* Do real work (tail-call) */
 429         add     r10, r0, r0;                    /* Arg 5: (unused) */
 430
 431 /* This the initial entry point for a new child thread, with an appropriate
 432    stack in place that makes it look the the child is in the middle of an
 433    syscall.  This function is actually `returned to' from switch_thread
 434    (copy_thread makes ret_from_fork the return address in each new thread's
 435    saved context).  */
 436 C_ENTRY(ret_from_fork):
 437         bralid  r15, schedule_tail; /* ...which is schedule_tail's arg */
 438         add     r3, r5, r0;     /* switch_thread returns the prev task */
 439                                 /* ( in the delay slot ) */
 440         brid    ret_from_trap;  /* Do normal trap return */
 441         add     r3, r0, r0;     /* Child's fork call should return 0. */
 442
 443 C_ENTRY(sys_vfork):
 444         brid    microblaze_vfork        /* Do real work (tail-call) */
 445         addik   r5, r1, PTO
 446
 447 C_ENTRY(sys_clone):
 448         bnei    r6, 1f;                 /* See if child SP arg (arg 1) is 0. */
 449         lwi     r6, r1, PTO + PT_R1;    /* If so, use paret's stack ptr */
 450 1:      addik   r7, r1, PTO;                    /* Arg 2: parent context */
 451         add     r8, r0, r0;                     /* Arg 3: (unused) */
 452         add     r9, r0, r0;                     /* Arg 4: (unused) */
 453         brid    do_fork         /* Do real work (tail-call) */
 454         add     r10, r0, r0;                    /* Arg 5: (unused) */
 455
 456 C_ENTRY(sys_execve):
 457         brid    microblaze_execve;      /* Do real work (tail-call).*/
 458         addik   r8, r1, PTO;            /* add user context as 4th arg */
 459
 460 C_ENTRY(sys_rt_sigreturn_wrapper):
 461         brid    sys_rt_sigreturn        /* Do real work */
 462         addik   r5, r1, PTO;            /* add user context as 1st arg */
 463
 464 /*
 465  * HW EXCEPTION rutine start
 466  */
 467 C_ENTRY(full_exception_trap):
 468         /* adjust exception address for privileged instruction
 469          * for finding where is it */
 470         addik   r17, r17, -4
 471         SAVE_STATE /* Save registers */
 472         /* PC, before IRQ/trap - this is one instruction above */
 473         swi     r17, r1, PTO+PT_PC;
 474         tovirt(r1,r1)
 475         /* FIXME this can be store directly in PT_ESR reg.
 476          * I tested it but there is a fault */
 477         /* where the trap should return need -8 to adjust for rtsd r15, 8 */
 478         addik   r15, r0, ret_from_exc - 8
 479         mfs     r6, resr
 480         mfs     r7, rfsr;               /* save FSR */
 481         mts     rfsr, r0;       /* Clear sticky fsr */
 482         rted    r0, full_exception
 483         addik   r5, r1, PTO              /* parameter struct pt_regs * regs */
 484
 485 /*
 486  * Unaligned data trap.
 487  *
 488  * Unaligned data trap last on 4k page is handled here.
 489  *
 490  * Trap entered via exception, so EE bit is set, and interrupts
 491  * are masked.  This is nice, means we don't have to CLI before state save
 492  *
 493  * The assembler routine is in "arch/microblaze/kernel/hw_exception_handler.S"
 494  */
 495 C_ENTRY(unaligned_data_trap):
 496         /* MS: I have to save r11 value and then restore it because
 497          * set_bit, clear_eip, set_ee use r11 as temp register if MSR
 498          * instructions are not used. We don't need to do if MSR instructions
 499          * are used and they use r0 instead of r11.
 500          * I am using ENTRY_SP which should be primary used only for stack
 501          * pointer saving. */
 502         swi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
 503         set_bip;        /* equalize initial state for all possible entries */
 504         clear_eip;
 505         set_ee;
 506         lwi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
 507         SAVE_STATE              /* Save registers.*/
 508         /* PC, before IRQ/trap - this is one instruction above */
 509         swi     r17, r1, PTO+PT_PC;
 510         tovirt(r1,r1)
 511         /* where the trap should return need -8 to adjust for rtsd r15, 8 */
 512         addik   r15, r0, ret_from_exc-8
 513         mfs     r3, resr                /* ESR */
 514         mfs     r4, rear                /* EAR */
 515         rtbd    r0, _unaligned_data_exception
 516         addik   r7, r1, PTO             /* parameter struct pt_regs * regs */
 517
 518 /*
 519  * Page fault traps.
 520  *
 521  * If the real exception handler (from hw_exception_handler.S) didn't find
 522  * the mapping for the process, then we're thrown here to handle such situation.
 523  *
 524  * Trap entered via exceptions, so EE bit is set, and interrupts
 525  * are masked.  This is nice, means we don't have to CLI before state save
 526  *
 527  * Build a standard exception frame for TLB Access errors.  All TLB exceptions
 528  * will bail out to this point if they can't resolve the lightweight TLB fault.
 529  *
 530  * The C function called is in "arch/microblaze/mm/fault.c", declared as:
 531  * void do_page_fault(struct pt_regs *regs,
 532  *                              unsigned long address,
 533  *                              unsigned long error_code)
 534  */
 535 /* data and intruction trap - which is choose is resolved int fault.c */
 536 C_ENTRY(page_fault_data_trap):
 537         SAVE_STATE              /* Save registers.*/
 538         /* PC, before IRQ/trap - this is one instruction above */
 539         swi     r17, r1, PTO+PT_PC;
 540         tovirt(r1,r1)
 541         /* where the trap should return need -8 to adjust for rtsd r15, 8 */
 542         addik   r15, r0, ret_from_exc-8
 543         mfs     r6, rear                /* parameter unsigned long address */
 544         mfs     r7, resr                /* parameter unsigned long error_code */
 545         rted    r0, do_page_fault
 546         addik   r5, r1, PTO             /* parameter struct pt_regs * regs */
 547
 548 C_ENTRY(page_fault_instr_trap):
 549         SAVE_STATE              /* Save registers.*/
 550         /* PC, before IRQ/trap - this is one instruction above */
 551         swi     r17, r1, PTO+PT_PC;
 552         tovirt(r1,r1)
 553         /* where the trap should return need -8 to adjust for rtsd r15, 8 */
 554         addik   r15, r0, ret_from_exc-8
 555         mfs     r6, rear                /* parameter unsigned long address */
 556         ori     r7, r0, 0               /* parameter unsigned long error_code */
 557         rted    r0, do_page_fault
 558         addik   r5, r1, PTO             /* parameter struct pt_regs * regs */
 559
 560 /* Entry point used to return from an exception.  */
 561 C_ENTRY(ret_from_exc):
 562         lwi     r11, r1, PTO + PT_MODE;
 563         bnei    r11, 2f;                /* See if returning to kernel mode, */
 564                                         /* ... if so, skip resched &c.  */
 565
 566         /* We're returning to user mode, so check for various conditions that
 567            trigger rescheduling. */
 568         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 569         lwi     r11, r11, TI_FLAGS;     /* get flags in thread info */
 570         andi    r11, r11, _TIF_NEED_RESCHED;
 571         beqi    r11, 5f;
 572
 573 /* Call the scheduler before returning from a syscall/trap. */
 574         bralid  r15, schedule;  /* Call scheduler */
 575         nop;                            /* delay slot */
 576
 577         /* Maybe handle a signal */
 578 5:      lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 579         lwi     r11, r11, TI_FLAGS;     /* get flags in thread info */
 580         andi    r11, r11, _TIF_SIGPENDING;
 581         beqi    r11, 1f;                /* Signals to handle, handle them */
 582
 583         /*
 584          * Handle a signal return; Pending signals should be in r18.
 585          *
 586          * Not all registers are saved by the normal trap/interrupt entry
 587          * points (for instance, call-saved registers (because the normal
 588          * C-compiler calling sequence in the kernel makes sure they're
 589          * preserved), and call-clobbered registers in the case of
 590          * traps), but signal handlers may want to examine or change the
 591          * complete register state.  Here we save anything not saved by
 592          * the normal entry sequence, so that it may be safely restored
 593          * (in a possibly modified form) after do_signal returns. */
 594         addik   r5, r1, PTO;            /* Arg 1: struct pt_regs *regs */
 595         addi    r7, r0, 0;              /* Arg 3: int in_syscall */
 596         bralid  r15, do_signal; /* Handle any signals */
 597         add     r6, r0, r0;             /* Arg 2: sigset_t *oldset */
 598
 599 /* Finally, return to user state.  */
 600 1:      set_bip;                        /* Ints masked for state restore */
 601         swi     CURRENT_TASK, r0, PER_CPU(CURRENT_SAVE); /* save current */
 602         VM_OFF;
 603         tophys(r1,r1);
 604
 605         RESTORE_REGS;
 606         addik   r1, r1, STATE_SAVE_SIZE         /* Clean up stack space.  */
 607
 608         lwi     r1, r1, PT_R1 - PT_SIZE; /* Restore user stack pointer. */
 609         bri     6f;
 610 /* Return to kernel state.  */
 611 2:      set_bip;                        /* Ints masked for state restore */
 612         VM_OFF;
 613         tophys(r1,r1);
 614         RESTORE_REGS;
 615         addik   r1, r1, STATE_SAVE_SIZE         /* Clean up stack space.  */
 616
 617         tovirt(r1,r1);
 618 6:
 619 EXC_return:             /* Make global symbol for debugging */
 620         rtbd    r14, 0; /* Instructions to return from an IRQ */
 621         nop;
 622
 623 /*
 624  * HW EXCEPTION rutine end
 625  */
 626
 627 /*
 628  * Hardware maskable interrupts.
 629  *
 630  * The stack-pointer (r1) should have already been saved to the memory
 631  * location PER_CPU(ENTRY_SP).
 632  */
 633 C_ENTRY(_interrupt):
 634 /* MS: we are in physical address */
 635 /* Save registers, switch to proper stack, convert SP to virtual.*/
 636         swi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP))
 637         /* MS: See if already in kernel mode. */
 638         mfs     r1, rmsr
 639         nop
 640         andi    r1, r1, MSR_UMS
 641         bnei    r1, 1f
 642
 643 /* Kernel-mode state save. */
 644         lwi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP))
 645         tophys(r1,r1); /* MS: I have in r1 physical address where stack is */
 646         /* save registers */
 647 /* MS: Make room on the stack -> activation record */
 648         addik   r1, r1, -STATE_SAVE_SIZE;
 649         SAVE_REGS
 650         brid    2f;
 651         swi     r1, r1, PTO + PT_MODE; /* 0 - user mode, 1 - kernel mode */
 652 1:
 653 /* User-mode state save. */
 654  /* MS: get the saved current */
 655         lwi     r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
 656         tophys(r1,r1);
 657         lwi     r1, r1, TS_THREAD_INFO;
 658         addik   r1, r1, THREAD_SIZE;
 659         tophys(r1,r1);
 660         /* save registers */
 661         addik   r1, r1, -STATE_SAVE_SIZE;
 662         SAVE_REGS
 663         /* calculate mode */
 664         swi     r0, r1, PTO + PT_MODE;
 665         lwi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
 666         swi     r11, r1, PTO+PT_R1;
 667         clear_ums;
 668 2:
 669         lwi     CURRENT_TASK, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
 670         tovirt(r1,r1)
 671         addik   r15, r0, irq_call;
 672 irq_call:rtbd   r0, do_IRQ;
 673         addik   r5, r1, PTO;
 674
 675 /* MS: we are in virtual mode */
 676 ret_from_irq:
 677         lwi     r11, r1, PTO + PT_MODE;
 678         bnei    r11, 2f;
 679
 680         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;
 681         lwi     r11, r11, TI_FLAGS; /* MS: get flags from thread info */
 682         andi    r11, r11, _TIF_NEED_RESCHED;
 683         beqi    r11, 5f
 684         bralid  r15, schedule;
 685         nop; /* delay slot */
 686
 687     /* Maybe handle a signal */
 688 5:      lwi     r11, CURRENT_TASK, TS_THREAD_INFO; /* MS: get thread info */
 689         lwi     r11, r11, TI_FLAGS; /* get flags in thread info */
 690         andi    r11, r11, _TIF_SIGPENDING;
 691         beqid   r11, no_intr_resched
 692 /* Handle a signal return; Pending signals should be in r18. */
 693         addi    r7, r0, 0; /* Arg 3: int in_syscall */
 694         addik   r5, r1, PTO; /* Arg 1: struct pt_regs *regs */
 695         bralid  r15, do_signal; /* Handle any signals */
 696         add     r6, r0, r0; /* Arg 2: sigset_t *oldset */
 697
 698 /* Finally, return to user state. */
 699 no_intr_resched:
 700     /* Disable interrupts, we are now committed to the state restore */
 701         disable_irq
 702         swi     CURRENT_TASK, r0, PER_CPU(CURRENT_SAVE);
 703         VM_OFF;
 704         tophys(r1,r1);
 705         RESTORE_REGS
 706         addik   r1, r1, STATE_SAVE_SIZE /* MS: Clean up stack space. */
 707         lwi     r1, r1, PT_R1 - PT_SIZE;
 708         bri     6f;
 709 /* MS: Return to kernel state. */
 710 2:
 711 #ifdef CONFIG_PREEMPT
 712         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;
 713         /* MS: get preempt_count from thread info */
 714         lwi     r5, r11, TI_PREEMPT_COUNT;
 715         bgti    r5, restore;
 716
 717         lwi     r5, r11, TI_FLAGS;              /* get flags in thread info */
 718         andi    r5, r5, _TIF_NEED_RESCHED;
 719         beqi    r5, restore /* if zero jump over */
 720
 721 preempt:
 722         /* interrupts are off that's why I am calling preempt_chedule_irq */
 723         bralid  r15, preempt_schedule_irq
 724         nop
 725         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 726         lwi     r5, r11, TI_FLAGS;              /* get flags in thread info */
 727         andi    r5, r5, _TIF_NEED_RESCHED;
 728         bnei    r5, preempt /* if non zero jump to resched */
 729 restore:
 730 #endif
 731         VM_OFF /* MS: turn off MMU */
 732         tophys(r1,r1)
 733         RESTORE_REGS
 734         addik   r1, r1, STATE_SAVE_SIZE /* MS: Clean up stack space. */
 735         tovirt(r1,r1);
 736 6:
 737 IRQ_return: /* MS: Make global symbol for debugging */
 738         rtid    r14, 0
 739         nop
 740
 741 /*
 742  * Debug trap for KGDB. Enter to _debug_exception by brki r16, 0x18
 743  * and call handling function with saved pt_regs
 744  */
 745 C_ENTRY(_debug_exception):
 746         /* BIP bit is set on entry, no interrupts can occur */
 747         swi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP))
 748
 749         mfs     r1, rmsr
 750         nop
 751         andi    r1, r1, MSR_UMS
 752         bnei    r1, 1f
 753 /* MS: Kernel-mode state save - kgdb */
 754         lwi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP)); /* Reload kernel stack-ptr*/
 755
 756         /* BIP bit is set on entry, no interrupts can occur */
 757         addik   r1, r1, CONFIG_KERNEL_BASE_ADDR - CONFIG_KERNEL_START - STATE_SAVE_SIZE;
 758         SAVE_REGS;
 759         /* save all regs to pt_reg structure */
 760         swi     r0, r1, PTO+PT_R0;      /* R0 must be saved too */
 761         swi     r14, r1, PTO+PT_R14     /* rewrite saved R14 value */
 762         swi     r16, r1, PTO+PT_R16
 763         swi     r16, r1, PTO+PT_PC; /* PC and r16 are the same */
 764         swi     r17, r1, PTO+PT_R17
 765         /* save special purpose registers to pt_regs */
 766         mfs     r11, rear;
 767         swi     r11, r1, PTO+PT_EAR;
 768         mfs     r11, resr;
 769         swi     r11, r1, PTO+PT_ESR;
 770         mfs     r11, rfsr;
 771         swi     r11, r1, PTO+PT_FSR;
 772
 773         /* stack pointer is in physical address at it is decrease
 774          * by STATE_SAVE_SIZE but we need to get correct R1 value */
 775         addik   r11, r1, CONFIG_KERNEL_START - CONFIG_KERNEL_BASE_ADDR + STATE_SAVE_SIZE;
 776         swi     r11, r1, PTO+PT_R1
 777         /* MS: r31 - current pointer isn't changed */
 778         tovirt(r1,r1)
 779 #ifdef CONFIG_KGDB
 780         addi    r5, r1, PTO /* pass pt_reg address as the first arg */
 781         la      r15, r0, dbtrap_call; /* return address */
 782         rtbd    r0, microblaze_kgdb_break
 783         nop;
 784 #endif
 785         /* MS: Place handler for brki from kernel space if KGDB is OFF.
 786          * It is very unlikely that another brki instruction is called. */
 787         bri 0
 788
 789 /* MS: User-mode state save - gdb */
 790 1:      lwi     r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */
 791         tophys(r1,r1);
 792         lwi     r1, r1, TS_THREAD_INFO; /* get the thread info */
 793         addik   r1, r1, THREAD_SIZE;    /* calculate kernel stack pointer */
 794         tophys(r1,r1);
 795
 796         addik   r1, r1, -STATE_SAVE_SIZE; /* Make room on the stack.  */
 797         SAVE_REGS;
 798         swi     r17, r1, PTO+PT_R17;
 799         swi     r16, r1, PTO+PT_R16;
 800         swi     r16, r1, PTO+PT_PC;     /* Save LP */
 801         swi     r0, r1, PTO + PT_MODE; /* Was in user-mode.  */
 802         lwi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
 803         swi     r11, r1, PTO+PT_R1; /* Store user SP.  */
 804         lwi     CURRENT_TASK, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
 805         tovirt(r1,r1)
 806         set_vms;
 807         addik   r5, r1, PTO;
 808         addik   r15, r0, dbtrap_call;
 809 dbtrap_call: /* Return point for kernel/user entry + 8 because of rtsd r15, 8 */
 810         rtbd    r0, sw_exception
 811         nop
 812
 813         /* MS: The first instruction for the second part of the gdb/kgdb */
 814         set_bip; /* Ints masked for state restore */
 815         lwi     r11, r1, PTO + PT_MODE;
 816         bnei    r11, 2f;
 817 /* MS: Return to user space - gdb */
 818         /* Get current task ptr into r11 */
 819         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 820         lwi     r11, r11, TI_FLAGS;     /* get flags in thread info */
 821         andi    r11, r11, _TIF_NEED_RESCHED;
 822         beqi    r11, 5f;
 823
 824         /* Call the scheduler before returning from a syscall/trap. */
 825         bralid  r15, schedule;  /* Call scheduler */
 826         nop;                            /* delay slot */
 827
 828         /* Maybe handle a signal */
 829 5:      lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 830         lwi     r11, r11, TI_FLAGS;     /* get flags in thread info */
 831         andi    r11, r11, _TIF_SIGPENDING;
 832         beqi    r11, 1f;                /* Signals to handle, handle them */
 833
 834         addik   r5, r1, PTO;            /* Arg 1: struct pt_regs *regs */
 835         addi  r7, r0, 0;        /* Arg 3: int in_syscall */
 836         bralid  r15, do_signal; /* Handle any signals */
 837         add     r6, r0, r0;             /* Arg 2: sigset_t *oldset */
 838
 839 /* Finally, return to user state.  */
 840 1:      swi     CURRENT_TASK, r0, PER_CPU(CURRENT_SAVE); /* save current */
 841         VM_OFF;
 842         tophys(r1,r1);
 843         /* MS: Restore all regs */
 844         RESTORE_REGS
 845         lwi     r17, r1, PTO+PT_R17;
 846         lwi     r16, r1, PTO+PT_R16;
 847         addik   r1, r1, STATE_SAVE_SIZE  /* Clean up stack space */
 848         lwi     r1, r1, PT_R1 - PT_SIZE; /* Restore user stack pointer */
 849 DBTRAP_return_user: /* MS: Make global symbol for debugging */
 850         rtbd    r16, 0; /* MS: Instructions to return from a debug trap */
 851         nop;
 852
 853 /* MS: Return to kernel state - kgdb */
 854 2:      VM_OFF;
 855         tophys(r1,r1);
 856         /* MS: Restore all regs */
 857         RESTORE_REGS
 858         lwi     r14, r1, PTO+PT_R14;
 859         lwi     r16, r1, PTO+PT_PC;
 860         lwi     r17, r1, PTO+PT_R17;
 861         addik   r1, r1, STATE_SAVE_SIZE; /* MS: Clean up stack space */
 862         tovirt(r1,r1);
 863 DBTRAP_return_kernel: /* MS: Make global symbol for debugging */
 864         rtbd    r16, 0; /* MS: Instructions to return from a debug trap */
 865         nop;
 866
 867
 868 ENTRY(_switch_to)
 869         /* prepare return value */
 870         addk    r3, r0, CURRENT_TASK
 871
 872         /* save registers in cpu_context */
 873         /* use r11 and r12, volatile registers, as temp register */
 874         /* give start of cpu_context for previous process */
 875         addik   r11, r5, TI_CPU_CONTEXT
 876         swi     r1, r11, CC_R1
 877         swi     r2, r11, CC_R2
 878         /* skip volatile registers.
 879          * they are saved on stack when we jumped to _switch_to() */
 880         /* dedicated registers */
 881         swi     r13, r11, CC_R13
 882         swi     r14, r11, CC_R14
 883         swi     r15, r11, CC_R15
 884         swi     r16, r11, CC_R16
 885         swi     r17, r11, CC_R17
 886         swi     r18, r11, CC_R18
 887         /* save non-volatile registers */
 888         swi     r19, r11, CC_R19
 889         swi     r20, r11, CC_R20
 890         swi     r21, r11, CC_R21
 891         swi     r22, r11, CC_R22
 892         swi     r23, r11, CC_R23
 893         swi     r24, r11, CC_R24
 894         swi     r25, r11, CC_R25
 895         swi     r26, r11, CC_R26
 896         swi     r27, r11, CC_R27
 897         swi     r28, r11, CC_R28
 898         swi     r29, r11, CC_R29
 899         swi     r30, r11, CC_R30
 900         /* special purpose registers */
 901         mfs     r12, rmsr
 902         swi     r12, r11, CC_MSR
 903         mfs     r12, rear
 904         swi     r12, r11, CC_EAR
 905         mfs     r12, resr
 906         swi     r12, r11, CC_ESR
 907         mfs     r12, rfsr
 908         swi     r12, r11, CC_FSR
 909
 910         /* update r31, the current-give me pointer to task which will be next */
 911         lwi     CURRENT_TASK, r6, TI_TASK
 912         /* stored it to current_save too */
 913         swi     CURRENT_TASK, r0, PER_CPU(CURRENT_SAVE)
 914
 915         /* get new process' cpu context and restore */
 916         /* give me start where start context of next task */
 917         addik   r11, r6, TI_CPU_CONTEXT
 918
 919         /* non-volatile registers */
 920         lwi     r30, r11, CC_R30
 921         lwi     r29, r11, CC_R29
 922         lwi     r28, r11, CC_R28
 923         lwi     r27, r11, CC_R27
 924         lwi     r26, r11, CC_R26
 925         lwi     r25, r11, CC_R25
 926         lwi     r24, r11, CC_R24
 927         lwi     r23, r11, CC_R23
 928         lwi     r22, r11, CC_R22
 929         lwi     r21, r11, CC_R21
 930         lwi     r20, r11, CC_R20
 931         lwi     r19, r11, CC_R19
 932         /* dedicated registers */
 933         lwi     r18, r11, CC_R18
 934         lwi     r17, r11, CC_R17
 935         lwi     r16, r11, CC_R16
 936         lwi     r15, r11, CC_R15
 937         lwi     r14, r11, CC_R14
 938         lwi     r13, r11, CC_R13
 939         /* skip volatile registers */
 940         lwi     r2, r11, CC_R2
 941         lwi     r1, r11, CC_R1
 942
 943         /* special purpose registers */
 944         lwi     r12, r11, CC_FSR
 945         mts     rfsr, r12
 946         lwi     r12, r11, CC_MSR
 947         mts     rmsr, r12
 948
 949         rtsd    r15, 8
 950         nop
 951
 952 ENTRY(_reset)
 953         brai    0x70; /* Jump back to FS-boot */
 954
 955         /* These are compiled and loaded into high memory, then
 956          * copied into place in mach_early_setup */
 957         .section        .init.ivt, "ax"
 958         .org    0x0
 959         /* this is very important - here is the reset vector */
 960         /* in current MMU branch you don't care what is here - it is
 961          * used from bootloader site - but this is correct for FS-BOOT */
 962         brai    0x70
 963         nop
 964         brai    TOPHYS(_user_exception); /* syscall handler */
 965         brai    TOPHYS(_interrupt);     /* Interrupt handler */
 966         brai    TOPHYS(_debug_exception);       /* debug trap handler */
 967         brai    TOPHYS(_hw_exception_handler);  /* HW exception handler */
 968
 969 .section .rodata,"a"
 970 #include "syscall_table.S"
 971
 972 syscall_table_size=(.-sys_call_table)
 973
 974 type_SYSCALL:
 975         .ascii "SYSCALL\0"
 976 type_IRQ:
 977         .ascii "IRQ\0"
 978 type_IRQ_PREEMPT:
 979         .ascii "IRQ (PREEMPTED)\0"
 980 type_SYSCALL_PREEMPT:
 981         .ascii " SYSCALL (PREEMPTED)\0"
 982
 983         /*
 984          * Trap decoding for stack unwinder
 985          * Tuples are (start addr, end addr, string)
 986          * If return address lies on [start addr, end addr],
 987          * unwinder displays 'string'
 988          */
 989
 990         .align 4
 991 .global microblaze_trap_handlers
 992 microblaze_trap_handlers:
 993         /* Exact matches come first */
 994         .word ret_from_trap; .word ret_from_trap   ; .word type_SYSCALL
 995         .word ret_from_irq ; .word ret_from_irq    ; .word type_IRQ
 996         /* Fuzzy matches go here */
 997         .word ret_from_irq ; .word no_intr_resched ; .word type_IRQ_PREEMPT
 998         .word ret_from_trap; .word TRAP_return     ; .word type_SYSCALL_PREEMPT
 999         /* End of table */
1000         .word 0               ; .word 0               ; .word 0